x_ite 8.12.0 → 8.12.1

package/dist/x_ite.d.ts

@@ -0,0 +1,2096 @@
+declare 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: string;
+}
+
+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
+
+declare 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;
+}