archematics/etc/deps/x_ite/x_ite.d.ts

declare module 'https://create3000.github.io/code/x_ite/latest/x_ite.mjs' {
  // This compilation-only file was replicated from the x_ite GitHub repository
  // https://github.com/create3000/x_ite
  // compliant with the GPL License, under which it was released.
 const X3D: X3D;
export default X3D;
export interface X3D {
   (callback?: () => void, fallback?: (error: Error) => void): Promise<void>;
   createBrowser(): X3DCanvasElement;
   getBrowser(via?: string | X3DCanvasElement): X3DBrowser;
   noConflict(): X3D;
   X3DConstants: X3DConstants;
   SFBool(arg: unknown): boolean;
   // NB. in all of the following `typeof Class` is an expression that
   // extracts the type of the constructor for Class.
   SFColor: typeof SFColor;
   SFColorRGBA: typeof SFColorRGBA;
   // Doubles and floats not different in JavaScript:
   SFDouble: typeof SFDouble;
   SFFloat: typeof SFDouble;

   SFImage: typeof SFImage;
   SFInt32: typeof SFInt32;

   // Doubles and floats same:
   SFMatrix3d: typeof SFMatrix3;
   SFMatrix3f: typeof SFMatrix3;
   SFMatrix4d: typeof SFMatrix4;
   SFMatrix4f: typeof SFMatrix4;

   // SFNode: typeof SFNode; // no working constructors, just one that throws
   SFRotation: typeof SFRotation;
   SFString: typeof SFString;
   SFTime: typeof SFTime;

   // Doubles and floats same:
   SFVec2d: typeof SFVec2;
   SFVec2f: typeof SFVec2;
   SFVec3d: typeof SFVec3;
   SFVec3f: typeof SFVec3;
   SFVec4d: typeof SFVec4;
   SFVec4f: typeof SFVec4;

   // All the array types:
   MFBool: typeof X3DArrayField<boolean>;
   MFColor: typeof X3DArrayField<SFColor>;
   MFColorRGBA: typeof X3DArrayField<SFColorRGBA>;
   MFDouble: typeof X3DArrayField<number>;
   MFFloat: typeof X3DArrayField<number>;
   MFImage: typeof X3DArrayField<SFImage>;
   MFMatrix3d: typeof X3DArrayField<SFMatrix3>;
   MFMatrix3f: typeof X3DArrayField<SFMatrix3>;
   MFMatrix4d:  typeof X3DArrayField<SFMatrix4>;
   MFMatrix4f:  typeof X3DArrayField<SFMatrix4>;
   MFInt32: typeof X3DArrayField<number>;
   MFNode: typeof X3DArrayField<SFNode>;
   MFRotation: typeof X3DArrayField<SFRotation>;
   MFString: typeof X3DArrayField<string>;
   MFTime: typeof X3DArrayField<SFTime>;
   MFVec2d: typeof X3DArrayField<SFVec2>;
   MFVec2f: typeof X3DArrayField<SFVec2>;
   MFVec3d: typeof X3DArrayField<SFVec3>;
   MFVec3f: typeof X3DArrayField<SFVec3>;
   MFVec4d: typeof X3DArrayField<SFVec4>;
   MFVec4f: typeof X3DArrayField<SFVec4>;
}

export interface X3DCanvasElement extends HTMLElement {
   readonly browser: X3DBrowser;
}

type JSONValue =
   | string
   | number
   | boolean
   | null
   | JSONValue[]
   | {[key: string]: JSONValue}

interface JSONObject {
   [k: string]: JSONValue
}

type BrowserProperty = 'ABSTRACT_NODES'
   | 'CONCRETE_NODES'
   | 'EXTERNAL_INTERACTIONS'
   | 'PROTOTYPE_CREATE'
   | 'DOM_IMPORT'
   | 'XML_ENCODING'
   | 'CLASSIC_VRML_ENCODING'
   | 'BINARY_ENCOIDING';

type QualityLevels = 'LOW' | 'MEDIUM' | 'HIGH';
type BrowserOption = {
   Antialiased:                  boolean,
   Dashboard:                    boolean,
   Rubberband:                   boolean,
   EnableInlineViewpoints:       boolean,
   MotionBlur:                   boolean,
   PrimitiveQuality:             QualityLevels,
   QualityWhenMoving:            QualityLevels | 'SAME',
   Shading:	                    'POINT' | 'WIREFRAME' | 'FLAT'
                                    | 'GOURAUD' | 'PHONG',
   SplashScreen:                 boolean,
   TextureQuality:               QualityLevels,
   AutoUpdate:                   boolean,
   Cache:                        boolean,
   ContentScale:                 number,
   ContextMenu:                  boolean,
   Debug:                        boolean,
   Gravity:                      number,
   LogarithmicDepthBuffer:       boolean,
   Multisampling:                number,
   Notifications:                boolean,
   OrderIndependentTransparency: boolean,
   StraightenHorizon:            boolean,
   Timings:                      boolean
}
export type RenderingProperty = {
   Shading:	              BrowserOption['Shading'],
   MaxTextureSize:         number,
   TextureUnits:           number,
   MaxLights:              number,
   Antialiased:            boolean,
   ColorDepth:             number,
   TextureMemory:          number,
   ContentScale:           number,
   MaxSamples:             number,
   Multisampling:          number,
   LogarithmicDepthBuffer: boolean
}

type BrowserCallback = (
   event: number) => void; // event is a Browser Event Constant

export interface X3DBrowser {
   name: string;
   version: string;
   providerURL: string;
   currentSpeed: number;
   currentFrameRate: number;
   description: string;
   readonly supportedComponents: ComponentInfoArray;
   readonly supportedProfiles: ProfileInfoArray;
   baseURL: string;
   currentScene: X3DScene;

   replaceWorld(scene: X3DScene): Promise<void>;
   createX3DFromString(x3dSyntax: string): Promise<X3DScene>;
   createX3DFromURL(url: X3DArrayField<string>): Promise<X3DScene>;
   createX3DFromURL(url: X3DArrayField<string>,
                    node: SFNode, fieldName: string): void;
   loadURL(url: X3DArrayField<string>,
           parameter?: X3DArrayField<string>): Promise<void>;
   importDocument(dom: HTMLElement | string): Promise<X3DScene>;
   importJS(json: string | JSONObject): Promise<X3DScene>;
   getBrowserProperty(prop: BrowserProperty): boolean;
   getBrowserOption<T extends keyof BrowserOption>(op: T): BrowserOption[T];
   setBrowserOption<T extends keyof BrowserOption>(
      op: T, value: BrowserOption[T]): void;
   getRenderingProperty<T extends keyof RenderingProperty>(
      prop: T): RenderingProperty[T];
   getContextMenu(): XiteContextMenu;
   addBrowserCallback(key: unknown, cb?: BrowserCallback): void;
   addBrowserCallback(
      key: unknown, event: number, // A Browser Event Constant
      cb?: BrowserCallback): void;
   removeBrowserCallback(key: unknown, event?: number): void;
   viewAll(layer?: SFNode, transitionTime?: number): void;
   nextViewpoint(layer?: SFNode): void;
   previousViewpoint(layer?: SFNode): void;
   firstViewpoint(layer?: SFNode): void;
   lastViewpoint(layer?: SFNode): void;
   changeViewpoint(name: string): void;
   changeViewpoint(layer: SFNode, name: string): void;
   print(thing: unknown): void;
   printLn(thing: unknown): void;
   // VRML methods
   getName(): string;
   getVersion(): string;
   getCurrentSpeed(): number;
   getCurrentFrameRate(): number;
   getWorldURL(): string;
   replaceWorld(nodes: X3DArrayField<SFNode>): string;
   createVrmlFromString(vrmlSyntax: string): X3DArrayField<SFNode>;
   createVrmlFromURL(url: X3DArrayField<string>,
                     node: SFNode, fieldName: string): void;
   addRoute(sourceNode: SFNode, sourceField: string,
            destinationNode: SFNode, destinationField: string): void;
   deleteRoute(sourceNode: SFNode, sourceField: string,
               destinationNode: SFNode, destinationField: string): void;
   loadURL(url: X3DArrayField<string>,
           parameter?: X3DArrayField<string>): void;
   setDescription(description: string): void;
}

type MinimalArray<T> = {[index: number]: T, length: number}

type ComponentInfoArray = MinimalArray<ComponentInfo>;
interface ComponentInfo {
   readonly name: string;
   readonly level: number;
   readonly title: string;
   readonly providerURL: string;
}

type ProfileInfoArray = MinimalArray<ProfileInfo>;
interface ProfileInfo {
   readonly name: string;
   readonly title: string;
   readonly providerURL: string;
   readonly components: ComponentInfoArray
}

type JQueryCtxMenuOpts = {
   selector: string,
   items: UserMenuItems,
   appendTo?: string | HTMLElement,
   triggers: string,
   hideOnSecondTrigger?: boolean,
   selectableSubMenu?: boolean,
   reposition?: boolean,
   delay?: number,
   autoHide?: boolean,
   zindex?: number | (($trigger: string, opt: JQueryCtxMenuOpts) => number)
   className?: string,
   classNames?: Record<string, string>,
   animation?: {duration: number, show: string, hide: string},
   events?: Record<string, (opt: JQueryCtxMenuOpts) => boolean>,
   position?: (opt: unknown, x?: number|string, y?: number|string) => void,
   determinePosition?: (menu: unknown) => void,
   callback?: MenuCallback,
   build?: ($triggerElement: unknown, e: Event) => JQueryCtxMenuOpts,
   itemClickEvent?: string
}

type UserMenuCallback = () => UserMenuItems
type UserMenuItems = Record<string, UserMenuItem>
type MenuCallback = (
   itemKey: string, opt: JQueryCtxMenuOpts, event: Event) => (boolean | void)
type MenuIconCallback = (
   opt: JQueryCtxMenuOpts, $itemElement: HTMLElement,
   itemKey: string, item: unknown) => string
type MenuBoolCallback = (itemKey: string, opt: JQueryCtxMenuOpts) => boolean
type UserMenuItem = {
   name: string,
   isHtmlName?: boolean,
   callback: MenuCallback,
   className?: string,
   icon?: string | MenuIconCallback,
   disabled?: boolean | MenuBoolCallback,
   visible?: boolean | MenuBoolCallback,
   type?: string,
   events?: Record<string, unknown>,
   value?: string,
   selected?: boolean | string,
   radio?: string,
   options?: Record<string|number, string>,
   height?: number,
   items?: UserMenuItems,
   accesskey?: string,
   dataAttr?: Record<string, string>
}

interface XiteContextMenu {
   getUserMenu(): UserMenuCallback;
   setUserMenu(cb: UserMenuCallback): void;
}

export interface X3DScene {
   readonly specificationVersion: string;
   readonly encoding: 'ASCII' | 'VRML' | 'XML' | 'BINARY'
      | 'SCRIPTED' | 'BIFS' | 'NONE';
   readonly profile: ProfileInfo;
   readonly components: ComponentInfoArray;
   readonly units: UnitInfoArray;
   readonly worldURL: string;
   readonly baseURL: string;
   rootNodes: X3DArrayField<SFNode>;
   readonly protos: ProtoDeclarationArray;
   readonly externprotos: ExternProtoDeclarationArray;
   readonly routes: RouteArray;

   // ExecutionContext methods. I didn't split these out because I
   // didn't see a place in the interface where it mattered, but
   // perhaps there should be a base class with just these...
   createNode<T extends keyof SpecializeNodeType>(
      spec: T): SpecializeNodeType[T];
   createProto(protoName: string): SFNode;
   getNamedNode(name: string): SFNode;
   updateNamedNode(name: string, node: SFNode): void;
   removeNamedNode(name: string): void;
   getImportedNode(importedName: string): SFNode;
   updateImportedNode(
      inlineNode: SFNode, exportedName: string, importedName: string): void;
   removeImportedNode(importedName: string): void;
   addRoute(sourceNode: SFNode, sourceField: string,
            destinationNode: SFNode, destinationField: string): X3DRoute;
   deleteRoute(route: X3DRoute): void;

   // X3DScene methods:
   getMetaData(name: string): string[];
   setMetaData(name: string, value: string | string[]): void;
   addMetaData(name: string, value: string): void;
   removeMetaData(name: string): void;
   addRootNode(node: SFNode): void;
   removeRootNode(node: SFNode): void;
   getExportedNode(exportedName: string): SFNode;
   updateExportedNode(exportedName: string, node: SFNode): void;
   removeExportedNode(exportedName: string): void;
   toVRMLString(options?: VRMLOptions): string;
   toXMLString(options?: VRMLOptions): string;
   toJSONString(options?: VRMLOptions): string;
}

type UnitInfoArray = MinimalArray<UnitInfo>;
interface UnitInfo {
   readonly category: string;
   readonly name: string;
   readonly conversionFactor: number;
}

type ProtoDeclarationArray = MinimalArray<X3DProtoDeclaration>;
export interface X3DProtoDeclaration {
   readonly name: string;
   readonly fields: FieldDefinitionArray;
   isExternProto: false;
   newInstance(): SFNode;
   toVRMLString(options?: VRMLOptions): string;
   toXMLString(options?: VRMLOptions): string;
   toJSONString(options?: VRMLOptions): string;
}

type ExternProtoDeclarationArray = MinimalArray<X3DExternProtoDeclaration>;
export interface X3DExternProtoDeclaration {
   readonly name: string;
   readonly fields: FieldDefinitionArray;
   readonly urls: X3DArrayField<string>;
   isExternProto: false;
   readonly loadState: number; // A Load State Constant from X3DConstants
   newInstance(): SFNode;
   loadNow(): Promise<void>;
   toVRMLString(options?: VRMLOptions): string;
   toXMLString(options?: VRMLOptions): string;
   toJSONString(options?: VRMLOptions): string;
}

type RouteArray = MinimalArray<X3DRoute>;
export interface X3DRoute {
   sourceNode: SFNode;
   sourceField: string;
   destinationNode: SFNode;
   destinationField: string;
}

type FieldCallback = (value: unknown) => void

 class X3DField {
   equals(other: X3DField): boolean;
   assign(other: X3DField): void;
   setValue(value: unknown): void;
   getValue(): unknown;
   getType(): number; // one of the Field Type Constants from X3DConstants
   getAccessType(): number; // one of the Access Type Constants
   isInitializable(): boolean;
   isInput(): boolean;
   isOutput(): boolean;
   isReadable(): boolean;
   isWritable(): boolean;
   getUnit(): string;
   hasReferences(): boolean;
   isReference(accessType: number): boolean;
   addReferencesCallback(key: unknown, callback: FieldCallback): void;
   removeReferencesCallback(key: unknown): void;
   getReferencesCallbacks(): Map<unknown, FieldCallback>;
   addFieldInterest(other: X3DField): void;
   removeFieldInterest(other: X3DField): void;
   getFieldInterest(): Set<X3DField>
   addFieldCallback(key: unknown, callback: FieldCallback): void;
   removeFieldCallback(key: unknown): void;
   getFieldCallbacks(): Map<unknown, FieldCallback>;
   addInputRoute(route: X3DRoute): void;
   removeInputRoute(route: X3DRoute): void;
   getInputRoutes(): Set<X3DRoute>;
   addOutputRoute(route: X3DRoute): void;
   removeOutputRoute(route: X3DRoute): void;
   getOutputRoutes(): Set<X3DRoute>;
   addRouteCallback(key: unknown, callback: FieldCallback): void;
   removeRouteCallback(key: unknown): void;
   getRouteCallbacks(): Map<unknown, FieldCallback>;
   dispose(): void;
}

export class SFColor extends X3DField {
   constructor(r?: number, g?: number, b?: number);
   r: number;
   g: number;
   b: number;
   copy(): SFColor;
   isDefaultValue(): boolean;
   set(r: number, g: number, b: number): SFColor;
   getHSV(result: number[]): number[];
   setHSV(h: number, s: number, v: number): void;
   lerp(destination: SFColor, t: number): SFColor;
   static typeName: 'SFColor';
}

export class SFColorRGBA extends X3DField {
   constructor(r?: number, g?: number, b?: number, a?: number);
   r: number;
   g: number;
   b: number;
   a: number;
   copy(): SFColorRGBA;
   isDefaultValue(): boolean;
   set(r: number, g: number, b: number): SFColorRGBA;
   getHSVA(result: number[]): number[];
   setHSVA(h: number, s: number, v: number): void;
   lerp(destination: SFColor, t: number): SFColorRGBA;
   static typeName: 'SFColorRGBA';
}

export class SFDouble extends X3DField {
   constructor(arg?: unknown);
   copy(): SFDouble;
   isDefaultValue(): boolean;
   set(arg: unknown): void;
   valueOf(): number;
}

export class SFImage extends X3DField {
   constructor(width?: number, height?: number,
               num_components?: number, array?: number[]);
   x: number;
   y: number;
   width: number;
   height: number;
   comp: number;
   array: number[];
   copy(): SFImage;
   isDefaultValue(): boolean;
   set(other: SFImage): void;
}

export class SFInt32 extends X3DField {
   constructor(val?: number);
   copy(): SFInt32;
   set(val?: number): void;
   valueOf(): number;
}

export class SFMatrix3 extends X3DField {
   constructor();
   constructor(r1: SFVec3, r2: SFVec3, r3: SFVec3);
   constructor(a: number, b: number, c: number,
               d: number, e: number, f: number,
               g: number, h: number, i: number);
   copy(): SFMatrix3;
   isDefaultValue(): boolean;
   set(other: SFMatrix3): void;
   setTransform(translation: SFVec2, rotation: number, scaleFactor: SFVec2,
                scaleOrientation: number, center: SFVec2): void;
   getTransform(translation: SFVec2, rotation: SFDouble, scaleFactor: SFVec2,
                scaleOrientation: SFDouble, center: SFVec2): void;
   determinant(): number;
   inverse(): SFMatrix3;
   transpose(): SFMatrix3;
   multLeft(A: SFMatrix3): SFMatrix3;
   multRight(B: SFMatrix3): SFMatrix3;
   multVecMatrix(row: SFVec2): SFVec2;
   multVecMatrix(row: SFVec3): SFVec3;
   multMatrixVec(col: SFVec2): SFVec2;
   multMatrixVec(col: SFVec3): SFVec3;
   multDirMatrix(row: SFVec2): SFVec2;
   multMatrixDir(col: SFVec2): SFVec2;
}

export class SFMatrix4 extends X3DField {
   constructor();
   constructor(r1: SFVec4, r2: SFVec4, r3: SFVec4, r4: SFVec4);
   constructor(a: number, b: number, c: number, d: number,
               e: number, f: number, g: number, h: number,
               i: number, j: number, k: number, l: number,
               m: number, n: number, o: number, p: number);
   copy(): SFMatrix4;
   isDefaultValue(): boolean;
   set(other: SFMatrix4): void;
   setTransform(translation: SFVec3, rotation: SFRotation,
                scaleFactor: SFVec3, scaleOrientation: SFRotation,
                center: SFVec3): void;
   getTransform(translation: SFVec3, rotation: SFRotation,
                scaleFactor: SFVec3, scaleOrientation: SFRotation,
                center: SFVec3): void;
   determinant(): number;
   inverse(): SFMatrix4;
   transpose(): SFMatrix4;
   multLeft(A: SFMatrix4): SFMatrix4;
   multRight(B: SFMatrix4): SFMatrix4;
   multVecMatrix(row: SFVec4): SFVec4;
   multVecMatrix(row: SFVec3): SFVec3;
   multMatrixVec(col: SFVec4): SFVec4;
   multMatrixVec(col: SFVec3): SFVec3;
   multDirMatrix(row: SFVec3): SFVec3;
   multMatrixDir(col: SFVec3): SFVec3;
}

export interface SFNode extends X3DField {
   // constructor(vrmlSyntax: string); // throws error, anyway

   // Each subclass of SFNode for the different node types
   // has various properties, that will be defined for
   // each one below. But as far as I can see, they all have metadata
   // properties:
   metadata: SFNode;

   copy(instance?: unknown): SFNode; // not sure what argument does...
   isDefaultValue(): boolean;
   set(other: SFNode): void;
   dispose(): void;
   // stupid WET TypeScript won't just overload the base class method:
   addFieldCallback(key: unknown, callback: FieldCallback): void;
   addFieldCallback(name: string, key: unknown,
                    callback: (value: unknown) => void): void;
   getFieldDefinitions(): FieldDefinitionArray;
   getField(name: string): X3DField;
   getNodeName(): string;
   getNodeDisplayName(): string;
   getNodeType(): number[]; // Array of Node Type constants from X3DConstants
   getNodeTypeName(): string;
   getNodeUserData(key: unknown): unknown;
   removeFieldCallback(key: unknown): void;
   removeFieldCallback(name: string, key: unknown): void;
   removeNodeUserData(key: unknown): void;
   setNodeUserData(key: unknown, data: unknown): unknown;
   toVRMLString(options?: VRMLOptions): string;
   toXMLString(options?: VRMLOptions): string;
   toJSONString(options?: VRMLOptions): string;
   valueOf(): unknown; // what is proper type? May depend on what kind...
}

interface SFNodeAcousticProperties extends SFNode {
   description: string;
   enabled: boolean;
   absorption: number;
   refraction: number;
   diffuse: number;
   specular: number;
}

interface SFNodeAnalyser extends SFNode {
   description: string;
   enabled: boolean;
   gain: number;
   fftSize: number;
   minDecibels: number;
   maxDecibels: number;
   smoothingTimeConstant: number;
   tailTime: SFTime;
}

interface Positioner extends SFNode {
   visible: boolean;
   bboxDisplay: boolean;
   bboxSize: SFVec3;
   bboxCenter: SFVec3;
}

interface GroupingFields {
   addChildren: X3DArrayField<SFNode>;
   removeChildren: X3DArrayField<SFNode>;
   children: X3DArrayField<SFNode>;
}

interface X3DGroupingNode extends Positioner, GroupingFields { }

interface URLFields {
   description: string;
   load: boolean;
   url: X3DArrayField<string>;
   autoRefresh: SFTime;
   autoRefreshTimeLimit: SFTime;
}

interface SFNodeAnchor extends X3DGroupingNode {
   parameter: X3DArrayField<string>;
}

interface SFNodeAppearance extends SFNode {
   acousticProperties: SFNodeAcousticProperties;
   alphaMode: 'AUTO' | 'OPAQUE' | 'MASK' | 'BLEND';
   alphaCutoff: number;
   pointProperties: SFNodePointProperties;
   lineProperties: SFNodeLineProperties;
   fillProperties: SFNodeFillProperties;
   material: SFNodeMaterial;
   backMaterial: SFNodeMaterial;
   texture: SFNode;
   textureTransform: SFNodeTextureTransform;
   shaders: X3DArrayField<SFNode>;
   blendMode: SFNodeBlendMode;
}

interface X3DTimeDependentNode extends SFNode {
   startTime: SFTime;
   resumeTime: SFTime;
   pauseTime: SFTime;
   stopTime: SFTime;
   isPaused: boolean;
   isActive: boolean;
   elapsedTime: SFTime;
}

interface SFNodeAudioClip extends X3DTimeDependentNode, URLFields {
   enabled: boolean;
   gain: number;
   pitch: number;
   loop: boolean;
   duration_changed: SFTime;
}

interface ChannelFields extends SFNode {
   description: string;
   enabled: boolean;
   gain: number;
   channelCount: number;
   channelCountMode: 'MAX' | 'CLAMPED-MAX' | 'EXPLICIT';
   channelInterpretation: 'SPEAKERS' | 'DISCRETE';
}

interface X3DSoundDestinationNode extends ChannelFields {
   mediaDeviceId: string;
   isActive: boolean;
   children: X3DArrayField<SFNode>;
}

interface SFNodeAudioDestination extends X3DSoundDestinationNode {
   maxChannelCount: number;
}

interface X3DBindableNode extends SFNode {
   set_bind: boolean;
   isBound: boolean;
   bindTime: SFTime;
}

interface X3DBackgroundNode extends X3DBindableNode {
   skyAngle: X3DArrayField<number>;
   skyColor: X3DArrayField<SFColor>;
   groundAngle: X3DArrayField<number>;
   groundColor: X3DArrayField<SFColor>;
   transparency: number;
}

interface SFNodeBackground extends X3DBackgroundNode {
   frontUrl: X3DArrayField<string>;
   backUrl: X3DArrayField<string>;
   leftUrl: X3DArrayField<string>;
   rightUrl: X3DArrayField<string>;
   topUrl: X3DArrayField<string>;
   bottomUrl: X3DArrayField<string>;
}

interface SFNodeBillboard extends X3DGroupingNode {
   axisOfRotation: SFVec3;
}

interface SFNodeBiquadFilter extends X3DTimeDependentNode, ChannelFields {
   frequency: number;
   detune: number;
   type: 'LOWPASS' | 'HIGHPASS' | 'BANDPASS'
      | 'LOWSHELF' | 'HIGHSHELF' | 'PEAKING' | 'NOTCH' |  'ALLPASS';
   qualityFactor: number;
   tailTime: SFTime;
   children: X3DArrayField<SFNode>;
}

type BlendFactor = 'ZERO' | 'ONE'
   | 'SRC_COLOR'      | 'ONE_MINUS_SRC_COLOR'
   | 'DST_COLOR'      | 'ONE_MINUS_DST_COLOR'
   | 'SRC_ALPHA'      | 'ONE_MINUS_SRC_ALPHA'
   | 'DST_ALPHA'      | 'ONE_MINUS_DST_ALPHA'
   | 'CONSTANT_COLOR' | 'ONE_MINUS_CONSTANT_COLOR'
   | 'CONSTANT_ALPHA' | 'ONE_MINUS_CONSTANT_ALPHA'

type BlendEquation = 'FUNC_ADD' | 'FUNC_SUBTRACT' | 'FUNC_REVERSE_SUBTRACT'

interface SFNodeBlendMode extends SFNode {
   blendColor: SFColorRGBA;
   sourceColorFactor: BlendFactor;
   sourceAlphaFactor: BlendFactor;
   destinationColorFactor: BlendFactor;
   destinationAlphaFactor: BlendFactor;
   colorEquation: BlendEquation;
   alphaEquation: BlendEquation;
}

interface SFNodeBox extends SFNode {
   size: SFVec3;
   solid: boolean;
}

interface SFNodeBufferAudioSource
   extends X3DTimeDependentNode, ChannelFields, URLFields {
      detune: number;
      buffer: X3DArrayField<number>;
      bufferDuration: SFTime;
      bufferLength: number;
      numberOfChannels: number;
      sampleRate: number;
      playbackRate: number;
      loopStart: SFTime;
      loopEnd: SFTime;
      loop: boolean;
   }

interface SFNodeChannelMerger extends ChannelFields {
   children: X3DArrayField<SFNode>;
}

interface SFNodeChannelSelector extends ChannelFields {
   channelSelection: number;
   children: X3DArrayField<SFNode>;
}

interface SFNodeChannelSplitter extends ChannelFields {
   children: X3DArrayField<SFNode>;
   outputs:  X3DArrayField<SFNode>;
}

interface SFNodeClipPlane extends SFNode {
   enabled: boolean;
   plane: SFVec4;
}

interface SFNodeCollision extends X3DGroupingNode {
   enabled: boolean;
   isActive: boolean;
   collideTime: SFTime;
   proxy: SFNode;
}

interface SFNodeColor extends SFNode {
   color: X3DArrayField<SFColor>;
}

interface SFNodeColorRGBA extends SFNode {
   color: X3DArrayField<SFColorRGBA>;
}

interface X3DChaserNode<T> extends SFNode {
   set_value: T;
   set_destination: T;
   initialValue: T;
   initialDestination: T;
   duration: SFTime;
   isActive: boolean;
   value_changed: T;
}

interface X3DDamperNode<T> extends SFNode {
   set_value: T;
   set_destination: T;
   initialValue: T;
   initialDestination: T;
   order: number;
   tau: SFTime;
   tolerance: number;
   isActive: boolean;
   value_changed: T;
}

interface X3DInterpolatorNode<T,V> extends SFNode {
   set_fraction: number;
   key: X3DArrayField<number>;
   keyValue: X3DArrayField<T>;
   value_changed: V;
}

interface X3DShaderNode extends SFNode {
   activate: boolean;
   isSelected: boolean;
   isValid: boolean;
   language: string;
}

interface SFNodeComposedShader extends X3DShaderNode {
   parts: X3DArrayField<SFNodeShaderPart>;
}

interface SFNodeCone extends SFNode {
   side: boolean;
   bottom: boolean;
   height: number;
   bottomRadius: number;
   solid: boolean;
}

interface SFNodeConvolver extends  X3DTimeDependentNode, ChannelFields {
   buffer: X3DArrayField<number>;
   normalize: boolean;
   tailTime: SFTime;
   children: X3DArrayField<SFNode>;
}

interface SFNodeCoordinate extends SFNode {
   point: X3DArrayField<SFVec3>;
}

interface SFNodeCylinder extends SFNode {
   top: boolean;
   side: boolean;
   bottom: boolean;
   height: number;
   radius: number;
   solid: boolean;
}

interface X3DPointingDeviceSensorNode extends SFNode {
   description: string;
   enabled: boolean;
   isOver: boolean;
   isActive: boolean;
}

interface X3DDragSensorNode extends X3DPointingDeviceSensorNode {
   offset: number;
   autoOffset: boolean;
   trackPoint_changed: SFVec3;
}

interface SFNodeCylinderSensor extends X3DDragSensorNode {
   axisRotation: SFRotation,
   diskAngle: number;
   minAngle: number;
   maxAngle: number;
   rotation_changed: SFRotation;
}

interface SFNodeDelay extends X3DTimeDependentNode, ChannelFields {
   delayTime: SFTime;
   maxDelayTime: SFTime;
   tailTime: SFTime;
   children: X3DArrayField<SFNode>;
}

interface X3DLightNode extends SFNode {
   global: boolean;
   on: boolean;
   color: SFColor;
   intensity: number;
   ambientIntensity: number;
   shadows: boolean;
   shadowColor: SFColor;
   shadowIntensity: number;
   shadowBias: number;
   shadowMapSize: number;
}

interface SFNodeDirectionalLight extends X3DLightNode {
   direction: SFVec3;
}

interface SFNodeDynamicsCompressor
   extends X3DTimeDependentNode, ChannelFields {
      attack: number;
      knee: number;
      ratio: number;
      reduction: number;
      release: SFTime;
      threshold: number;
      tailTime: SFTime;
      children: X3DArrayField<SFNode>;
   }

interface SFNodeEaseInEaseOut extends SFNode {
   set_fraction: number;
   key: X3DArrayField<number>;
   easeInEaseOut: X3DArrayField<SFVec2>;
   modifiedFraction_changed: number;
}

interface GeometrySubnodes {
   attrib: X3DArrayField<SFNodeFloatVertexAttribute>;
   fogCoord: SFNodeFogCoordinate;
   color: SFNodeColor | SFNodeColorRGBA;
   normal: SFNodeNormal;
}

interface SFNodeElevationGrid extends SFNode, GeometrySubnodes {
   set_height: X3DArrayField<number>;
   xDimension: number;
   zDimension: number;
   xSpacing: number;
   zSpacing: number;
   solid: boolean;
   ccw: boolean;
   creaseAngle: number;
   colorPerVertex: boolean;
   normalPerVertex: boolean;
   texCoord: SFNode;
   height: X3DArrayField<number>;
}

interface SFNodeEnvironmentLight extends X3DLightNode {
   rotation: SFRotation;
   diffuseCoefficients: X3DArrayField<number>;
   diffuse: SFNode;
   diffuseTexture: SFNode;
   specularTexture: SFNode;
}

interface SFNodeExtrusion extends SFNode {
   set_crossSection: X3DArrayField<SFVec2>;
   set_orientation: X3DArrayField<SFRotation>;
   set_scale: X3DArrayField<SFVec2>;
   set_spine: X3DArrayField<SFVec3>;
   beginCap: boolean;
   endCap: boolean;
   solid: boolean;
   ccw: boolean;
   convex: boolean;
   creaseAngle: number;
   crossSection: X3DArrayField<SFVec2>;
   orientation: X3DArrayField<SFRotation>;
   scale: X3DArrayField<SFVec2>;
   spine: X3DArrayField<SFVec3>;
}

interface SFNodeFillProperties extends SFNode {
   filled: boolean;
   hatched: boolean;
   hatchStyle: number;
   hatchColor: SFColor;
}

interface SFNodeFloatVertexAttribute extends SFNode {
   name: string;
   numComponents: number;
   value: X3DArrayField<number>;
}

interface FogCommon extends SFNode {
   fogType: 'LINEAR' | 'EXPONENTIAL';
   color: SFColor;
   visibilityRange: number;
}

interface SFNodeFog extends X3DBindableNode, FogCommon { }

interface SFNodeFogCoordinate extends SFNode {
   depth: X3DArrayField<number>;
}

interface SFNodeFontStyle extends SFNode {
   language: string;
   family: X3DArrayField<string>;
   style:  'PLAIN' | 'BOLD' | 'ITALIC' | 'BOLDITALIC' | '';
   size: number;
   spacing: number;
   horizontal: boolean;
   leftToRight: boolean;
   topToBottom: boolean;
   justify: X3DArrayField<'BEGIN' | 'END' | 'FIRST' | 'MIDDLE' | ''>;
}

interface SFNodeGain extends X3DTimeDependentNode, ChannelFields {
   tailTime: SFTime;
   children: X3DArrayField<SFNode>;
}

interface Texture2DFields {
   repeatS: boolean;
   repeatT: boolean;
   textureProperties: SFNodeTextureProperties;
}

interface SFNodeImageTexture extends SFNode, URLFields, Texture2DFields { }

interface IndexedColorCoord {
   set_colorIndex: X3DArrayField<number>;
   set_coordIndex: X3DArrayField<number>;
   colorIndex: X3DArrayField<number>;
   coordIndex: X3DArrayField<number>;
   color: SFNodeColor | SFNodeColorRGBA;
   coord: SFNodeCoordinate;
}

interface SFNodeIndexedFaceSet extends SFNodeIndexedLineSet {
   set_texCoordIndex: X3DArrayField<number>;
   set_normalIndex: X3DArrayField<number>;
   solid: boolean;
   ccw: boolean;
   convex: boolean;
   creaseAngle: number;
   normalPerVertex: boolean;
   texCoordIndex: X3DArrayField<number>;
   normalIndex: X3DArrayField<number>;
   texCoord: SFNode;
}

interface SFNodeIndexedLineSet
   extends SFNode, GeometrySubnodes, IndexedColorCoord {
      colorPerVertex: boolean;
}

interface SFNodeTriangleSet extends SFNode, GeometrySubnodes {
   solid: boolean;
   ccw: boolean;
   colorPerVertex: boolean;
   normalPerVertex: boolean;
   texCoord: SFNode;
   coord: SFNodeCoordinate;
}

interface IndexedTriangles extends SFNodeTriangleSet {
   set_index: X3DArrayField<number>;
   index: X3DArrayField<number>;
}

interface SFNodeInline extends Positioner, URLFields {
   global: boolean;
}

interface SFNodeLOD extends X3DGroupingNode {
   forceTransitions: boolean;
   center: SFVec3;
   range: X3DArrayField<number>;
   level_changed: number;
}

interface SFNodeLayer extends SFNode, GroupingFields {
   pickable: boolean;
   objectType: X3DArrayField<string>;
   visible: boolean;
   viewport: SFNodeViewport;
}

interface SFNodeLayerSet extends SFNode {
   activeLayer: number;
   order: X3DArrayField<number>;
   layers: X3DArrayField<SFNodeLayer>;
}

interface SFNodeLineProperties extends SFNode {
   applied: boolean;
   linetype: number;
   linewidthScaleFactor: number;
}

interface SFNodeLineSet extends SFNode, GeometrySubnodes {
   vertexCount: X3DArrayField<number>;
   coord: SFNodeCoordinate;
}

interface SFNodeListenerPointSource extends X3DTimeDependentNode {
   description: string;
   enabled: boolean;
   orientation: SFRotation;
   gain: number;
   dopplerEnabled: boolean;
   interauralDistance: number;
   trackCurrentView: boolean;
}

interface SFNodeLoadSensor extends SFNode {
   enabled: boolean;
   timeOut: SFTime;
   isActive: boolean;
   isLoaded: boolean;
   progress: number;
   loadTime: SFTime;
   children: X3DArrayField<SFNode>;
}

interface SFNodeLocalFog extends FogCommon {
   enabled: boolean;
}

interface SFNodeUnlitMaterial extends SFNode {
   emissiveColor: SFColor;
   emissiveTextureMapping: string;
   emissiveTexture: SFNode;
   normalScale: number;
   normalTextureMapping: string;
   normalTexture: SFNode;
   transparency: number;
}

interface MaterialCommon extends SFNodeUnlitMaterial {
   occlusionStrength: number;
   occlusionTextureMapping: string;
   occlusionTexture: SFNode;
}

interface SFNodeMaterial extends MaterialCommon {
   ambientIntensity: number;
   ambientTextureMapping: string;
   ambientTexture: SFNode;
   diffuseColor: SFColor;
   diffuseTextureMapping: string;
   diffuseTexture: SFNode;
   specularColor: SFColor;
   specularTextureMapping: string;
   specularTexture: SFNode;
   shininess: number;
   shininessTextureMapping: string;
   shininessTexture: SFNode;
}

interface SFNodeMatrix3VertexAttribute extends SFNode {
   name: string;
   value: X3DArrayField<SFMatrix3>;
}

interface SFNodeMatrix4VertexAttribute extends SFNode {
   name: string;
   value: X3DArrayField<SFMatrix4>;
}

interface X3DMetadataNode extends SFNode {
   name: string;
   reference: string;
}

interface MetadataInstance<T> extends X3DMetadataNode {
   value: X3DArrayField<T>;
}

interface SFNodeMicrophoneSource extends X3DTimeDependentNode {
   description: string;
   enabled: boolean;
   gain: number;
   mediaDeviceId: string;
}

interface SFNodeMovieTexture extends SFNodeAudioClip, Texture2DFields {
   speed: number;
}

interface SFNodeMultiTexture extends SFNode {
   description: string;
   color: SFColor;
   alpha: number;
   mode: X3DArrayField<string>;
   source: X3DArrayField<string>;
   function: X3DArrayField<string>;
   texture: X3DArrayField<SFNode>;
}

interface SFNodeMultiTextureCoordinate extends SFNode {
   texCoord: X3DArrayField<SFNodeTextureCoordinate>;
}

interface SFNodeMultiTextureTransform extends SFNode {
   textureTransform: X3DArrayField<SFNodeTextureTransform>;
}

interface SFNodeNavigationInfo extends X3DBindableNode {
   type: X3DArrayField<
      'EXAMINE' | 'WALK' | 'FLY' | 'PLANE' | 'PLANE_create3000.github.io'
      | 'PLANE_create3000.de' | 'LOOKAT' | 'EXPLORE' | 'ANY' | 'NONE'>;
   avatarSize: X3DArrayField<number>;
   speed: number;
   headlight: boolean;
   visibilityLimit: number;
   transitionType: X3DArrayField<'TELEPORT' | 'LINEAR' | 'ANIMATE'>;
   transitionTime: SFTime;
   transitionComplete: boolean;
}

interface SFNodeNormal extends SFNode {
   vector: X3DArrayField<SFVec3>;
}

interface X3DViewpointNode extends X3DBindableNode {
   description: string;
   position: SFVec3;
   orientation: SFRotation;
   centerOfRotation: SFVec3;
   fieldOfView: number;
   nearDistance: number;
   farDistance: number;
   viewAll: boolean;
   jump: boolean;
   retainUserOffsets: boolean;
   navigationInfo: SFNodeNavigationInfo;
}

interface SFNodeOscillatorSource extends X3DTimeDependentNode {
   description: string;
   enabled: boolean;
   gain: number;
   frequency: number;
   detune: number;
   periodicWave: SFNodePeriodicWave;
}

interface SFNodePackagedShader extends X3DShaderNode, URLFields { }

interface SFNodePeriodicWave extends SFNode {
   description: string;
   enabled: boolean;
   type: 'SINE' | 'SQUARE' | 'SAWTOOTH' | 'TRIANGLE' | 'CUSTOM'
   optionsReal: X3DArrayField<number>;
   optionsImag: X3DArrayField<number>;
}

interface SFNodePhysicalMaterial extends MaterialCommon {
   baseColor: SFColor;
   baseTextureMapping: String;
   baseTexture: SFNode;
   metallic: number;
   roughness: number;
   metallicRoughnessTextureMapping: string;
   metallicRoughnessTexture: SFNode;
}

interface SFNodePixelTexture extends SFNode, Texture2DFields {
   description: string;
   image: SFImage;
}

interface SFNodePlaneSensor extends X3DDragSensorNode {
   axisRotation: SFRotation;
   minPosition: SFVec2;
   maxPosition: SFVec2;
   translation_changed: SFVec3;
}

interface SFNodePointLight extends X3DLightNode {
   attenuation: SFVec3;
   location: SFVec3;
   radius: number;
}

interface SFNodePointProperties extends SFNode {
   pointSizeScaleFactor: number;
   pointSizeMinValue: number;
   pointSizeMaxValue: number;
   attenuation: SFVec3;
}

interface SFNodePointSet extends SFNode, GeometrySubnodes {
   coord: SFNodeCoordinate;
}

interface SFNodeProgramShader extends X3DShaderNode {
   programs: X3DArrayField<SFNodeShaderProgram>
}

interface X3DEnvironmentalSensorNode extends SFNode {
   enabled: boolean;
   size: SFVec3;
   center: SFVec3;
   enterTime: SFTime;
   exitTime: SFTime;
   isActive: boolean;
}

interface SFNodeProximitySensor extends X3DEnvironmentalSensorNode {
   position_changed: SFVec3;
   orientation_changed: SFRotation;
   centerOfRotation_changed: SFVec3;
}

interface SFNodeScript extends SFNode, URLFields {
   directOutput: boolean;
   mustEvaluate: boolean;
}

interface SFNodeShaderPart extends SFNode, URLFields {
   type: 'VERTEX' | 'FRAGMENT';
}

type SFNodeShaderProgram = SFNodeShaderPart; // Why are there two node types?

interface SFNodeShape extends Positioner {
   castShadow: boolean;
   appearance: SFNodeAppearance;
   geometry: SFNode;
}

interface SoundCommon extends SFNode {
   description: string;
   enabled: boolean;
   spatialize: boolean;
   location: SFVec3;
   direction: SFVec3;
   intensity: number;
   priority: number;
   children: X3DArrayField<SFNode>;
}

interface SFNodeSound extends SFNode {
   minBack: number;
   minFront: number;
   maxBack: number;
   maxFront: number;
   source: SFNode;
}

interface SFNodeSpatialSound extends SFNode {
   coneInnerAngle: number;
   coneOuterAngle: number;
   coneOuterGain: number;
   distanceModel: 'LINEAR' | 'INVERSE' | 'EXPONENTIAL';
   dopplerEnabled: boolean;
   enableHRTF: boolean;
   gain: number;
   maxDistance: number;
   referenceDistance: number;
   rolloffFactor: number;
}

interface SFNodeSphere extends SFNode {
   radius: number;
   solid: boolean;
}

interface SFNodeSphereSensor extends X3DPointingDeviceSensorNode {
   rotation_changed: SFRotation;
}

interface SplineInterpolator<U> extends X3DInterpolatorNode<U,U> {
   closed: boolean;
   keyVelocity: X3DArrayField<U>;
   normalizeVelocity: boolean;
}

interface SFNodeSpotLight extends SFNodePointLight {
   direction: SFVec3;
   beamWidth: number;
   cutOffAngle: number;
}

interface SFNodeSquadOrientationInterpolator
   extends X3DInterpolatorNode<SFRotation, SFRotation> {
      closed: boolean;
   }

interface SFNodeStaticGroup extends Positioner {
   children: X3DArrayField<SFNode>;
}

interface SFNodeStreamAudioDestination extends X3DSoundDestinationNode {
   streamIdentifier: X3DArrayField<string>;
}

interface SFNodeStreamAudioSource extends X3DTimeDependentNode {
   description: string;
   enabled: boolean;
   gain: number;
   streamIdentifier: X3DArrayField<string>;
}

interface SFNodeSwitch extends X3DGroupingNode {
   whichChoice: number;
}

interface SFNodeText extends SFNode {
   string: X3DArrayField<string>;
   length: X3DArrayField<number>;
   maxExtent: number;
   solid: boolean;
   origin: SFVec3;
   textBounds: SFVec2;
   lineBounds: X3DArrayField<SFVec2>;
   fontStyle: SFNodeFontStyle;
}

interface SFNodeTextureBackground extends X3DBackgroundNode {
   frontTexture: SFNode;
   backTexture: SFNode;
   leftTexture: SFNode;
   rightTexture: SFNode;
   topTexture: SFNode;
   bottomTexture: SFNode;
}

interface SFNodeTextureCoordinate extends SFNode {
   mapping: string;
   point: X3DArrayField<SFVec2>;
}

interface SFNodeTextureCoordinateGenerator extends SFNode {
   mapping: string;
   mode: 'SPHERE' | 'SPHERE-LOCAL' | 'SPHERE-REFLECT' | 'SPHERE-REFLECT-LOCAL'
      | 'COORD' | 'COORD-EYE' | 'NOISE' | 'NOISE-EYE' | 'CAMERASPACENORMAL'
      | 'CAMERASPACEPOSITION' | 'CAMERASPACEREFLECTIONVECTOR' ;
   parameter: X3DArrayField<number>;
}

interface SFNodeTextureProperties extends SFNode {
   borderColor: SFColorRGBA;
   borderWidth: number;
   anisotropicDegree: number;
   generateMipMaps: boolean;
   minificationFilter: string;
   magnificationFilter: string;
   boundaryModeS: string;
   boundaryModeT: string;
   boundaryModeR: string;
   textureCompression: string;
   texturePriority: number;
}

interface SFNodeTextureTransform extends SFNode {
   mapping: string;
   translation: SFVec2;
   rotation: number;
   scale: SFVec2;
   center: SFVec2;
}

interface SFNodeTimeSensor extends X3DTimeDependentNode {
   description: string;
   enabled: boolean;
   cycleInterval: SFTime;
   loop: boolean;
   cycleTime: SFTime;
   fraction_changed: number;
   time: SFTime;
}

interface SFNodeTouchSensor extends X3DPointingDeviceSensorNode {
   hitTexCoord_changed: SFVec2;
   hitNormal_changed: SFVec3;
   hitPoint_changed: SFVec3;
   touchTime: SFTime;
}

interface SFNodeTransform extends X3DGroupingNode {
   translation: SFVec3;
   rotation: SFRotation;
   scale: SFVec3;
   scaleOrientation: SFRotation;
   center: SFVec3;
}

interface SFNodeTransformSensor extends X3DEnvironmentalSensorNode {
   position_changed: SFVec3;
   orientation_changed: SFRotation;
   targetObject: SFNode;
}

interface SFNodeTriangleFanSet extends SFNodeTriangleSet {
   fanCount: X3DArrayField<number>;
}

interface SFNodeTriangleStripSet extends SFNodeTriangleSet {
   stripCount: X3DArrayField<number>;
}

interface SFNodeTwoSidedMaterial extends SFNode {
   ambientIntensity: number;
   backAmbientIntensity: number;
   backDiffuseColor: SFColor;
   backEmissiveColor: SFColor;
   backShininess: number;
   backSpecularColor: SFColor;
   backTransparency: number;
   diffuseColor: SFColor;
   emissiveColor: SFColor;
   shininess: number;
   separateBackColor: boolean;
   specularColor: SFColor;
   transparency: number;
}

interface SFNodeViewpointGroup extends SFNode {
   description: string;
   displayed: boolean;
   retainUserOffsets: boolean;
   size: SFVec3;
   center: SFVec3;
   children: X3DArrayField<SFNode>;
}

interface SFNodeViewport extends X3DGroupingNode {
   clipBoundary: X3DArrayField<number>;
}

interface SFNodeWaveShaper extends X3DTimeDependentNode, ChannelFields {
   curve: X3DArrayField<number>;
   oversample: 'NONE' | '2x' | '4x';
   tailTime: SFTime;
   children: X3DArrayField<SFNode>;
}

interface SFNodeWorldInfo extends SFNode {
   title: string;
   info: X3DArrayField<string>;
}

export type SpecializeNodeType = {
   AcousticProperties: SFNodeAcousticProperties,
   Analyser: SFNodeAnalyser,
   Anchor: SFNodeAnchor,
   Appearance: SFNodeAppearance,
   AudioClip: SFNodeAudioClip,
   AudioDestination: SFNodeAudioDestination,
   Background: SFNodeBackground,
   Billboard: SFNodeBillboard,
   BiquadFilter: SFNodeBiquadFilter,
   BlendMode: SFNodeBlendMode,
   Box: SFNodeBox,
   BufferAudioSource: SFNodeBufferAudioSource,
   ChannelMerger: SFNodeChannelMerger,
   ChannelSelector: SFNodeChannelSelector,
   ChannelSplitter: SFNodeChannelSplitter,
   ClipPlane: SFNodeClipPlane,
   Collision: SFNodeCollision,
   Color: SFNodeColor,
   ColorRGBA: SFNodeColorRGBA,
   ColorChaser: X3DChaserNode<SFColor>,
   ColorDamper: X3DDamperNode<SFColor>,
   ColorInterpolator: X3DInterpolatorNode<SFColor, SFColor>,
   ComposedShader: SFNodeComposedShader,
   Cone: SFNodeCone,
   Convolver: SFNodeConvolver,
   Coordinate: SFNodeCoordinate,
   CoordinateChaser: X3DChaserNode<X3DArrayField<SFVec3>>,
   CoordinateDamper: X3DDamperNode<X3DArrayField<SFVec3>>,
   CoordinateInterpolator: X3DInterpolatorNode<SFVec3, X3DArrayField<SFVec3>>,
   CoordinateInterpolator2D:
      X3DInterpolatorNode<SFVec2, X3DArrayField<SFVec2>>,
   Cylinder: SFNodeCylinder,
   CylinderSensor: SFNodeCylinderSensor,
   Delay: SFNodeDelay,
   DirectionalLight: SFNodeDirectionalLight,
   DynamicsCompressor: SFNodeDynamicsCompressor,
   EaseInEaseOut: SFNodeEaseInEaseOut,
   ElevationGrid: SFNodeElevationGrid,
   EnvironmentLight: SFNodeEnvironmentLight,
   Extrusion: SFNodeExtrusion,
   FillProperties: SFNodeFillProperties,
   FloatVertexAttribute: SFNodeFloatVertexAttribute,
   Fog: SFNodeFog,
   FogCoordinate: SFNodeFogCoordinate,
   FontStyle: SFNodeFontStyle,
   Gain: SFNodeGain,
   Group: X3DGroupingNode,
   ImageTexture: SFNodeImageTexture,
   IndexedFaceSet: SFNodeIndexedFaceSet,
   IndexedLineSet: SFNodeIndexedLineSet,
   IndexedTriangleFanSet: IndexedTriangles,
   IndexedTriangleSet: IndexedTriangles,
   IndexedTriangleStripSet: IndexedTriangles,
   Inline: SFNodeInline,
   LOD: SFNodeLOD,
   Layer: SFNodeLayer,
   LayerSet: SFNodeLayerSet,
   LineProperties: SFNodeLineProperties,
   LineSet: SFNodeLineSet,
   ListenerPointSource: SFNodeListenerPointSource,
   LoadSensor: SFNodeLoadSensor,
   LocalFog: SFNodeLocalFog,
   Material: SFNodeMaterial,
   Matrix3VertexAttribute: SFNodeMatrix3VertexAttribute,
   Matrix4VertexAttribute: SFNodeMatrix4VertexAttribute,
   MetadataBoolean: MetadataInstance<boolean>,
   MetadataDouble: MetadataInstance<number>,
   MetadataFloat: MetadataInstance<number>,
   MetadataInteger: MetadataInstance<number>,
   MetadataSet: MetadataInstance<X3DMetadataNode>,
   MetadataString: MetadataInstance<string>,
   MicrophoneSource: SFNodeMicrophoneSource,
   MovieTexture: SFNodeMovieTexture,
   MultiTexture: SFNodeMultiTexture,
   MultiTextureCoordinate: SFNodeMultiTextureCoordinate,
   MultiTextureTransform: SFNodeMultiTextureTransform,
   NavigationInfo: SFNodeNavigationInfo,
   Normal: SFNodeNormal,
   NormalInterpolator: X3DInterpolatorNode<SFVec3, X3DArrayField<SFVec3>>,
   OrientationChaser: X3DChaserNode<SFRotation>,
   OrientationDamper: X3DDamperNode<SFRotation>,
   OrientationInterpolator: X3DInterpolatorNode<SFRotation, SFRotation>,
   OrthoViewpoint: X3DViewpointNode,
   OscillatorSource: SFNodeOscillatorSource,
   PackagedShader: SFNodePackagedShader,
   PeriodicWave: SFNodePeriodicWave,
   PhysicalMaterial: SFNodePhysicalMaterial,
   PixelTexture: SFNodePixelTexture,
   PlaneSensor: SFNodePlaneSensor,
   PointLight: SFNodePointLight,
   PointProperties: SFNodePointProperties,
   PointSet: SFNodePointSet,
   PositionChaser: X3DChaserNode<SFVec3>,
   PositionChaser2D: X3DChaserNode<SFVec2>,
   PositionDamper: X3DDamperNode<SFVec3>,
   PositionDamper2D: X3DDamperNode<SFVec2>,
   PositionInterpolator: X3DInterpolatorNode<SFVec3, SFVec3>,
   PositionInterpolator2D: X3DInterpolatorNode<SFVec2, SFVec2>,
   ProgramShader: SFNodeProgramShader,
   ProximitySensor: SFNodeProximitySensor,
   ScalarChaser: X3DChaserNode<number>,
   ScalarDamper: X3DDamperNode<number>,
   ScalarInterpolator: X3DInterpolatorNode<number, number>,
   Script: SFNodeScript,
   ShaderPart: SFNodeShaderPart,
   ShaderProgram: SFNodeShaderProgram,
   Shape: SFNodeShape,
   Sound: SFNodeSound,
   SpatialSound: SFNodeSpatialSound,
   Sphere: SFNodeSphere,
   SphereSensor: SFNodeSphereSensor,
   SplinePositionInterpolator: SplineInterpolator<SFVec3>,
   SplinePositionInterpolator2D: SplineInterpolator<SFVec2>,
   SplineScalarInterpolator: SplineInterpolator<number>,
   SpotLight: SFNodePointLight,
   SquadOrientationInterpolator: SFNodeSquadOrientationInterpolator,
   StaticGroup: SFNodeStaticGroup,
   StreamAudioDestination: SFNodeStreamAudioDestination,
   StreamAudioSource: SFNodeStreamAudioSource,
   Switch: SFNodeSwitch,
   TexCoordChaser2D: X3DChaserNode<X3DArrayField<SFVec2>>,
   TexCoordDamper2D: X3DDamperNode<X3DArrayField<SFVec2>>,
   Text: SFNodeText,
   TextureBackground: SFNodeTextureBackground,
   TextureCoordinate: SFNodeTextureCoordinate,
   TextureCoordinateGenerator: SFNodeTextureCoordinateGenerator,
   TextureProperties: SFNodeTextureProperties,
   TextureTransform: SFNodeTextureTransform,
   TimeSensor: SFNodeTimeSensor,
   TouchSensor: SFNodeTouchSensor,
   Transform: SFNodeTransform,
   TransformSensor: SFNodeTransformSensor,
   TriangleFanSet: SFNodeTriangleFanSet,
   TriangleSet: SFNodeTriangleSet,
   TriangleStripSet: SFNodeTriangleStripSet,
   TwoSidedMaterial: SFNodeTwoSidedMaterial,
   UnlitMaterial: SFNodeUnlitMaterial,
   Viewpoint: X3DViewpointNode,
   ViewpointGroup: SFNodeViewpointGroup,
   Viewport: SFNodeViewport,
   VisibilitySensor: X3DEnvironmentalSensorNode,
   WaveShaper: SFNodeWaveShaper,
   WorldInfo: SFNodeWorldInfo,
   [name: string]: SFNode // catchall
}

type FieldDefinitionArray = Map<unknown, X3DFieldDefinition>;
export type X3DFieldDefinition = {
   accessType: number, // that's a guess
   dataType: string,
   name: string,
   value: unknown // I don't think we can do better without parsing the
                  // possible values for dataType...
}
type VRMLOptions = {
   style?: string,
   indent?: string,
   precision?: number,
   doublePrecision?: number,
   html?: boolean,
   closingTags?: boolean
}

export class SFRotation extends X3DField {
   constructor();
   constructor(x: number, y: number, z: number, angle: number);
   constructor(axis: SFVec3, angle: number);
   constructor(from: SFVec3, to: SFVec3);
   constructor(matrix: SFMatrix3);
   x: number;
   y: number;
   z: number;
   angle: number;

   copy(): SFRotation;
   isDefaultValue(): boolean;
   set(other: SFRotation): void;

   getAxis(): SFVec3;
   getMatrix(): SFMatrix3;
   inverse(): SFRotation;
   multiply(other: SFRotation): SFRotation;
   multVec(subject: SFVec3): SFVec3;
   setAxis(axis: SFVec3): void;
   setMatrix(matrix: SFMatrix3): void;
   slerp(destination: SFRotation, t: number): SFRotation;
}

export class SFString extends X3DField {
   constructor(arg?: unknown);
   copy(): SFString;
   isDefaultValue(): boolean;
   set(arg: unknown): void;
   valueOf(): string;
   length: number;
}

export class SFTime extends X3DField {
   constructor(arg?: unknown);
   copy(): SFTime;
   isDefaultValue(): boolean;
   set(arg: unknown): void;
   valueOf(): number; // I think that's the right type...
}

export class SFVec2 extends X3DField {
   constructor(x?: number, y?: number);
   x: number;
   y: number;

   copy(): SFVec2;
   isDefaultValue(): boolean;
   set(other: SFVec2): void;

   abs(): SFVec2;
   add(other: SFVec2): SFVec2;
   distance(other: SFVec2): number;
   divide(denominator: number): SFVec2;
   divVec(other: SFVec2): SFVec2;
   dot(other: SFVec2): number;
   inverse(): SFVec2;
   length(): number;
   lerp(destination: SFVec2, t: number): SFVec2;
   min(other: SFVec2): SFVec2;
   max(other: SFVec2): SFVec2;
   multiply(factor: number): SFVec2;
   multVec(other: SFVec2): SFVec2;
   negate(): SFVec2;
   normalize(): SFVec2;
   subtract(other: SFVec2): SFVec2;
}

export class SFVec3 extends X3DField {
   constructor(x?: number, y?: number, z?: number);
   x: number;
   y: number;
   z: number;

   copy(): SFVec3;
   isDefaultValue(): boolean;
   set(other: SFVec3): void;

   abs(): SFVec3;
   add(other: SFVec3): SFVec3;
   cross(other: SFVec3): SFVec3;
   distance(other: SFVec3): number;
   divide(denominator: number): SFVec3;
   divVec(other: SFVec3): SFVec3;
   dot(other: SFVec3): number;
   inverse(): SFVec3;
   length(): number;
   lerp(destination: SFVec3, t: number): SFVec3;
   min(other: SFVec3): SFVec3;
   max(other: SFVec3): SFVec3;
   multiply(factor: number): SFVec3;
   multVec(other: SFVec3): SFVec3;
   negate(): SFVec3;
   normalize(): SFVec3;
   subtract(other: SFVec3): SFVec3;
}

export class SFVec4 extends X3DField {
   constructor(x?: number, y?: number, z?: number, w?: number);
   x: number;
   y: number;
   z: number;
   w: number;

   copy(): SFVec4;
   isDefaultValue(): boolean;
   set(other: SFVec4): void;

   abs(): SFVec4;
   add(other: SFVec4): SFVec4;
   distance(other: SFVec4): number;
   divide(denominator: number): SFVec4;
   divVec(other: SFVec4): SFVec4;
   dot(other: SFVec4): number;
   inverse(): SFVec4;
   length(): number;
   lerp(destination: SFVec4, t: number): SFVec4;
   min(other: SFVec4): SFVec4;
   max(other: SFVec4): SFVec4;
   multiply(factor: number): SFVec4;
   multVec(other: SFVec4): SFVec4;
   negate(): SFVec4;
   normalize(): SFVec4;
   subtract(other: SFVec4): SFVec4;
}

type ArrayTest<T> = (elt: T, ix: boolean, arr: X3DArrayField<T>) => boolean
type ArrayAction<T> = (elt: T, ix: boolean, arr: X3DArrayField<T>) => void
type ArrayReducer<T,U> =
   (acc: U, elt: T, ix: number, arr: X3DArrayField<T>) => U
export class X3DArrayField<T> extends X3DField {
   constructor(...elts: T[]);
   [index: number]: T;
   length: number;
   at(index: number): T;
   entries(): IterableIterator<[number, T]>;
   every(predicate: ArrayTest<T>): boolean;
   fill(val: T, start?: number, end?: number): X3DArrayField<T>;
   filter(predicate: ArrayTest<T>): X3DArrayField<T>;
   find(test: ArrayTest<T>): T | undefined;
   findIndex(test: ArrayTest<T>): number;
   findLast(test: ArrayTest<T>): T | undefined;
   findLastIndex(test: ArrayTest<T>): number;
   forEach(action: ArrayAction<T>): void;
   includes(needle: T): boolean;
   indexOf(needle: T): number;
   join(separator?: string): string;
   keys(): number[];
   lastIndexOf(needle: T): number;
   map<U>(f: (elt: T, ix: number, arr: X3DArrayField<T>) => U): U[];
   pop(): T;
   push(...elts: T[]): number;
   reduce<U>(f: ArrayReducer<T,U>, initial?: U): U;
   reduceRight<U>(f: ArrayReducer<T,U>, initial?: U): U;
   reverse(): X3DArrayField<T>;
   shift(): T;
   slice(start?: number, end?: number): X3DArrayField<T>;
   some(predicate: ArrayTest<T>): boolean;
   sort(comparator?: (a: T, b: T) => number): X3DArrayField<T>;
   splice(start: number, deleteCount: number,
          ...rest: T[]) : X3DArrayField<T>;
   toReversed(): X3DArrayField<T>;
   toSorted(comparator?: (a: T, b: T) => number): X3DArrayField<T>;
   toSpliced(start: number, deleteCount: number,
             ...rest: T[]) : X3DArrayField<T>;
   unshift(...elts: T[]): number;
   values(): IterableIterator<T>;
   with(index: number, value: T): X3DArrayField<T>;
}

// would be better to make these enums...
export interface X3DConstants {
   // Browser Event Constants
   CONNECTION_ERROR: 0;
   BROWSER_EVENT: 1;
   INITIALIZED_EVENT: 2;
   SHUTDOWN_EVENT: 3;
   INITIALIZED_ERROR: 4;
   // Load State Constants
   NOT_STARTED_STATE: 0;
   IN_PROGRESS_STATE: 1;
   COMPLETE_STATE: 2;
   FAILED_STATE: 3;
   // Access Type Constants
   initializeOnly: 1;
   inputOnly: 2;
   outputOnly: 4;
   inputOutput: 7;
   // Field Type Constants
   SFBool: 0;
   SFColor: 1;
   SFColorRGBA: 2;
   SFDouble: 3;
   SFFloat: 4;
   SFImage: 5;
   SFInt32: 6;
   SFMatrix3d: 7;
   SFMatrix3f: 8;
   SFMatrix4d: 9;
   SFMatrix4f: 10;
   SFNode: 11;
   SFRotation: 12;
   SFString: 13;
   SFTime: 14;
   SFVec2d: 15;
   SFVec2f: 16;
   SFVec3d: 17;
   SFVec3f: 18;
   SFVec4d: 19;
   SFVec4f: 20;
   MFBool: 22;
   MFColor: 23;
   MFColorRGBA: 24;
   MFDouble: 25;
   MFFloat: 26;
   MFImage: 27;
   MFInt32: 28;
   MFMatrix3d: 29;
   MFMatrix3f: 30;
   MFMatrix4d: 31;
   MFMatrix4f: 32;
   MFNode: 33;
   MFRotation: 34;
   MFString: 35;
   MFTime: 36;
   MFVec2d: 37;
   MFVec2f: 38;
   MFVec3d: 39;
   MFVec3f: 40;
   MFVec4d: 41;
   MFVec4f: 42;
   // Concrete Node Types
   AcousticProperties: 140;
   Analyser: 155;
   Anchor: 96;
   Appearance: 141;
   AudioClip: 156;
   AudioDestination: 157;
   Background: 21;
   Billboard: 88;
   BiquadFilter: 158;
   Box: 49;
   BufferAudioSource: 159;
   ChannelMerger: 160;
   ChannelSelector: 161;
   ChannelSplitter: 162;
   ClipPlane: 108;
   Collision: 89;
   Color: 109;
   ColorChaser: 32;
   ColorDamper: 33;
   ColorInterpolator: 64;
   ColorRGBA: 110;
   ComposedShader: 129;
   Cone: 50;
   Convolver: 163;
   Coordinate: 111;
   CoordinateChaser: 34;
   CoordinateDamper: 35;
   CoordinateInterpolator: 65;
   CoordinateInterpolator2D: 66;
   Cylinder: 51;
   CylinderSensor: 101;
   Delay: 164;
   DirectionalLight: 83;
   DynamicsCompressor: 165;
   EaseInEaseOut: 67;
   ElevationGrid: 52;
   EnvironmentLight: 84;
   Extrusion: 53;
   FillProperties: 142;
   FloatVertexAttribute: 130;
   Fog: 22;
   FogCoordinate: 23;
   FontStyle: 203;
   Gain: 166;
   Group: 56;
   ImageTexture: 181;
   IndexedFaceSet: 54;
   IndexedLineSet: 112;
   IndexedTriangleFanSet: 113;
   IndexedTriangleSet: 114;
   IndexedTriangleStripSet: 115;
   Inline: 97;
   LOD: 90;
   Layer: 78;
   LayerSet: 79;
   LineProperties: 143;
   LineSet: 116;
   ListenerPointSource: 167;
   LoadSensor: 98;
   LocalFog: 24;
   Material: 144;
   Matrix3VertexAttribute: 131;
   Matrix4VertexAttribute: 132;
   MetadataBoolean: 7;
   MetadataDouble: 8;
   MetadataFloat: 9;
   MetadataInteger: 10;
   MetadataSet: 11;
   MetadataString: 12;
   MicrophoneSource: 168;
   MovieTexture: 182;
   MultiTexture: 183;
   MultiTextureCoordinate: 184;
   MultiTextureTransform: 185;
   NavigationInfo: 91;
   Normal: 117;
   NormalInterpolator: 68;
   OrientationChaser: 36;
   OrientationDamper: 37;
   OrientationInterpolator: 69;
   OrthoViewpoint: 92;
   OscillatorSource: 169;
   PackagedShader: 133;
   PeriodicWave: 170;
   PhysicalMaterial: 145;
   PixelTexture: 186;
   PlaneSensor: 102;
   PointLight: 85;
   PointProperties: 146;
   PointSet: 118;
   PositionChaser: 38;
   PositionChaser2D: 39;
   PositionDamper: 40;
   PositionDamper2D: 41;
   PositionInterpolator: 70;
   PositionInterpolator2D: 71;
   ProgramShader: 134;
   ProximitySensor: 28;
   ScalarChaser: 42;
   ScalarDamper: 43;
   ScalarInterpolator: 72;
   Script: 201;
   ShaderPart: 135;
   ShaderProgram: 136;
   Shape: 147;
   Sound: 171;
   SpatialSound: 172;
   Sphere: 55;
   SphereSensor: 103;
   SplinePositionInterpolator: 73;
   SplinePositionInterpolator2D: 74;
   SplineScalarInterpolator: 75;
   SpotLight: 86;
   SquadOrientationInterpolator: 76;
   StaticGroup: 57;
   StreamAudioDestination: 173;
   StreamAudioSource: 174;
   Switch: 58;
   TexCoordChaser2D: 44;
   TexCoordDamper2D: 45;
   Text: 204;
   TextureBackground: 25;
   TextureCoordinate: 187;
   TextureCoordinateGenerator: 188;
   TextureProperties: 189;
   TextureTransform: 190;
   TimeSensor: 198;
   TouchSensor: 104;
   Transform: 59;
   TransformSensor: 29;
   TriangleFanSet: 119;
   TriangleSet: 120;
   TriangleStripSet: 121;
   TwoSidedMaterial: 148;
   UnlitMaterial: 149;
   Viewpoint: 93;
   ViewpointGroup: 94;
   Viewport: 80;
   VisibilitySensor: 30;
   VrmlMatrix: 21;
   WaveShaper: 175;
   WorldInfo: 13;
   // Abstract Node Types
   X3DAppearanceChildNode: 150;
   X3DAppearanceNode: 151;
   X3DBackgroundNode: 26;
   X3DBaseNode: 0;
   X3DBindableNode: 14;
   X3DBoundedObject: 60;
   X3DBrowser: 200;
   X3DChaserNode: 46;
   X3DChildNode: 15;
   X3DColorNode: 122;
   X3DComposedGeometryNode: 123;
   X3DCoordinateNode: 124;
   X3DDamperNode: 47;
   X3DDragSensorNode: 105;
   X3DEnvironmentalSensorNode: 31;
   X3DExecutionContext: 5;
   X3DExternProtoDeclaration: 4;
   X3DFogObject: 27;
   X3DFollowerNode: 48;
   X3DFontStyleNode: 205;
   X3DGeometricPropertyNode: 125;
   X3DGeometryNode: 126;
   X3DGroupingNode: 61;
   X3DInfoNode: 16;
   X3DInterpolatorNode: 77;
   X3DLayerNode: 81;
   X3DLightNode: 87;
   X3DLineGeometryNode: 127;
   X3DMaterialNode: 152;
   X3DMetadataObject: 17;
   X3DNetworkSensorNode: 99;
   X3DNode: 18;
   X3DNormalNode: 128;
   X3DOneSidedMaterialNode: 153;
   X3DPointingDeviceSensorNode: 106;
   X3DProgrammableShaderObject: 137;
   X3DProtoDeclaration: 2;
   X3DProtoDeclarationNode: 1;
   X3DPrototypeInstance: 19;
   X3DScene: 6;
   X3DScriptNode: 202;
   X3DSensorNode: 20;
   X3DShaderNode: 138;
   X3DShapeNode: 154;
   X3DSingleTextureCoordinateNode: 191;
   X3DSingleTextureNode: 192;
   X3DSingleTextureTransformNode: 193;
   X3DSoundChannelNode: 176;
   X3DSoundDestinationNode: 177;
   X3DSoundNode: 178;
   X3DSoundProcessingNode: 179;
   X3DSoundSourceNode: 180;
   X3DTexture2DNode: 194;
   X3DTextureCoordinateNode: 195;
   X3DTextureNode: 196;
   X3DTextureTransformNode: 197;
   X3DTimeDependentNode: 199;
   X3DTouchSensorNode: 107;
   X3DTransformMatrix3DNode: 62;
   X3DTransformNode: 63;
   X3DUrlObject: 100;
   X3DVertexAttributeNode: 139;
   X3DViewpointNode: 95;
   X3DViewportNode: 82;
   X3DWorld: 3;
}
}