@vue-godot/cli 0.0.1

package/templates/typings/godot.mix.d.ts

@@ -0,0 +1,257 @@
+/// <reference no-default-lib="true"/>
+declare module "godot" {
+    export const IntegerType: unique symbol;
+    export const FloatType: unique symbol;
+
+    /** A built-in type representing a method or a standalone function.  
+     *  	  
+     *  @link https://docs.godotengine.org/en/4.2/classes/class_callable.html  
+     */
+    interface AnyCallable {
+        /** Returns `true` if this [Callable] has no target to call the method on. */
+        is_null(): boolean
+
+        /** Returns `true` if this [Callable] is a custom callable. Custom callables are created from [method bind] or [method unbind]. In GDScript, lambda functions are also custom callables. */
+        is_custom(): boolean
+
+        /** Returns `true` if this [Callable] is a standard callable. This method is the opposite of [method is_custom]. Returns `false` if this callable is a lambda function. */
+        is_standard(): boolean
+
+        /** Returns `true` if the callable's object exists and has a valid method name assigned, or is a custom callable. */
+        is_valid(): boolean
+
+        /** Returns the object on which this [Callable] is called. */
+        get_object(): Object
+
+        /** Returns the ID of this [Callable]'s object (see [method Object.get_instance_id]). */
+        get_object_id(): int64
+
+        /** Returns the name of the method represented by this [Callable]. If the callable is a GDScript lambda function, returns the function's name or `"<anonymous lambda>"`. */
+        get_method(): StringName
+
+        /** Returns the total amount of arguments bound (or unbound) via successive [method bind] or [method unbind] calls. If the amount of arguments unbound is greater than the ones bound, this function returns a value less than zero. */
+        get_bound_arguments_count(): int64
+
+        /** Return the bound arguments (as long as [method get_bound_arguments_count] is greater than zero), or empty (if [method get_bound_arguments_count] is less than or equal to zero). */
+        get_bound_arguments(): Array
+
+        /** Returns the 32-bit hash value of this [Callable]'s object.  
+         *      
+         *  **Note:** [Callable]s with equal content will always produce identical hash values. However, the reverse is not true. Returning identical hash values does  *not*  imply the callables are equal, because different callables can have identical hash values due to hash collisions. The engine uses a 32-bit hash algorithm for [method hash].  
+         */
+        hash(): int64
+
+        /** Returns a copy of this [Callable] with one or more arguments bound. When called, the bound arguments are passed  *after*  the arguments supplied by [method call]. See also [method unbind].  
+         *      
+         *  **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.  
+         */
+        bind(...vargargs: any[]): AnyCallable
+
+        /** Returns a copy of this [Callable] with one or more arguments bound, reading them from an array. When called, the bound arguments are passed  *after*  the arguments supplied by [method call]. See also [method unbind].  
+         *      
+         *  **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.  
+         */
+        bindv(arguments_: GArray): AnyCallable
+
+        /** Returns a copy of this [Callable] with a number of arguments unbound. In other words, when the new callable is called the last few arguments supplied by the user are ignored, according to [param argcount]. The remaining arguments are passed to the callable. This allows to use the original callable in a context that attempts to pass more arguments than this callable can handle, e.g. a signal with a fixed number of arguments. See also [method bind].  
+         *      
+         *  **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.  
+         *    
+         */
+        unbind(argcount: int64): AnyCallable
+        
+        /** Calls the method represented by this [Callable]. Arguments can be passed and should match the method's signature. */
+        call(...vargargs: any[]): any
+        
+        /** Calls the method represented by this [Callable]. Unlike [method call], this method expects all arguments to be contained inside the [param arguments] [Array]. */
+        callv(arguments_: GArray): any
+        
+        /** Calls the method represented by this [Callable] in deferred mode, i.e. at the end of the current frame. Arguments can be passed and should match the method's signature.  
+         *    
+         *      
+         *  **Note:** Deferred calls are processed at idle time. Idle time happens mainly at the end of process and physics frames. In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.  
+         *  See also [method Object.call_deferred].  
+         */
+        call_deferred(...vargargs: any[]): void
+    }
+
+    /** A built-in type representing a signal of an [Object].  
+     *  	  
+     *  @link https://docs.godotengine.org/en/4.2/classes/class_signal.html  
+     */
+    interface AnySignal {
+        /** Returns `true` if the signal's name does not exist in its object, or the object is not valid. */
+        is_null(): boolean
+
+        /** Returns the object emitting this signal. */
+        get_object(): Object
+
+        /** Returns the ID of the object emitting this signal (see [method Object.get_instance_id]). */
+        get_object_id(): int64
+
+        /** Returns the name of this signal. */
+        get_name(): StringName
+
+        /** Returns `true` if the specified [Callable] is connected to this signal. */
+        is_connected(callable: AnyCallable): boolean
+
+        /** Returns an [Array] of connections for this signal. Each connection is represented as a [Dictionary] that contains three entries:  
+         *  - `signal` is a reference to this signal;  
+         *  - `callable` is a reference to the connected [Callable];  
+         *  - `flags` is a combination of [enum Object.ConnectFlags].  
+         */
+        get_connections(): Array
+    }
+
+    interface Callable0<R = void> extends AnyCallable {
+        call(): R;
+    }
+
+    interface Callable1<T1, R = void> extends AnyCallable {
+        call(v1: T1): R;
+    }
+
+    interface Callable2<T1, T2, R = void> extends AnyCallable {
+        call(v1: T1, v2, T2): R;
+    }
+
+    interface Callable3<T1, T2, T3, R = void> extends AnyCallable {
+        call(v1: T1, v2: T2, v3: T3): R;
+    }
+
+    interface Callable4<T1, T2, T3, T4, R = void> extends AnyCallable {
+        call(v1: T1, v2: T2, v3: T3, v4: T4): R;
+    }
+
+    interface Callable5<T1, T2, T3, T4, T5, R = void> extends AnyCallable {
+        call(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): R;
+    }
+
+    interface Signal0 extends AnySignal {
+        connect(callable: Callable0, flags: int64 = 0): void;
+        disconnect(callable: Callable0): void;
+        is_connected(callable: Callable0): boolean;
+        emit(): void;
+
+        as_promise(): Promise<void>;
+    }
+
+    interface Signal1<T1> extends AnySignal {
+        connect(callable: Callable1<T1>, flags: int64 = 0): void;
+        disconnect(callable: Callable1<T1>): void;
+        is_connected(callable: Callable1<T1>): boolean;
+        emit(v1: T1): void;
+
+        // the first argument is used as the resolved value
+        as_promise(): Promise<T1>;
+    }
+
+    interface Signal2<T1, T2> extends AnySignal {
+        connect(callable: Callable2<T1, T2>, flags: int64 = 0): void;
+        disconnect(callable: Callable2<T1, T2>): void;
+        is_connected(callable: Callable2<T1, T2>): boolean;
+        emit(v1: T1, v2: T2): void;
+
+        // the first argument is used as the resolved value
+        as_promise(): Promise<T1>;
+    }
+
+    interface Signal3<T1, T2, T3> extends AnySignal {
+        connect(callable: Callable3<T1, T2, T3>, flags: int64 = 0): void;
+        disconnect(callable: Callable3<T1, T2, T3>): void;
+        is_connected(callable: Callable3<T1, T2, T3>): boolean;
+        emit(v1: T1, v2: T2, v3: T3): void;
+
+        // the first argument is used as the resolved value
+        as_promise(): Promise<T1>;
+    }
+
+    interface Signal4<T1, T2, T3, T4> extends AnySignal {
+        connect(callable: Callable4<T1, T2, T3, T4>, flags: int64 = 0): void;
+        disconnect(callable: Callable4<T1, T2, T3, T4>): void;
+        is_connected(callable: Callable4<T1, T2, T3, T4>): boolean;
+        emit(v1: T1, v2: T2, v3: T3, v4: T4): void;
+
+        // the first argument is used as the resolved value
+        as_promise(): Promise<T1>;
+    }
+
+    interface Signal5<T1, T2, T3, T4, T5> extends AnySignal {
+        connect(callable: Callable5<T1, T2, T3, T4, T5>, flags: int64 = 0): void;
+        disconnect(callable: Callable5<T1, T2, T3, T4, T5>): void;
+        is_connected(callable: Callable5<T1, T2, T3, T4, T5>): boolean;
+        emit(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): void;
+
+        // the first argument is used as the resolved value
+        as_promise(): Promise<T1>;
+    }
+
+    type NodePathMap = { [K in string]?: Node };
+
+    type StaticNodePath<Map extends NodePathMap> = (keyof Map & string) | {
+        [K in keyof Map & string]: Map[K] extends Node<infer ChildMap>
+            ? `${K}/${StaticNodePath<ChildMap>}`
+            : never
+    }[keyof Map & string];
+
+    type ResolveNodePath<Map extends NodePathMap, Path extends string, Default = never> = Path extends keyof Map
+        ? Map[Path]
+        : Path extends `${infer Key extends keyof Map & string}/${infer SubPath}`
+            ? Map[Key] extends Node<infer ChildMap>
+                ? ResolveNodePath<ChildMap, SubPath, Default>
+                : Default
+            : Default;
+
+    /**
+     * GArray elements are exposed with a subset of JavaScript's standard Array API. Array indexes are exposed as
+     * enumerable properties, thus if you want to perform more complex operations you can convert to a regular
+     * JavaScript array with [...g_array.proxy()].
+     */
+    class GArrayProxy<T> {
+        [Symbol.iterator](): IteratorObject<GProxyValueWrap<T>>;
+        /**
+         * Gets the length of the array. This is a number one higher than the highest index in the array.
+         */
+        get length(): number;
+        /**
+         * Removes the last element from an array and returns it.
+         * If the array is empty, undefined is returned and the array is not modified.
+         */
+        pop(): T | undefined;
+        /**
+         * Appends new elements to the end of an array, and returns the new length of the array.
+         * @param items New elements to add to the array.
+         */
+        push(...items: Array<T | GProxyValueWrap<T>>): number;
+        /**
+         * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
+         * @param searchElement The value to locate in the array.
+         * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
+         */
+        indexOf(searchElement: T, fromIndex?: number): number;
+        /**
+         * Determines whether an array includes a certain element, returning true or false as appropriate.
+         * @param searchElement The element to search for.
+         */
+        includes(searchElement: T): boolean;
+        toJSON(key?: any): any;
+        toString(): string;
+        [n: number]: T | GProxyValueWrap<T>; // More accurate get type blocked by https://github.com/microsoft/TypeScript/issues/43826
+    }
+
+    // Ideally this would be a class, but TS currently doesn't provide a way to type a class with mapped properties.
+    /**
+     * GObject entries are exposed as enumerable properties, so Object.keys(), Object.entries() etc. will work.
+     */
+    type GDictionaryProxy<T> = {
+        [K in keyof T & string]: T[K] | GProxyValueWrap<T[K]>; // More accurate get type blocked by https://github.com/microsoft/TypeScript/issues/43826
+    } & ('toString' extends keyof T ? {} : {
+        toString(): string;
+    });
+
+    type GProxyValueWrap<V> = V extends GArray<infer E>
+        ? GArrayProxy<E>
+        : V extends GDictionary<infer T>
+            ? GDictionaryProxy<T>
+            : V;
+}

package/templates/typings/godot.vue-components.gen.d.ts

@@ -0,0 +1,216 @@
+// AUTO-GENERATED by @vue-godot/types-gen — do not edit manually
+// Augments @vue/runtime-core GlobalComponents so Volar provides
+// typed props when using Godot nodes in Vue templates.
+
+import type { AllowedComponentProps, VNodeProps } from "@vue/runtime-core"
+
+/**
+ * Extracts settable (non-method) instance properties from a Godot node class.
+ * All keys become optional since props are optional in Vue templates.
+ */
+type GodotProps<T> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]?: T[K]
+}
+
+declare module "@vue/runtime-core" {
+  interface GlobalComponents {
+    AbstractPolygon2DEditor: new () => { $props: GodotProps<import("godot").AbstractPolygon2DEditor> & AllowedComponentProps & VNodeProps }
+    ActionMapEditor: new () => { $props: GodotProps<import("godot").ActionMapEditor> & AllowedComponentProps & VNodeProps }
+    AnchorPresetPicker: new () => { $props: GodotProps<import("godot").AnchorPresetPicker> & AllowedComponentProps & VNodeProps }
+    AnimationBezierTrackEdit: new () => { $props: GodotProps<import("godot").AnimationBezierTrackEdit> & AllowedComponentProps & VNodeProps }
+    AnimationMarkerEdit: new () => { $props: GodotProps<import("godot").AnimationMarkerEdit> & AllowedComponentProps & VNodeProps }
+    AnimationNodeBlendSpace1DEditor: new () => { $props: GodotProps<import("godot").AnimationNodeBlendSpace1DEditor> & AllowedComponentProps & VNodeProps }
+    AnimationNodeBlendSpace2DEditor: new () => { $props: GodotProps<import("godot").AnimationNodeBlendSpace2DEditor> & AllowedComponentProps & VNodeProps }
+    AnimationNodeBlendTreeEditor: new () => { $props: GodotProps<import("godot").AnimationNodeBlendTreeEditor> & AllowedComponentProps & VNodeProps }
+    AnimationNodeStateMachineEditor: new () => { $props: GodotProps<import("godot").AnimationNodeStateMachineEditor> & AllowedComponentProps & VNodeProps }
+    AnimationPlayerEditor: new () => { $props: GodotProps<import("godot").AnimationPlayerEditor> & AllowedComponentProps & VNodeProps }
+    AnimationTimelineEdit: new () => { $props: GodotProps<import("godot").AnimationTimelineEdit> & AllowedComponentProps & VNodeProps }
+    AnimationTrackEditor: new () => { $props: GodotProps<import("godot").AnimationTrackEditor> & AllowedComponentProps & VNodeProps }
+    AnimationTreeEditor: new () => { $props: GodotProps<import("godot").AnimationTreeEditor> & AllowedComponentProps & VNodeProps }
+    AnimationTreeNodeEditorPlugin: new () => { $props: GodotProps<import("godot").AnimationTreeNodeEditorPlugin> & AllowedComponentProps & VNodeProps }
+    AspectRatioContainer: new () => { $props: GodotProps<import("godot").AspectRatioContainer> & AllowedComponentProps & VNodeProps }
+    BackgroundProgress: new () => { $props: GodotProps<import("godot").BackgroundProgress> & AllowedComponentProps & VNodeProps }
+    BaseButton: new () => { $props: GodotProps<import("godot").BaseButton> & AllowedComponentProps & VNodeProps }
+    BoxContainer: new () => { $props: GodotProps<import("godot").BoxContainer> & AllowedComponentProps & VNodeProps }
+    Button: new () => { $props: GodotProps<import("godot").Button> & AllowedComponentProps & VNodeProps }
+    CSGShapeEditor: new () => { $props: GodotProps<import("godot").CSGShapeEditor> & AllowedComponentProps & VNodeProps }
+    CanvasItemEditor: new () => { $props: GodotProps<import("godot").CanvasItemEditor> & AllowedComponentProps & VNodeProps }
+    CanvasItemEditorViewport: new () => { $props: GodotProps<import("godot").CanvasItemEditorViewport> & AllowedComponentProps & VNodeProps }
+    Cast2DEditor: new () => { $props: GodotProps<import("godot").Cast2DEditor> & AllowedComponentProps & VNodeProps }
+    CenterContainer: new () => { $props: GodotProps<import("godot").CenterContainer> & AllowedComponentProps & VNodeProps }
+    CheckBox: new () => { $props: GodotProps<import("godot").CheckBox> & AllowedComponentProps & VNodeProps }
+    CheckButton: new () => { $props: GodotProps<import("godot").CheckButton> & AllowedComponentProps & VNodeProps }
+    CodeEdit: new () => { $props: GodotProps<import("godot").CodeEdit> & AllowedComponentProps & VNodeProps }
+    CollisionPolygon2DEditor: new () => { $props: GodotProps<import("godot").CollisionPolygon2DEditor> & AllowedComponentProps & VNodeProps }
+    CollisionShape2DEditor: new () => { $props: GodotProps<import("godot").CollisionShape2DEditor> & AllowedComponentProps & VNodeProps }
+    ColorPicker: new () => { $props: GodotProps<import("godot").ColorPicker> & AllowedComponentProps & VNodeProps }
+    ColorPickerButton: new () => { $props: GodotProps<import("godot").ColorPickerButton> & AllowedComponentProps & VNodeProps }
+    ColorRect: new () => { $props: GodotProps<import("godot").ColorRect> & AllowedComponentProps & VNodeProps }
+    ConnectionsDock: new () => { $props: GodotProps<import("godot").ConnectionsDock> & AllowedComponentProps & VNodeProps }
+    Container: new () => { $props: GodotProps<import("godot").Container> & AllowedComponentProps & VNodeProps }
+    Control: new () => { $props: GodotProps<import("godot").Control> & AllowedComponentProps & VNodeProps }
+    ControlEditorPopupButton: new () => { $props: GodotProps<import("godot").ControlEditorPopupButton> & AllowedComponentProps & VNodeProps }
+    ControlEditorPresetPicker: new () => { $props: GodotProps<import("godot").ControlEditorPresetPicker> & AllowedComponentProps & VNodeProps }
+    ControlEditorToolbar: new () => { $props: GodotProps<import("godot").ControlEditorToolbar> & AllowedComponentProps & VNodeProps }
+    DefaultThemeEditorPreview: new () => { $props: GodotProps<import("godot").DefaultThemeEditorPreview> & AllowedComponentProps & VNodeProps }
+    DockSplitContainer: new () => { $props: GodotProps<import("godot").DockSplitContainer> & AllowedComponentProps & VNodeProps }
+    EditorAssetLibrary: new () => { $props: GodotProps<import("godot").EditorAssetLibrary> & AllowedComponentProps & VNodeProps }
+    EditorAudioBus: new () => { $props: GodotProps<import("godot").EditorAudioBus> & AllowedComponentProps & VNodeProps }
+    EditorAudioBuses: new () => { $props: GodotProps<import("godot").EditorAudioBuses> & AllowedComponentProps & VNodeProps }
+    EditorAudioMeterNotches: new () => { $props: GodotProps<import("godot").EditorAudioMeterNotches> & AllowedComponentProps & VNodeProps }
+    EditorAutoloadSettings: new () => { $props: GodotProps<import("godot").EditorAutoloadSettings> & AllowedComponentProps & VNodeProps }
+    EditorBottomPanel: new () => { $props: GodotProps<import("godot").EditorBottomPanel> & AllowedComponentProps & VNodeProps }
+    EditorDebuggerInspector: new () => { $props: GodotProps<import("godot").EditorDebuggerInspector> & AllowedComponentProps & VNodeProps }
+    EditorDebuggerNode: new () => { $props: GodotProps<import("godot").EditorDebuggerNode> & AllowedComponentProps & VNodeProps }
+    EditorDebuggerTree: new () => { $props: GodotProps<import("godot").EditorDebuggerTree> & AllowedComponentProps & VNodeProps }
+    EditorExpressionEvaluator: new () => { $props: GodotProps<import("godot").EditorExpressionEvaluator> & AllowedComponentProps & VNodeProps }
+    EditorHelpBit: new () => { $props: GodotProps<import("godot").EditorHelpBit> & AllowedComponentProps & VNodeProps }
+    EditorInspector: new () => { $props: GodotProps<import("godot").EditorInspector> & AllowedComponentProps & VNodeProps }
+    EditorInspectorCategory: new () => { $props: GodotProps<import("godot").EditorInspectorCategory> & AllowedComponentProps & VNodeProps }
+    EditorLog: new () => { $props: GodotProps<import("godot").EditorLog> & AllowedComponentProps & VNodeProps }
+    EditorMainScreen: new () => { $props: GodotProps<import("godot").EditorMainScreen> & AllowedComponentProps & VNodeProps }
+    EditorNetworkProfiler: new () => { $props: GodotProps<import("godot").EditorNetworkProfiler> & AllowedComponentProps & VNodeProps }
+    EditorObjectSelector: new () => { $props: GodotProps<import("godot").EditorObjectSelector> & AllowedComponentProps & VNodeProps }
+    EditorPerformanceProfiler: new () => { $props: GodotProps<import("godot").EditorPerformanceProfiler> & AllowedComponentProps & VNodeProps }
+    EditorPluginSettings: new () => { $props: GodotProps<import("godot").EditorPluginSettings> & AllowedComponentProps & VNodeProps }
+    EditorProfiler: new () => { $props: GodotProps<import("godot").EditorProfiler> & AllowedComponentProps & VNodeProps }
+    EditorProperty: new () => { $props: GodotProps<import("godot").EditorProperty> & AllowedComponentProps & VNodeProps }
+    EditorPropertyCheck: new () => { $props: GodotProps<import("godot").EditorPropertyCheck> & AllowedComponentProps & VNodeProps }
+    EditorPropertyInteger: new () => { $props: GodotProps<import("godot").EditorPropertyInteger> & AllowedComponentProps & VNodeProps }
+    EditorPropertyLocalizableString: new () => { $props: GodotProps<import("godot").EditorPropertyLocalizableString> & AllowedComponentProps & VNodeProps }
+    EditorPropertyMultilineText: new () => { $props: GodotProps<import("godot").EditorPropertyMultilineText> & AllowedComponentProps & VNodeProps }
+    EditorPropertyPath: new () => { $props: GodotProps<import("godot").EditorPropertyPath> & AllowedComponentProps & VNodeProps }
+    EditorPropertyResource: new () => { $props: GodotProps<import("godot").EditorPropertyResource> & AllowedComponentProps & VNodeProps }
+    EditorPropertyText: new () => { $props: GodotProps<import("godot").EditorPropertyText> & AllowedComponentProps & VNodeProps }
+    EditorPropertyVector2i: new () => { $props: GodotProps<import("godot").EditorPropertyVector2i> & AllowedComponentProps & VNodeProps }
+    EditorPropertyVectorN: new () => { $props: GodotProps<import("godot").EditorPropertyVectorN> & AllowedComponentProps & VNodeProps }
+    EditorResourcePicker: new () => { $props: GodotProps<import("godot").EditorResourcePicker> & AllowedComponentProps & VNodeProps }
+    EditorRunBar: new () => { $props: GodotProps<import("godot").EditorRunBar> & AllowedComponentProps & VNodeProps }
+    EditorRunNative: new () => { $props: GodotProps<import("godot").EditorRunNative> & AllowedComponentProps & VNodeProps }
+    EditorSceneTabs: new () => { $props: GodotProps<import("godot").EditorSceneTabs> & AllowedComponentProps & VNodeProps }
+    EditorScriptPicker: new () => { $props: GodotProps<import("godot").EditorScriptPicker> & AllowedComponentProps & VNodeProps }
+    EditorSpinSlider: new () => { $props: GodotProps<import("godot").EditorSpinSlider> & AllowedComponentProps & VNodeProps }
+    EditorTitleBar: new () => { $props: GodotProps<import("godot").EditorTitleBar> & AllowedComponentProps & VNodeProps }
+    EditorToaster: new () => { $props: GodotProps<import("godot").EditorToaster> & AllowedComponentProps & VNodeProps }
+    EditorValidationPanel: new () => { $props: GodotProps<import("godot").EditorValidationPanel> & AllowedComponentProps & VNodeProps }
+    EditorVersionButton: new () => { $props: GodotProps<import("godot").EditorVersionButton> & AllowedComponentProps & VNodeProps }
+    EditorVisualProfiler: new () => { $props: GodotProps<import("godot").EditorVisualProfiler> & AllowedComponentProps & VNodeProps }
+    EditorZoomWidget: new () => { $props: GodotProps<import("godot").EditorZoomWidget> & AllowedComponentProps & VNodeProps }
+    EmbeddedProcess: new () => { $props: GodotProps<import("godot").EmbeddedProcess> & AllowedComponentProps & VNodeProps }
+    EventListenerLineEdit: new () => { $props: GodotProps<import("godot").EventListenerLineEdit> & AllowedComponentProps & VNodeProps }
+    FileSystemDock: new () => { $props: GodotProps<import("godot").FileSystemDock> & AllowedComponentProps & VNodeProps }
+    FileSystemList: new () => { $props: GodotProps<import("godot").FileSystemList> & AllowedComponentProps & VNodeProps }
+    FindInFilesPanel: new () => { $props: GodotProps<import("godot").FindInFilesPanel> & AllowedComponentProps & VNodeProps }
+    FindReplaceBar: new () => { $props: GodotProps<import("godot").FindReplaceBar> & AllowedComponentProps & VNodeProps }
+    FlowContainer: new () => { $props: GodotProps<import("godot").FlowContainer> & AllowedComponentProps & VNodeProps }
+    GameView: new () => { $props: GodotProps<import("godot").GameView> & AllowedComponentProps & VNodeProps }
+    GodotJSDockedPanel: new () => { $props: GodotProps<import("godot").GodotJSDockedPanel> & AllowedComponentProps & VNodeProps }
+    GodotJSStatisticsViewer: new () => { $props: GodotProps<import("godot").GodotJSStatisticsViewer> & AllowedComponentProps & VNodeProps }
+    GraphEdit: new () => { $props: GodotProps<import("godot").GraphEdit> & AllowedComponentProps & VNodeProps }
+    GraphEditFilter: new () => { $props: GodotProps<import("godot").GraphEditFilter> & AllowedComponentProps & VNodeProps }
+    GraphEditMinimap: new () => { $props: GodotProps<import("godot").GraphEditMinimap> & AllowedComponentProps & VNodeProps }
+    GraphElement: new () => { $props: GodotProps<import("godot").GraphElement> & AllowedComponentProps & VNodeProps }
+    GraphFrame: new () => { $props: GodotProps<import("godot").GraphFrame> & AllowedComponentProps & VNodeProps }
+    GraphNode: new () => { $props: GodotProps<import("godot").GraphNode> & AllowedComponentProps & VNodeProps }
+    GridContainer: new () => { $props: GodotProps<import("godot").GridContainer> & AllowedComponentProps & VNodeProps }
+    GridMapEditor: new () => { $props: GodotProps<import("godot").GridMapEditor> & AllowedComponentProps & VNodeProps }
+    GroupSettingsEditor: new () => { $props: GodotProps<import("godot").GroupSettingsEditor> & AllowedComponentProps & VNodeProps }
+    GroupsEditor: new () => { $props: GodotProps<import("godot").GroupsEditor> & AllowedComponentProps & VNodeProps }
+    HBoxContainer: new () => { $props: GodotProps<import("godot").HBoxContainer> & AllowedComponentProps & VNodeProps }
+    HFlowContainer: new () => { $props: GodotProps<import("godot").HFlowContainer> & AllowedComponentProps & VNodeProps }
+    HScrollBar: new () => { $props: GodotProps<import("godot").HScrollBar> & AllowedComponentProps & VNodeProps }
+    HSeparator: new () => { $props: GodotProps<import("godot").HSeparator> & AllowedComponentProps & VNodeProps }
+    HSlider: new () => { $props: GodotProps<import("godot").HSlider> & AllowedComponentProps & VNodeProps }
+    HSplitContainer: new () => { $props: GodotProps<import("godot").HSplitContainer> & AllowedComponentProps & VNodeProps }
+    HistoryDock: new () => { $props: GodotProps<import("godot").HistoryDock> & AllowedComponentProps & VNodeProps }
+    ImportDefaultsEditor: new () => { $props: GodotProps<import("godot").ImportDefaultsEditor> & AllowedComponentProps & VNodeProps }
+    ImportDock: new () => { $props: GodotProps<import("godot").ImportDock> & AllowedComponentProps & VNodeProps }
+    InspectorDock: new () => { $props: GodotProps<import("godot").InspectorDock> & AllowedComponentProps & VNodeProps }
+    ItemList: new () => { $props: GodotProps<import("godot").ItemList> & AllowedComponentProps & VNodeProps }
+    Label: new () => { $props: GodotProps<import("godot").Label> & AllowedComponentProps & VNodeProps }
+    LightOccluder2DEditor: new () => { $props: GodotProps<import("godot").LightOccluder2DEditor> & AllowedComponentProps & VNodeProps }
+    Line2DEditor: new () => { $props: GodotProps<import("godot").Line2DEditor> & AllowedComponentProps & VNodeProps }
+    LineEdit: new () => { $props: GodotProps<import("godot").LineEdit> & AllowedComponentProps & VNodeProps }
+    LinkButton: new () => { $props: GodotProps<import("godot").LinkButton> & AllowedComponentProps & VNodeProps }
+    LocalizationEditor: new () => { $props: GodotProps<import("godot").LocalizationEditor> & AllowedComponentProps & VNodeProps }
+    MarginContainer: new () => { $props: GodotProps<import("godot").MarginContainer> & AllowedComponentProps & VNodeProps }
+    MenuBar: new () => { $props: GodotProps<import("godot").MenuBar> & AllowedComponentProps & VNodeProps }
+    MenuButton: new () => { $props: GodotProps<import("godot").MenuButton> & AllowedComponentProps & VNodeProps }
+    MeshInstance3DEditor: new () => { $props: GodotProps<import("godot").MeshInstance3DEditor> & AllowedComponentProps & VNodeProps }
+    MeshLibraryEditor: new () => { $props: GodotProps<import("godot").MeshLibraryEditor> & AllowedComponentProps & VNodeProps }
+    MultiMeshEditor: new () => { $props: GodotProps<import("godot").MultiMeshEditor> & AllowedComponentProps & VNodeProps }
+    NavigationLink2DEditor: new () => { $props: GodotProps<import("godot").NavigationLink2DEditor> & AllowedComponentProps & VNodeProps }
+    NavigationMeshEditor: new () => { $props: GodotProps<import("godot").NavigationMeshEditor> & AllowedComponentProps & VNodeProps }
+    NavigationObstacle2DEditor: new () => { $props: GodotProps<import("godot").NavigationObstacle2DEditor> & AllowedComponentProps & VNodeProps }
+    NavigationPolygonEditor: new () => { $props: GodotProps<import("godot").NavigationPolygonEditor> & AllowedComponentProps & VNodeProps }
+    NinePatchRect: new () => { $props: GodotProps<import("godot").NinePatchRect> & AllowedComponentProps & VNodeProps }
+    Node3DEditor: new () => { $props: GodotProps<import("godot").Node3DEditor> & AllowedComponentProps & VNodeProps }
+    Node3DEditorViewport: new () => { $props: GodotProps<import("godot").Node3DEditorViewport> & AllowedComponentProps & VNodeProps }
+    Node3DEditorViewportContainer: new () => { $props: GodotProps<import("godot").Node3DEditorViewportContainer> & AllowedComponentProps & VNodeProps }
+    NodeDock: new () => { $props: GodotProps<import("godot").NodeDock> & AllowedComponentProps & VNodeProps }
+    OpenXRBindingModifierEditor: new () => { $props: GodotProps<import("godot").OpenXRBindingModifierEditor> & AllowedComponentProps & VNodeProps }
+    OpenXRInteractionProfileEditor: new () => { $props: GodotProps<import("godot").OpenXRInteractionProfileEditor> & AllowedComponentProps & VNodeProps }
+    OpenXRInteractionProfileEditorBase: new () => { $props: GodotProps<import("godot").OpenXRInteractionProfileEditorBase> & AllowedComponentProps & VNodeProps }
+    OptionButton: new () => { $props: GodotProps<import("godot").OptionButton> & AllowedComponentProps & VNodeProps }
+    Panel: new () => { $props: GodotProps<import("godot").Panel> & AllowedComponentProps & VNodeProps }
+    PanelContainer: new () => { $props: GodotProps<import("godot").PanelContainer> & AllowedComponentProps & VNodeProps }
+    Path2DEditor: new () => { $props: GodotProps<import("godot").Path2DEditor> & AllowedComponentProps & VNodeProps }
+    Polygon2DEditor: new () => { $props: GodotProps<import("godot").Polygon2DEditor> & AllowedComponentProps & VNodeProps }
+    Polygon3DEditor: new () => { $props: GodotProps<import("godot").Polygon3DEditor> & AllowedComponentProps & VNodeProps }
+    ProgressBar: new () => { $props: GodotProps<import("godot").ProgressBar> & AllowedComponentProps & VNodeProps }
+    ProgressDialog: new () => { $props: GodotProps<import("godot").ProgressDialog> & AllowedComponentProps & VNodeProps }
+    ProjectExportTextureFormatError: new () => { $props: GodotProps<import("godot").ProjectExportTextureFormatError> & AllowedComponentProps & VNodeProps }
+    QuickOpenResultContainer: new () => { $props: GodotProps<import("godot").QuickOpenResultContainer> & AllowedComponentProps & VNodeProps }
+    Range: new () => { $props: GodotProps<import("godot").Range> & AllowedComponentProps & VNodeProps }
+    ReferenceRect: new () => { $props: GodotProps<import("godot").ReferenceRect> & AllowedComponentProps & VNodeProps }
+    ReplicationEditor: new () => { $props: GodotProps<import("godot").ReplicationEditor> & AllowedComponentProps & VNodeProps }
+    ResourcePreloaderEditor: new () => { $props: GodotProps<import("godot").ResourcePreloaderEditor> & AllowedComponentProps & VNodeProps }
+    RichTextLabel: new () => { $props: GodotProps<import("godot").RichTextLabel> & AllowedComponentProps & VNodeProps }
+    SceneTreeDock: new () => { $props: GodotProps<import("godot").SceneTreeDock> & AllowedComponentProps & VNodeProps }
+    SceneTreeEditor: new () => { $props: GodotProps<import("godot").SceneTreeEditor> & AllowedComponentProps & VNodeProps }
+    ScreenSelect: new () => { $props: GodotProps<import("godot").ScreenSelect> & AllowedComponentProps & VNodeProps }
+    ScriptEditor: new () => { $props: GodotProps<import("godot").ScriptEditor> & AllowedComponentProps & VNodeProps }
+    ScriptEditorBase: new () => { $props: GodotProps<import("godot").ScriptEditorBase> & AllowedComponentProps & VNodeProps }
+    ScrollBar: new () => { $props: GodotProps<import("godot").ScrollBar> & AllowedComponentProps & VNodeProps }
+    ScrollContainer: new () => { $props: GodotProps<import("godot").ScrollContainer> & AllowedComponentProps & VNodeProps }
+    SectionedInspector: new () => { $props: GodotProps<import("godot").SectionedInspector> & AllowedComponentProps & VNodeProps }
+    Separator: new () => { $props: GodotProps<import("godot").Separator> & AllowedComponentProps & VNodeProps }
+    ShaderFileEditor: new () => { $props: GodotProps<import("godot").ShaderFileEditor> & AllowedComponentProps & VNodeProps }
+    ShaderGlobalsEditor: new () => { $props: GodotProps<import("godot").ShaderGlobalsEditor> & AllowedComponentProps & VNodeProps }
+    SizeFlagPresetPicker: new () => { $props: GodotProps<import("godot").SizeFlagPresetPicker> & AllowedComponentProps & VNodeProps }
+    Skeleton2DEditor: new () => { $props: GodotProps<import("godot").Skeleton2DEditor> & AllowedComponentProps & VNodeProps }
+    Slider: new () => { $props: GodotProps<import("godot").Slider> & AllowedComponentProps & VNodeProps }
+    SpinBox: new () => { $props: GodotProps<import("godot").SpinBox> & AllowedComponentProps & VNodeProps }
+    SplitContainer: new () => { $props: GodotProps<import("godot").SplitContainer> & AllowedComponentProps & VNodeProps }
+    SplitContainerDragger: new () => { $props: GodotProps<import("godot").SplitContainerDragger> & AllowedComponentProps & VNodeProps }
+    Sprite2DEditor: new () => { $props: GodotProps<import("godot").Sprite2DEditor> & AllowedComponentProps & VNodeProps }
+    SpriteFramesEditor: new () => { $props: GodotProps<import("godot").SpriteFramesEditor> & AllowedComponentProps & VNodeProps }
+    SubViewportContainer: new () => { $props: GodotProps<import("godot").SubViewportContainer> & AllowedComponentProps & VNodeProps }
+    TabBar: new () => { $props: GodotProps<import("godot").TabBar> & AllowedComponentProps & VNodeProps }
+    TabContainer: new () => { $props: GodotProps<import("godot").TabContainer> & AllowedComponentProps & VNodeProps }
+    TextEdit: new () => { $props: GodotProps<import("godot").TextEdit> & AllowedComponentProps & VNodeProps }
+    TextureButton: new () => { $props: GodotProps<import("godot").TextureButton> & AllowedComponentProps & VNodeProps }
+    TextureProgressBar: new () => { $props: GodotProps<import("godot").TextureProgressBar> & AllowedComponentProps & VNodeProps }
+    TextureRect: new () => { $props: GodotProps<import("godot").TextureRect> & AllowedComponentProps & VNodeProps }
+    ThemeEditor: new () => { $props: GodotProps<import("godot").ThemeEditor> & AllowedComponentProps & VNodeProps }
+    ThemeEditorPreview: new () => { $props: GodotProps<import("godot").ThemeEditorPreview> & AllowedComponentProps & VNodeProps }
+    ThemeItemImportTree: new () => { $props: GodotProps<import("godot").ThemeItemImportTree> & AllowedComponentProps & VNodeProps }
+    ThemeTypeEditor: new () => { $props: GodotProps<import("godot").ThemeTypeEditor> & AllowedComponentProps & VNodeProps }
+    TileAtlasView: new () => { $props: GodotProps<import("godot").TileAtlasView> & AllowedComponentProps & VNodeProps }
+    TileMapLayerEditor: new () => { $props: GodotProps<import("godot").TileMapLayerEditor> & AllowedComponentProps & VNodeProps }
+    TileSetAtlasSourceEditor: new () => { $props: GodotProps<import("godot").TileSetAtlasSourceEditor> & AllowedComponentProps & VNodeProps }
+    TileSetEditor: new () => { $props: GodotProps<import("godot").TileSetEditor> & AllowedComponentProps & VNodeProps }
+    TileSetScenesCollectionSourceEditor: new () => { $props: GodotProps<import("godot").TileSetScenesCollectionSourceEditor> & AllowedComponentProps & VNodeProps }
+    Tree: new () => { $props: GodotProps<import("godot").Tree> & AllowedComponentProps & VNodeProps }
+    VBoxContainer: new () => { $props: GodotProps<import("godot").VBoxContainer> & AllowedComponentProps & VNodeProps }
+    VFlowContainer: new () => { $props: GodotProps<import("godot").VFlowContainer> & AllowedComponentProps & VNodeProps }
+    VScrollBar: new () => { $props: GodotProps<import("godot").VScrollBar> & AllowedComponentProps & VNodeProps }
+    VSeparator: new () => { $props: GodotProps<import("godot").VSeparator> & AllowedComponentProps & VNodeProps }
+    VSlider: new () => { $props: GodotProps<import("godot").VSlider> & AllowedComponentProps & VNodeProps }
+    VSplitContainer: new () => { $props: GodotProps<import("godot").VSplitContainer> & AllowedComponentProps & VNodeProps }
+    VideoStreamPlayer: new () => { $props: GodotProps<import("godot").VideoStreamPlayer> & AllowedComponentProps & VNodeProps }
+    ViewportNavigationControl: new () => { $props: GodotProps<import("godot").ViewportNavigationControl> & AllowedComponentProps & VNodeProps }
+    ViewportRotationControl: new () => { $props: GodotProps<import("godot").ViewportRotationControl> & AllowedComponentProps & VNodeProps }
+    WindowWrapper: new () => { $props: GodotProps<import("godot").WindowWrapper> & AllowedComponentProps & VNodeProps }
+  }
+}

package/templates/typings/godot.worker.d.ts

@@ -0,0 +1,32 @@
+
+declare module "godot.worker" {
+    import { Object as GDObject } from "godot";
+
+    class JSWorker {
+        constructor(path: string);
+
+        postMessage(message: any): void;
+        terminate(): void;
+
+        onready?: () => void;
+        onmessage?: (message: any) => void;
+
+        //TODO not implemented yet
+        onerror?: (error: any) => void;
+
+        ontransfer?: (obj: GDObject) => void;
+    }
+
+    // only available in worker scripts
+    const JSWorkerParent: {
+        onmessage?: (message: any) => void,
+        
+        close(): void,
+
+        transfer(obj: GDObject): void,
+
+        postMessage(message: any): void,
+
+    } | undefined;
+
+}