typescript-to-gdscript 0.1.0

package/typings/classes/VisualShaderNodeCompare.d.ts

@@ -0,0 +1,68 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A comparison function for common types within the visual shader graph. */
+declare class VisualShaderNodeCompare extends VisualShaderNode {
+  /** Extra condition which is applied if {@link type} is set to {@link CTYPE_VECTOR_3D}. */
+  condition: int;
+  /** A comparison function. */
+  function: int;
+  /** The type to be used in the comparison. */
+  type: int;
+  set_condition(value: int): void;
+  get_condition(): int;
+  set_function(value: int): void;
+  get_function(): int;
+  set_comparison_type(value: int): void;
+  get_comparison_type(): int;
+
+  // enum ComparisonType
+  /** A floating-point scalar. */
+  static readonly CTYPE_SCALAR: int;
+  /** An integer scalar. */
+  static readonly CTYPE_SCALAR_INT: int;
+  /** An unsigned integer scalar. */
+  static readonly CTYPE_SCALAR_UINT: int;
+  /** A 2D vector type. */
+  static readonly CTYPE_VECTOR_2D: int;
+  /** A 3D vector type. */
+  static readonly CTYPE_VECTOR_3D: int;
+  /** A 4D vector type. */
+  static readonly CTYPE_VECTOR_4D: int;
+  /** A boolean type. */
+  static readonly CTYPE_BOOLEAN: int;
+  /** A transform (`mat4`) type. */
+  static readonly CTYPE_TRANSFORM: int;
+  /** Represents the size of the {@link ComparisonType} enum. */
+  static readonly CTYPE_MAX: int;
+  // enum Function
+  /** Comparison for equality (`a == b`). */
+  static readonly FUNC_EQUAL: int;
+  /** Comparison for inequality (`a != b`). */
+  static readonly FUNC_NOT_EQUAL: int;
+  /**
+   * Comparison for greater than (`a > b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+   */
+  static readonly FUNC_GREATER_THAN: int;
+  /**
+   * Comparison for greater than or equal (`a >= b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+   */
+  static readonly FUNC_GREATER_THAN_EQUAL: int;
+  /**
+   * Comparison for less than (`a < b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+   */
+  static readonly FUNC_LESS_THAN: int;
+  /**
+   * Comparison for less than or equal (`a <= b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+   */
+  static readonly FUNC_LESS_THAN_EQUAL: int;
+  /** Represents the size of the {@link Function} enum. */
+  static readonly FUNC_MAX: int;
+  // enum Condition
+  /** The result will be `true` if all components in the vector satisfy the comparison condition. */
+  static readonly COND_ALL: int;
+  /** The result will be `true` if any component in the vector satisfies the comparison condition. */
+  static readonly COND_ANY: int;
+  /** Represents the size of the {@link Condition} enum. */
+  static readonly COND_MAX: int;
+}

package/typings/classes/VisualShaderNodeConstant.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A base type for the constants within the visual shader graph. */
+declare class VisualShaderNodeConstant extends VisualShaderNode {
+}

package/typings/classes/VisualShaderNodeCubemap.d.ts

@@ -0,0 +1,43 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Cubemap} sampling node to be used within the visual shader graph. */
+declare class VisualShaderNodeCubemap extends VisualShaderNode {
+  /** The {@link Cubemap} texture to sample when using {@link SOURCE_TEXTURE} as {@link source}. */
+  cube_map: TextureLayered | null;
+  /** Defines which source should be used for the sampling. */
+  source: int;
+  /** Defines the type of data provided by the source texture. */
+  texture_type: int;
+  set_cube_map(value: TextureLayered | null): void;
+  get_cube_map(): TextureLayered | null;
+  set_source(value: int): void;
+  get_source(): int;
+  set_texture_type(value: int): void;
+  get_texture_type(): int;
+
+  // enum Source
+  /**
+   * Use the {@link Cubemap} set via {@link cube_map}. If this is set to {@link source}, the `samplerCube` port is ignored.
+   */
+  static readonly SOURCE_TEXTURE: int;
+  /**
+   * Use the {@link Cubemap} sampler reference passed via the `samplerCube` port. If this is set to {@link source}, the {@link cube_map} texture is ignored.
+   */
+  static readonly SOURCE_PORT: int;
+  /** Represents the size of the {@link Source} enum. */
+  static readonly SOURCE_MAX: int;
+  // enum TextureType
+  /** No hints are added to the uniform declaration. */
+  static readonly TYPE_DATA: int;
+  /**
+   * Adds `source_color` as hint to the uniform declaration for proper conversion from nonlinear sRGB encoding to linear encoding.
+   */
+  static readonly TYPE_COLOR: int;
+  /**
+   * Adds `hint_normal` as hint to the uniform declaration, which internally converts the texture for proper usage as normal map.
+   */
+  static readonly TYPE_NORMAL_MAP: int;
+  /** Represents the size of the {@link TextureType} enum. */
+  static readonly TYPE_MAX: int;
+}

package/typings/classes/VisualShaderNodeCubemapParameter.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Cubemap} parameter node to be used within the visual shader graph. */
+declare class VisualShaderNodeCubemapParameter extends VisualShaderNodeTextureParameter {
+}

package/typings/classes/VisualShaderNodeCurveTexture.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Performs a {@link CurveTexture} lookup within the visual shader graph. */
+declare class VisualShaderNodeCurveTexture extends VisualShaderNodeResizableBase {
+  /** The source texture. */
+  texture: CurveTexture | null;
+  set_texture(value: CurveTexture | null): void;
+  get_texture(): CurveTexture | null;
+}

package/typings/classes/VisualShaderNodeCurveXYZTexture.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Performs a {@link CurveXYZTexture} lookup within the visual shader graph. */
+declare class VisualShaderNodeCurveXYZTexture extends VisualShaderNodeResizableBase {
+  /** The source texture. */
+  texture: CurveXYZTexture | null;
+  set_texture(value: CurveXYZTexture | null): void;
+  get_texture(): CurveXYZTexture | null;
+}

package/typings/classes/VisualShaderNodeCustom.d.ts

@@ -0,0 +1,122 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Virtual class to define custom {@link VisualShaderNode}s for use in the Visual Shader Editor. */
+declare class VisualShaderNodeCustom extends VisualShaderNode {
+  /**
+   * Override this method to define the path to the associated custom node in the Visual Shader Editor's members dialog. The path may look like `"MyGame/MyFunctions/Noise"`.
+   * Defining this method is **optional**. If not overridden, the node will be filed under the "Addons" category.
+   */
+  _get_category(): string;
+  /**
+   * Override this method to define the actual shader code of the associated custom node. The shader code should be returned as a string, which can have multiple lines (the `"""` multiline string construct can be used for convenience).
+   * The `input_vars` and `output_vars` arrays contain the string names of the various input and output variables, as defined by `_get_input_*` and `_get_output_*` virtual methods in this class.
+   * The output ports can be assigned values in the shader code. For example, `return output_vars[0] + " = " + input_vars[0] + ";"`.
+   * You can customize the generated code based on the shader `mode` and/or `type`.
+   * Defining this method is **required**.
+   */
+  _get_code(input_vars: Array<string>, output_vars: Array<string>, mode: int, type_: int): string;
+  /**
+   * Override this method to define the input port which should be connected by default when this node is created as a result of dragging a connection from an existing node to the empty space on the graph.
+   * Defining this method is **optional**. If not overridden, the connection will be created to the first valid port.
+   */
+  _get_default_input_port(type_: int): int;
+  /**
+   * Override this method to define the description of the associated custom node in the Visual Shader Editor's members dialog.
+   * Defining this method is **optional**.
+   */
+  _get_description(): string;
+  /**
+   * Override this method to add a shader code to the beginning of each shader function (once). The shader code should be returned as a string, which can have multiple lines (the `"""` multiline string construct can be used for convenience).
+   * If there are multiple custom nodes of different types which use this feature the order of each insertion is undefined.
+   * You can customize the generated code based on the shader `mode` and/or `type`.
+   * Defining this method is **optional**.
+   */
+  _get_func_code(mode: int, type_: int): string;
+  /**
+   * Override this method to add shader code on top of the global shader, to define your own standard library of reusable methods, varyings, constants, uniforms, etc. The shader code should be returned as a string, which can have multiple lines (the `"""` multiline string construct can be used for convenience).
+   * Be careful with this functionality as it can cause name conflicts with other custom nodes, so be sure to give the defined entities unique names.
+   * You can customize the generated code based on the shader `mode`.
+   * Defining this method is **optional**.
+   */
+  _get_global_code(mode: int): string;
+  /**
+   * Override this method to define the number of input ports of the associated custom node.
+   * Defining this method is **required**. If not overridden, the node has no input ports.
+   */
+  _get_input_port_count(): int;
+  /**
+   * Override this method to define the default value for the specified input port. Prefer use this over {@link VisualShaderNode.set_input_port_default_value}.
+   * Defining this method is **required**. If not overridden, the node has no default values for their input ports.
+   */
+  _get_input_port_default_value(port: int): unknown;
+  /**
+   * Override this method to define the names of input ports of the associated custom node. The names are used both for the input slots in the editor and as identifiers in the shader code, and are passed in the `input_vars` array in {@link _get_code}.
+   * Defining this method is **optional**, but recommended. If not overridden, input ports are named as `"in" + str(port)`.
+   */
+  _get_input_port_name(port: int): string;
+  /**
+   * Override this method to define the returned type of each input port of the associated custom node.
+   * Defining this method is **optional**, but recommended. If not overridden, input ports will return the {@link VisualShaderNode.PORT_TYPE_SCALAR} type.
+   */
+  _get_input_port_type(port: int): int;
+  /**
+   * Override this method to define the name of the associated custom node in the Visual Shader Editor's members dialog and graph.
+   * Defining this method is **optional**, but recommended. If not overridden, the node will be named as "Unnamed".
+   */
+  _get_name(): string;
+  /**
+   * Override this method to define the number of output ports of the associated custom node.
+   * Defining this method is **required**. If not overridden, the node has no output ports.
+   */
+  _get_output_port_count(): int;
+  /**
+   * Override this method to define the names of output ports of the associated custom node. The names are used both for the output slots in the editor and as identifiers in the shader code, and are passed in the `output_vars` array in {@link _get_code}.
+   * Defining this method is **optional**, but recommended. If not overridden, output ports are named as `"out" + str(port)`.
+   */
+  _get_output_port_name(port: int): string;
+  /**
+   * Override this method to define the returned type of each output port of the associated custom node.
+   * Defining this method is **optional**, but recommended. If not overridden, output ports will return the {@link VisualShaderNode.PORT_TYPE_SCALAR} type.
+   */
+  _get_output_port_type(port: int): int;
+  /**
+   * Override this method to define the number of the properties.
+   * Defining this method is **optional**.
+   */
+  _get_property_count(): int;
+  /**
+   * Override this method to define the default index of the property of the associated custom node.
+   * Defining this method is **optional**.
+   */
+  _get_property_default_index(index: int): int;
+  /**
+   * Override this method to define the names of the property of the associated custom node.
+   * Defining this method is **optional**.
+   */
+  _get_property_name(index: int): string;
+  /**
+   * Override this method to define the options inside the drop-down list property of the associated custom node.
+   * Defining this method is **optional**.
+   */
+  _get_property_options(index: int): PackedStringArray;
+  /**
+   * Override this method to define the return icon of the associated custom node in the Visual Shader Editor's members dialog.
+   * Defining this method is **optional**. If not overridden, no return icon is shown.
+   */
+  _get_return_icon_type(): int;
+  /**
+   * Override this method to prevent the node to be visible in the member dialog for the certain `mode` and/or `type`.
+   * Defining this method is **optional**. If not overridden, it's `true`.
+   */
+  _is_available(mode: int, type_: int): boolean;
+  /**
+   * Override this method to enable the high-end mark in the Visual Shader Editor's members dialog. This should return `true` for nodes that only work when using the Forward+ and Mobile renderers.
+   * Defining this method is **optional**. If not overridden, it's `false`, which indicates this node works with all renderers (including Compatibility).
+   */
+  _is_highend(): boolean;
+  /**
+   * Returns the selected index of the drop-down list option within a graph. You may use this function to define the specific behavior in the {@link _get_code} or {@link _get_global_code}.
+   */
+  get_option_index(option: int): int;
+}

package/typings/classes/VisualShaderNodeDerivativeFunc.d.ts

@@ -0,0 +1,56 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Calculates a derivative within the visual shader graph. */
+declare class VisualShaderNodeDerivativeFunc extends VisualShaderNode {
+  /** A derivative function type. */
+  function: int;
+  /** A type of operands and returned value. */
+  op_type: int;
+  /**
+   * Sets the level of precision to use for the derivative function. When using the Compatibility renderer, this setting has no effect.
+   */
+  precision: int;
+  set_function(value: int): void;
+  get_function(): int;
+  set_op_type(value: int): void;
+  get_op_type(): int;
+  set_precision(value: int): void;
+  get_precision(): int;
+
+  // enum OpType
+  /** A floating-point scalar. */
+  static readonly OP_TYPE_SCALAR: int;
+  /** A 2D vector type. */
+  static readonly OP_TYPE_VECTOR_2D: int;
+  /** A 3D vector type. */
+  static readonly OP_TYPE_VECTOR_3D: int;
+  /** A 4D vector type. */
+  static readonly OP_TYPE_VECTOR_4D: int;
+  /** Represents the size of the {@link OpType} enum. */
+  static readonly OP_TYPE_MAX: int;
+  // enum Function
+  /** Sum of absolute derivative in `x` and `y`. */
+  static readonly FUNC_SUM: int;
+  /** Derivative in `x` using local differencing. */
+  static readonly FUNC_X: int;
+  /** Derivative in `y` using local differencing. */
+  static readonly FUNC_Y: int;
+  /** Represents the size of the {@link Function} enum. */
+  static readonly FUNC_MAX: int;
+  // enum Precision
+  /**
+   * No precision is specified, the GPU driver is allowed to use whatever level of precision it chooses. This is the default option and is equivalent to using `dFdx()` or `dFdy()` in text shaders.
+   */
+  static readonly PRECISION_NONE: int;
+  /**
+   * The derivative will be calculated using the current fragment's neighbors (which may not include the current fragment). This tends to be faster than using {@link PRECISION_FINE}, but may not be suitable when more precision is needed. This is equivalent to using `dFdxCoarse()` or `dFdyCoarse()` in text shaders.
+   */
+  static readonly PRECISION_COARSE: int;
+  /**
+   * The derivative will be calculated using the current fragment and its immediate neighbors. This tends to be slower than using {@link PRECISION_COARSE}, but may be necessary when more precision is needed. This is equivalent to using `dFdxFine()` or `dFdyFine()` in text shaders.
+   */
+  static readonly PRECISION_FINE: int;
+  /** Represents the size of the {@link Precision} enum. */
+  static readonly PRECISION_MAX: int;
+}

package/typings/classes/VisualShaderNodeDeterminant.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Calculates the determinant of a {@link Transform3D} within the visual shader graph. */
+declare class VisualShaderNodeDeterminant extends VisualShaderNode {
+}

package/typings/classes/VisualShaderNodeDistanceFade.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A visual shader node representing distance fade effect. */
+declare class VisualShaderNodeDistanceFade extends VisualShaderNode {
+}

package/typings/classes/VisualShaderNodeDotProduct.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Calculates a dot product of two vectors within the visual shader graph. */
+declare class VisualShaderNodeDotProduct extends VisualShaderNode {
+}

package/typings/classes/VisualShaderNodeExpression.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A custom visual shader graph expression written in Godot Shading Language. */
+declare class VisualShaderNodeExpression extends VisualShaderNodeGroupBase {
+  /**
+   * An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (`vertex`, `fragment`, or `light`), and thus cannot be used to declare functions, varyings, uniforms, or global constants.
+   */
+  expression: string;
+  set_expression(value: string | NodePath): void;
+  get_expression(): string;
+}

package/typings/classes/VisualShaderNodeFaceForward.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Returns the vector that points in the same direction as a reference vector within the visual shader graph.
+ */
+declare class VisualShaderNodeFaceForward extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeFloatConstant.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A scalar floating-point constant to be used within the visual shader graph. */
+declare class VisualShaderNodeFloatConstant extends VisualShaderNodeConstant {
+  /** A floating-point constant which represents a state of this node. */
+  constant: float;
+  set_constant(value: float): void;
+  get_constant(): float;
+}

package/typings/classes/VisualShaderNodeFloatFunc.d.ts

@@ -0,0 +1,108 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A scalar floating-point function to be used within the visual shader graph. */
+declare class VisualShaderNodeFloatFunc extends VisualShaderNode {
+  /** A function to be applied to the scalar. */
+  function: int;
+  set_function(value: int): void;
+  get_function(): int;
+
+  // enum Function
+  /** Returns the sine of the parameter. Translates to `sin(x)` in the Godot Shader Language. */
+  static readonly FUNC_SIN: int;
+  /** Returns the cosine of the parameter. Translates to `cos(x)` in the Godot Shader Language. */
+  static readonly FUNC_COS: int;
+  /** Returns the tangent of the parameter. Translates to `tan(x)` in the Godot Shader Language. */
+  static readonly FUNC_TAN: int;
+  /** Returns the arc-sine of the parameter. Translates to `asin(x)` in the Godot Shader Language. */
+  static readonly FUNC_ASIN: int;
+  /** Returns the arc-cosine of the parameter. Translates to `acos(x)` in the Godot Shader Language. */
+  static readonly FUNC_ACOS: int;
+  /** Returns the arc-tangent of the parameter. Translates to `atan(x)` in the Godot Shader Language. */
+  static readonly FUNC_ATAN: int;
+  /** Returns the hyperbolic sine of the parameter. Translates to `sinh(x)` in the Godot Shader Language. */
+  static readonly FUNC_SINH: int;
+  /**
+   * Returns the hyperbolic cosine of the parameter. Translates to `cosh(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_COSH: int;
+  /**
+   * Returns the hyperbolic tangent of the parameter. Translates to `tanh(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_TANH: int;
+  /**
+   * Returns the natural logarithm of the parameter. Translates to `log(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_LOG: int;
+  /**
+   * Returns the natural exponentiation of the parameter. Translates to `exp(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_EXP: int;
+  /** Returns the square root of the parameter. Translates to `sqrt(x)` in the Godot Shader Language. */
+  static readonly FUNC_SQRT: int;
+  /** Returns the absolute value of the parameter. Translates to `abs(x)` in the Godot Shader Language. */
+  static readonly FUNC_ABS: int;
+  /** Extracts the sign of the parameter. Translates to `sign(x)` in the Godot Shader Language. */
+  static readonly FUNC_SIGN: int;
+  /**
+   * Finds the nearest integer less than or equal to the parameter. Translates to `floor(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_FLOOR: int;
+  /** Finds the nearest integer to the parameter. Translates to `round(x)` in the Godot Shader Language. */
+  static readonly FUNC_ROUND: int;
+  /**
+   * Finds the nearest integer that is greater than or equal to the parameter. Translates to `ceil(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_CEIL: int;
+  /**
+   * Computes the fractional part of the argument. Translates to `fract(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_FRACT: int;
+  /** Clamps the value between `0.0` and `1.0` using `min(max(x, 0.0), 1.0)`. */
+  static readonly FUNC_SATURATE: int;
+  /** Negates the `x` using `-(x)`. */
+  static readonly FUNC_NEGATE: int;
+  /**
+   * Returns the arc-hyperbolic-cosine of the parameter. Translates to `acosh(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_ACOSH: int;
+  /**
+   * Returns the arc-hyperbolic-sine of the parameter. Translates to `asinh(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_ASINH: int;
+  /**
+   * Returns the arc-hyperbolic-tangent of the parameter. Translates to `atanh(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_ATANH: int;
+  /** Convert a quantity in radians to degrees. Translates to `degrees(x)` in the Godot Shader Language. */
+  static readonly FUNC_DEGREES: int;
+  /**
+   * Returns 2 raised by the power of the parameter. Translates to `exp2(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_EXP2: int;
+  /**
+   * Returns the inverse of the square root of the parameter. Translates to `inversesqrt(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_INVERSE_SQRT: int;
+  /**
+   * Returns the base 2 logarithm of the parameter. Translates to `log2(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_LOG2: int;
+  /** Convert a quantity in degrees to radians. Translates to `radians(x)` in the Godot Shader Language. */
+  static readonly FUNC_RADIANS: int;
+  /** Finds reciprocal value of dividing 1 by `x` (i.e. `1 / x`). */
+  static readonly FUNC_RECIPROCAL: int;
+  /**
+   * Finds the nearest even integer to the parameter. Translates to `roundEven(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_ROUNDEVEN: int;
+  /**
+   * Returns a value equal to the nearest integer to `x` whose absolute value is not larger than the absolute value of `x`. Translates to `trunc(x)` in the Godot Shader Language.
+   */
+  static readonly FUNC_TRUNC: int;
+  /** Subtracts scalar `x` from 1 (i.e. `1 - x`). */
+  static readonly FUNC_ONEMINUS: int;
+  /** Represents the size of the {@link Function} enum. */
+  static readonly FUNC_MAX: int;
+}

package/typings/classes/VisualShaderNodeFloatOp.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A floating-point scalar operator to be used within the visual shader graph. */
+declare class VisualShaderNodeFloatOp extends VisualShaderNode {
+  /** An operator to be applied to the inputs. */
+  operator: int;
+  set_operator(value: int): void;
+  get_operator(): int;
+
+  // enum Operator
+  /** Sums two numbers using `a + b`. */
+  static readonly OP_ADD: int;
+  /** Subtracts two numbers using `a - b`. */
+  static readonly OP_SUB: int;
+  /** Multiplies two numbers using `a * b`. */
+  static readonly OP_MUL: int;
+  /** Divides two numbers using `a / b`. */
+  static readonly OP_DIV: int;
+  /** Calculates the remainder of two numbers. Translates to `mod(a, b)` in the Godot Shader Language. */
+  static readonly OP_MOD: int;
+  /** Raises the `a` to the power of `b`. Translates to `pow(a, b)` in the Godot Shader Language. */
+  static readonly OP_POW: int;
+  /** Returns the greater of two numbers. Translates to `max(a, b)` in the Godot Shader Language. */
+  static readonly OP_MAX: int;
+  /** Returns the lesser of two numbers. Translates to `min(a, b)` in the Godot Shader Language. */
+  static readonly OP_MIN: int;
+  /** Returns the arc-tangent of the parameters. Translates to `atan(a, b)` in the Godot Shader Language. */
+  static readonly OP_ATAN2: int;
+  /**
+   * Generates a step function by comparing `b`(x) to `a`(edge). Returns 0.0 if `x` is smaller than `edge` and otherwise 1.0. Translates to `step(a, b)` in the Godot Shader Language.
+   */
+  static readonly OP_STEP: int;
+  /** Represents the size of the {@link Operator} enum. */
+  static readonly OP_ENUM_SIZE: int;
+}

package/typings/classes/VisualShaderNodeFloatParameter.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A scalar float parameter to be used within the visual shader graph. */
+declare class VisualShaderNodeFloatParameter extends VisualShaderNodeParameter {
+  /** A default value to be assigned within the shader. */
+  default_value: float;
+  /** Enables usage of the {@link default_value}. */
+  default_value_enabled: boolean;
+  /**
+   * A hint applied to the uniform, which controls the values it can take when set through the Inspector.
+   */
+  hint: int;
+  /**
+   * Minimum value for range hints. Used if {@link hint} is set to {@link HINT_RANGE} or {@link HINT_RANGE_STEP}.
+   */
+  max: float;
+  /**
+   * Maximum value for range hints. Used if {@link hint} is set to {@link HINT_RANGE} or {@link HINT_RANGE_STEP}.
+   */
+  min: float;
+  /**
+   * Step (increment) value for the range hint with step. Used if {@link hint} is set to {@link HINT_RANGE_STEP}.
+   */
+  step: float;
+  set_default_value(value: float): void;
+  get_default_value(): float;
+  set_default_value_enabled(value: boolean): void;
+  is_default_value_enabled(): boolean;
+  set_hint(value: int): void;
+  get_hint(): int;
+  set_max(value: float): void;
+  get_max(): float;
+  set_min(value: float): void;
+  get_min(): float;
+  set_step(value: float): void;
+  get_step(): float;
+
+  // enum Hint
+  /** No hint used. */
+  static readonly HINT_NONE: int;
+  /**
+   * A range hint for scalar value, which limits possible input values between {@link min} and {@link max}. Translated to `hint_range(min, max)` in shader code.
+   */
+  static readonly HINT_RANGE: int;
+  /**
+   * A range hint for scalar value with step, which limits possible input values between {@link min} and {@link max}, with a step (increment) of {@link step}). Translated to `hint_range(min, max, step)` in shader code.
+   */
+  static readonly HINT_RANGE_STEP: int;
+  /** Represents the size of the {@link Hint} enum. */
+  static readonly HINT_MAX: int;
+}

package/typings/classes/VisualShaderNodeFrame.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A frame other visual shader nodes can be attached to for better organization. */
+declare class VisualShaderNodeFrame extends VisualShaderNodeResizableBase {
+  /** The list of nodes attached to the frame. */
+  attached_nodes: PackedInt32Array;
+  /** If `true`, the frame will automatically resize to enclose all attached nodes. */
+  autoshrink: boolean;
+  /** The color of the frame when {@link tint_color_enabled} is `true`. */
+  tint_color: Color;
+  /** If `true`, the frame will be tinted with the color specified in {@link tint_color}. */
+  tint_color_enabled: boolean;
+  /** The title of the node. */
+  title: string;
+  set_attached_nodes(value: PackedInt32Array | Array<unknown>): void;
+  get_attached_nodes(): PackedInt32Array;
+  set_autoshrink_enabled(value: boolean): void;
+  is_autoshrink_enabled(): boolean;
+  set_tint_color(value: Color): void;
+  get_tint_color(): Color;
+  set_tint_color_enabled(value: boolean): void;
+  is_tint_color_enabled(): boolean;
+  set_title(value: string | NodePath): void;
+  get_title(): string;
+
+  /**
+   * Adds a node to the list of nodes attached to the frame. Should not be called directly, use the {@link VisualShader.attach_node_to_frame} method instead.
+   */
+  add_attached_node(node: int): void;
+  /**
+   * Removes a node from the list of nodes attached to the frame. Should not be called directly, use the {@link VisualShader.detach_node_from_frame} method instead.
+   */
+  remove_attached_node(node: int): void;
+}

package/typings/classes/VisualShaderNodeFresnel.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A Fresnel effect to be used within the visual shader graph. */
+declare class VisualShaderNodeFresnel extends VisualShaderNode {
+}

package/typings/classes/VisualShaderNodeGlobalExpression.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A custom global visual shader graph expression written in Godot Shading Language. */
+declare class VisualShaderNodeGlobalExpression extends VisualShaderNodeExpression {
+}