typescript-to-gdscript 0.1.0

package/typings/classes/Transform3D.d.ts

@@ -0,0 +1,173 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3×4 matrix representing a 3D transformation. */
+declare interface Transform3D {
+  /**
+   * The {@link Basis} of this transform. It is composed by 3 axes ({@link Basis.x}, {@link Basis.y}, and {@link Basis.z}). Together, these represent the transform's rotation, scale, and shear.
+   */
+  basis: Basis;
+  /** The translation offset of this transform. In 3D space, this can be seen as the position. */
+  origin: Vector3;
+
+  /**
+   * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any {@link basis}, including non-uniform ones, but is slower. See also {@link Basis.inverse}.
+   * **Note:** For this method to return correctly, the transform's {@link basis} needs to have a determinant that is not exactly `0.0` (see {@link Basis.determinant}).
+   */
+  affine_inverse(): Transform3D;
+  /**
+   * Returns the result of the linear interpolation between this transform and `xform` by the given `weight`.
+   * The `weight` should be between `0.0` and `1.0` (inclusive). Values outside this range are allowed and can be used to perform *extrapolation* instead.
+   */
+  interpolate_with(xform: Transform3D | Projection, weight: float): Transform3D;
+  /**
+   * Returns the inverted version of this transform (https://en.wikipedia.org/wiki/Invertible_matrix). See also {@link Basis.inverse}.
+   * **Note:** For this method to return correctly, the transform's {@link basis} needs to be *orthonormal* (see {@link orthonormalized}). That means the basis should only represent a rotation. If it does not, use {@link affine_inverse} instead.
+   */
+  inverse(): Transform3D;
+  /**
+   * Returns `true` if this transform and `xform` are approximately equal, by running {@link @GlobalScope.is_equal_approx} on each component.
+   */
+  is_equal_approx(xform: Transform3D | Projection): boolean;
+  /**
+   * Returns `true` if this transform is finite, by calling {@link @GlobalScope.is_finite} on each component.
+   */
+  is_finite(): boolean;
+  /**
+   * Returns a copy of this transform rotated so that the forward axis (-Z) points towards the `target` position.
+   * The up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the forward axis. The resulting transform is orthonormalized. The existing rotation, scale, and skew information from the original transform is discarded. The `target` and `up` vectors cannot be zero, cannot be parallel to each other, and are defined in global/parent space.
+   * If `use_model_front` is `true`, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the `target` position. By default, the -Z axis (camera forward) is treated as forward (implies +X is right).
+   */
+  looking_at(target: Vector3 | Vector3i, up?: Vector3 | Vector3i, use_model_front?: boolean): Transform3D;
+  /**
+   * Returns a copy of this transform with its {@link basis} orthonormalized. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation. See also {@link Basis.orthonormalized}.
+   */
+  orthonormalized(): Transform3D;
+  /**
+   * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
+   * The `axis` must be a normalized vector (see {@link Vector3.normalized}). If `angle` is positive, the basis is rotated counter-clockwise around the axis.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the left, i.e., `R * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  rotated(axis: Vector3 | Vector3i, angle: float): Transform3D;
+  /**
+   * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
+   * The `axis` must be a normalized vector in the transform's local coordinate system. For example, to rotate around the local X-axis, use {@link Vector3.RIGHT}.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the right, i.e., `X * R`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  rotated_local(axis: Vector3 | Vector3i, angle: float): Transform3D;
+  /**
+   * Returns a copy of this transform scaled by the given `scale` factor.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the left, i.e., `S * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  scaled(scale: Vector3 | Vector3i): Transform3D;
+  /**
+   * Returns a copy of this transform scaled by the given `scale` factor.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the right, i.e., `X * S`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  scaled_local(scale: Vector3 | Vector3i): Transform3D;
+  /**
+   * Returns a copy of this transform translated by the given `offset`.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the left, i.e., `T * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  translated(offset: Vector3 | Vector3i): Transform3D;
+  /**
+   * Returns a copy of this transform translated by the given `offset`.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the right, i.e., `X * T`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  translated_local(offset: Vector3 | Vector3i): Transform3D;
+
+  // Operator overloads
+  [__ops_ne]: { right: Transform3D; ret: boolean };
+  [__ops_mul]: { right: AABB; ret: AABB } | { right: PackedVector3Array; ret: PackedVector3Array } | { right: Plane; ret: Plane } | { right: Transform3D; ret: Transform3D } | { right: Vector3; ret: Vector3 } | { right: float; ret: Transform3D } | { right: int; ret: Transform3D };
+  [__ops_div]: { right: float; ret: Transform3D } | { right: int; ret: Transform3D };
+  [__ops_eq]: { right: Transform3D; ret: boolean };
+
+  [__variant_converts]: Transform3D | Projection;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface Transform3DConstructor {
+  readonly prototype: Transform3D;
+  /**
+   * Constructs a {@link Transform3D} identical to {@link IDENTITY}.
+   * **Note:** In C#, this constructs a {@link Transform3D} with its {@link origin} and the components of its {@link basis} set to {@link Vector3.ZERO}.
+   */
+  (): Transform3D;
+  /** Constructs a {@link Transform3D} as a copy of the given {@link Transform3D}. */
+  (from_: Transform3D): Transform3D;
+  /** Constructs a {@link Transform3D} from a {@link Basis} and {@link Vector3}. */
+  (basis: Basis, origin: Vector3): Transform3D;
+  /**
+   * Constructs a {@link Transform3D} from a {@link Projection}. Because {@link Transform3D} is a 3×4 matrix and {@link Projection} is a 4×4 matrix, this operation trims the last row of the projection matrix (`from.x.w`, `from.y.w`, `from.z.w`, and `from.w.w` are not included in the new transform).
+   */
+  (from_: Projection): Transform3D;
+  /**
+   * Constructs a {@link Transform3D} from four {@link Vector3} values (also called matrix columns).
+   * The first three arguments are the {@link basis}'s axes ({@link Basis.x}, {@link Basis.y}, and {@link Basis.z}).
+   */
+  (x_axis: Vector3, y_axis: Vector3, z_axis: Vector3, origin: Vector3): Transform3D;
+
+  /**
+   * The identity {@link Transform3D}. This is a transform with no translation, no rotation, and a scale of {@link Vector3.ONE}. Its {@link basis} is equal to {@link Basis.IDENTITY}. This also means that:
+   * - Its {@link Basis.x} points right ({@link Vector3.RIGHT});
+   * - Its {@link Basis.y} points up ({@link Vector3.UP});
+   * - Its {@link Basis.z} points back ({@link Vector3.BACK}).
+   * If a {@link Vector3}, an {@link AABB}, a {@link Plane}, a {@link PackedVector3Array}, or another {@link Transform3D} is transformed (multiplied) by this constant, no transformation occurs.
+   * **Note:** In GDScript, this constant is equivalent to creating a [constructor Transform3D] without any arguments. It can be used to make your code clearer, and for consistency with C#.
+   */
+  readonly IDENTITY: Transform3D;
+  /**
+   * {@link Transform3D} with mirroring applied perpendicular to the YZ plane. Its {@link basis} is equal to {@link Basis.FLIP_X}.
+   */
+  readonly FLIP_X: Transform3D;
+  /**
+   * {@link Transform3D} with mirroring applied perpendicular to the XZ plane. Its {@link basis} is equal to {@link Basis.FLIP_Y}.
+   */
+  readonly FLIP_Y: Transform3D;
+  /**
+   * {@link Transform3D} with mirroring applied perpendicular to the XY plane. Its {@link basis} is equal to {@link Basis.FLIP_Z}.
+   */
+  readonly FLIP_Z: Transform3D;
+}
+declare const Transform3D: Transform3DConstructor;

package/typings/classes/Translation.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A language translation that maps a collection of strings to their individual translations. */
+declare class Translation extends Resource {
+  /** The locale of the translation. */
+  locale: string;
+  /**
+   * The plural rules string to enforce. See GNU gettext (https://www.gnu.org/software/gettext/manual/html_node/Plural-forms.html) for examples and more info.
+   * If empty or invalid, default plural rules from {@link TranslationServer.get_plural_rules} are used. The English plural rules are used as a fallback.
+   */
+  plural_rules_override: string;
+  set_locale(value: string | NodePath): void;
+  get_locale(): string;
+  set_plural_rules_override(value: string | NodePath): void;
+  get_plural_rules_override(): string;
+
+  /** Virtual method to override {@link get_message}. */
+  _get_message(src_message: string, context: string): string;
+  /** Virtual method to override {@link get_plural_message}. */
+  _get_plural_message(src_message: string, src_plural_message: string, n: int, context: string): string;
+  /**
+   * Adds a message if nonexistent, followed by its translation.
+   * An additional context could be used to specify the translation context or differentiate polysemic words.
+   */
+  add_message(src_message: string, xlated_message: string, context?: string): void;
+  /**
+   * Adds a message involving plural translation if nonexistent, followed by its translation.
+   * An additional context could be used to specify the translation context or differentiate polysemic words.
+   */
+  add_plural_message(src_message: string, xlated_messages: PackedStringArray | Array<unknown>, context?: string): void;
+  /** Erases a message. */
+  erase_message(src_message: string, context?: string): void;
+  /** Returns a message's translation. */
+  get_message(src_message: string, context?: string): string;
+  /** Returns the number of existing messages. */
+  get_message_count(): int;
+  /**
+   * Returns the keys of all messages, that is, the context and untranslated strings of each message.
+   * **Note:** If a message does not use a context, the corresponding element is the untranslated string. Otherwise, the corresponding element is the context and untranslated string separated by the EOT character (`U+0004`). This is done for compatibility purposes.
+   */
+  get_message_list(): PackedStringArray;
+  /**
+   * Returns a message's translation involving plurals.
+   * The number `n` is the number or quantity of the plural object. It will be used to guide the translation system to fetch the correct plural form for the selected language.
+   * **Note:** Plurals are only supported in gettext-based translations (PO) ($DOCS_URL/tutorials/i18n/localization_using_gettext.html), not CSV.
+   */
+  get_plural_message(src_message: string, src_plural_message: string, n: int, context?: string): string;
+  /** Returns all the translated strings. */
+  get_translated_message_list(): PackedStringArray;
+}

package/typings/classes/TranslationDomain.d.ts

@@ -0,0 +1,115 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A self-contained collection of {@link Translation} resources. */
+declare class TranslationDomain extends RefCounted {
+  /**
+   * If `true`, translation is enabled. Otherwise, {@link translate} and {@link translate_plural} will return the input message unchanged regardless of the current locale.
+   */
+  enabled: boolean;
+  /**
+   * Replace all characters with their accented variants during pseudolocalization.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_accents_enabled: boolean;
+  /**
+   * Double vowels in strings during pseudolocalization to simulate the lengthening of text due to localization.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_double_vowels_enabled: boolean;
+  /**
+   * If `true`, enables pseudolocalization for the project. This can be used to spot untranslatable strings or layout issues that may occur once the project is localized to languages that have longer strings than the source language.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_enabled: boolean;
+  /**
+   * The expansion ratio to use during pseudolocalization. A value of `0.3` is sufficient for most practical purposes, and will increase the length of each string by 30%.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_expansion_ratio: float;
+  /**
+   * If `true`, emulate bidirectional (right-to-left) text when pseudolocalization is enabled. This can be used to spot issues with RTL layout and UI mirroring that will crop up if the project is localized to RTL languages such as Arabic or Hebrew.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_fake_bidi_enabled: boolean;
+  /**
+   * Replace all characters in the string with `*`. Useful for finding non-localizable strings.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_override_enabled: boolean;
+  /**
+   * Prefix that will be prepended to the pseudolocalized string.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_prefix: string;
+  /**
+   * Skip placeholders for string formatting like `%s` or `%f` during pseudolocalization. Useful to identify strings which need additional control characters to display correctly.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_skip_placeholders_enabled: boolean;
+  /**
+   * Suffix that will be appended to the pseudolocalized string.
+   * **Note:** Updating this property does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} notification manually after you have finished modifying pseudolocalization related options.
+   */
+  pseudolocalization_suffix: string;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_pseudolocalization_accents_enabled(value: boolean): void;
+  is_pseudolocalization_accents_enabled(): boolean;
+  set_pseudolocalization_double_vowels_enabled(value: boolean): void;
+  is_pseudolocalization_double_vowels_enabled(): boolean;
+  set_pseudolocalization_enabled(value: boolean): void;
+  is_pseudolocalization_enabled(): boolean;
+  set_pseudolocalization_expansion_ratio(value: float): void;
+  get_pseudolocalization_expansion_ratio(): float;
+  set_pseudolocalization_fake_bidi_enabled(value: boolean): void;
+  is_pseudolocalization_fake_bidi_enabled(): boolean;
+  set_pseudolocalization_override_enabled(value: boolean): void;
+  is_pseudolocalization_override_enabled(): boolean;
+  set_pseudolocalization_prefix(value: string | NodePath): void;
+  get_pseudolocalization_prefix(): string;
+  set_pseudolocalization_skip_placeholders_enabled(value: boolean): void;
+  is_pseudolocalization_skip_placeholders_enabled(): boolean;
+  set_pseudolocalization_suffix(value: string | NodePath): void;
+  get_pseudolocalization_suffix(): string;
+
+  /** Adds a translation. */
+  add_translation(translation: Translation): void;
+  /** Removes all translations. */
+  clear(): void;
+  /**
+   * Returns the {@link Translation} instances that match `locale` (see {@link TranslationServer.compare_locales}). If `exact` is `true`, only instances whose locale exactly equals `locale` will be returned.
+   */
+  find_translations(locale: string | NodePath, exact: boolean): Array<Translation>;
+  /** Returns the locale override of the domain. Returns an empty string if locale override is disabled. */
+  get_locale_override(): string;
+  /**
+   * Returns the {@link Translation} instance that best matches `locale`. Returns `null` if there are no matches.
+   */
+  get_translation_object(locale: string | NodePath): Translation | null;
+  /** Returns all available {@link Translation} instances as added by {@link add_translation}. */
+  get_translations(): Array<Translation>;
+  /** Returns `true` if this translation domain contains the given `translation`. */
+  has_translation(translation: Translation): boolean;
+  /**
+   * Returns `true` if there are any {@link Translation} instances that match `locale` (see {@link TranslationServer.compare_locales}). If `exact` is `true`, only instances whose locale exactly equals `locale` are considered.
+   */
+  has_translation_for_locale(locale: string | NodePath, exact: boolean): boolean;
+  /** Returns the pseudolocalized string based on the `message` passed in. */
+  pseudolocalize(message: string): string;
+  /** Removes the given translation. */
+  remove_translation(translation: Translation): void;
+  /**
+   * Sets the locale override of the domain.
+   * If `locale` is an empty string, locale override is disabled. Otherwise, `locale` will be standardized to match known locales (e.g. `en-US` would be matched to `en_US`).
+   * **Note:** Calling this method does not automatically update texts in the scene tree. Please propagate the {@link MainLoop.NOTIFICATION_TRANSLATION_CHANGED} signal manually.
+   */
+  set_locale_override(locale: string | NodePath): void;
+  /** Returns the current locale's translation for the given message and context. */
+  translate(message: string, context?: string): string;
+  /**
+   * Returns the current locale's translation for the given message, plural message and context.
+   * The number `n` is the number or quantity of the plural object. It will be used to guide the translation system to fetch the correct plural form for the selected language.
+   */
+  translate_plural(message: string, message_plural: string, n: int, context?: string): string;
+}

package/typings/classes/TranslationServer.d.ts

@@ -0,0 +1,117 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** The server responsible for language translations. */
+declare interface TranslationServer extends GodotObject {
+  /**
+   * If `true`, enables the use of pseudolocalization on the main translation domain. See {@link ProjectSettings.internationalization/pseudolocalization/use_pseudolocalization} for details.
+   */
+  pseudolocalization_enabled: boolean;
+  set_pseudolocalization_enabled(value: boolean): void;
+  is_pseudolocalization_enabled(): boolean;
+
+  /** Adds a translation to the main translation domain. */
+  add_translation(translation: Translation): void;
+  /** Removes all translations from the main translation domain. */
+  clear(): void;
+  /** Compares two locales and returns a similarity score between `0` (no match) and `10` (full match). */
+  compare_locales(locale_a: string | NodePath, locale_b: string | NodePath): int;
+  /**
+   * Returns the {@link Translation} instances in the main translation domain that match `locale` (see {@link compare_locales}). If `exact` is `true`, only instances whose locale exactly equals `locale` will be returned.
+   */
+  find_translations(locale: string | NodePath, exact: boolean): Array<Translation>;
+  /** Converts a number from Western Arabic (0..9) to the numeral system used in the given `locale`. */
+  format_number(number: string | NodePath, locale: string | NodePath): string;
+  /** Returns an array of known country codes. */
+  get_all_countries(): PackedStringArray;
+  /** Returns array of known language codes. */
+  get_all_languages(): PackedStringArray;
+  /** Returns an array of known script codes. */
+  get_all_scripts(): PackedStringArray;
+  /** Returns a readable country name for the `country` code. */
+  get_country_name(country: string | NodePath): string;
+  /** Returns a readable language name for the `language` code. */
+  get_language_name(language: string | NodePath): string;
+  /** Returns an array of all loaded locales of the project. */
+  get_loaded_locales(): PackedStringArray;
+  /**
+   * Returns the current locale of the project.
+   * See also {@link OS.get_locale} and {@link OS.get_locale_language} to query the locale of the user system.
+   */
+  get_locale(): string;
+  /**
+   * Returns a locale's language and its variant (e.g. `"en_US"` would return `"English (United States)"`).
+   */
+  get_locale_name(locale: string | NodePath): string;
+  /**
+   * Returns the translation domain with the specified name. An empty translation domain will be created and added if it does not exist.
+   */
+  get_or_add_domain(domain: string): TranslationDomain;
+  /** Returns the percent sign used in the given `locale`. */
+  get_percent_sign(locale: string | NodePath): string;
+  /** Returns the default plural rules for the `locale`. */
+  get_plural_rules(locale: string | NodePath): string;
+  /** Returns a readable script name for the `script` code. */
+  get_script_name(script: string | NodePath): string;
+  /**
+   * Returns the current locale of the editor.
+   * **Note:** When called from an exported project returns the same value as {@link get_locale}.
+   */
+  get_tool_locale(): string;
+  /**
+   * Returns the {@link Translation} instance that best matches `locale` in the main translation domain. Returns `null` if there are no matches.
+   */
+  get_translation_object(locale: string | NodePath): Translation | null;
+  /**
+   * Returns all available {@link Translation} instances in the main translation domain as added by {@link add_translation}.
+   */
+  get_translations(): Array<Translation>;
+  /** Returns `true` if a translation domain with the specified name exists. */
+  has_domain(domain: string): boolean;
+  /** Returns `true` if the main translation domain contains the given `translation`. */
+  has_translation(translation: Translation): boolean;
+  /**
+   * Returns `true` if there are any {@link Translation} instances in the main translation domain that match `locale` (see {@link compare_locales}). If `exact` is `true`, only instances whose locale exactly equals `locale` are considered.
+   */
+  has_translation_for_locale(locale: string | NodePath, exact: boolean): boolean;
+  /** Converts `number` from the numeral system used in the given `locale` to Western Arabic (0..9). */
+  parse_number(number: string | NodePath, locale: string | NodePath): string;
+  /**
+   * Returns the pseudolocalized string based on the `message` passed in.
+   * **Note:** This method always uses the main translation domain.
+   */
+  pseudolocalize(message: string): string;
+  /**
+   * Reparses the pseudolocalization options and reloads the translation for the main translation domain.
+   */
+  reload_pseudolocalization(): void;
+  /**
+   * Removes the translation domain with the specified name.
+   * **Note:** Trying to remove the main translation domain is an error.
+   */
+  remove_domain(domain: string): void;
+  /** Removes the given translation from the main translation domain. */
+  remove_translation(translation: Translation): void;
+  /**
+   * Sets the locale of the project. The `locale` string will be standardized to match known locales (e.g. `en-US` would be matched to `en_US`).
+   * If translations have been loaded beforehand for the new locale, they will be applied.
+   */
+  set_locale(locale: string | NodePath): void;
+  /**
+   * Returns a `locale` string standardized to match known locales (e.g. `en-US` would be matched to `en_US`). If `add_defaults` is `true`, the locale may have a default script or country added.
+   */
+  standardize_locale(locale: string | NodePath, add_defaults?: boolean): string;
+  /**
+   * Returns the current locale's translation for the given message and context.
+   * **Note:** This method always uses the main translation domain.
+   */
+  translate(message: string, context?: string): string;
+  /**
+   * Returns the current locale's translation for the given message, plural message and context.
+   * The number `n` is the number or quantity of the plural object. It will be used to guide the translation system to fetch the correct plural form for the selected language.
+   * **Note:** This method always uses the main translation domain.
+   */
+  translate_plural(message: string, plural_message: string, n: int, context?: string): string;
+}
+declare const TranslationServer: TranslationServer;
+