@league-of-foundry-developers/foundry-vtt-types 9.238.0 → 9.249.0

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShader.d.ts

@@ -0,0 +1,114 @@
+interface LightingTechnique {
+  /** The numeric identifier of the technique */
+  id: number;
+
+  /** The localization string that labels the technique */
+  label: string;
+
+  /** The shader fragment when the technique is used */
+  shader: string;
+}
+
+/**
+ * This class defines an interface which all adaptive lighting shaders extend.
+ */
+declare class AdaptiveLightingShader extends AbstractBaseShader {
+  /** @override */
+  static vertexShader: string;
+
+  /**
+   * Useful constant values computed at compile time
+   */
+  static CONSTANTS: string;
+
+  /**
+   * The coloration technique shader fragment
+   */
+  static get ADAPTIVE_COLORATION(): string;
+
+  /**
+   * Fade easing to use with distance in interval [0,1]
+   * @param amp  - (default: `3`)
+   * @param coef - (default: `0.80`)
+   */
+  static FADE(amp?: number, coef?: number): string;
+
+  /**
+   * Fractional Brownian Motion for a given number of octaves
+   * @param octaves - (default: `4`)
+   * @param amp     - (default: `1.0`)
+   */
+  static FBM(octaves?: number, amp?: number): string;
+
+  /**
+   * A conventional pseudo-random number generator with the "golden" numbers, based on uv position
+   */
+  static PRNG: string;
+
+  /**
+   * A Vec3 pseudo-random generator, based on uv position
+   */
+  static PRNG3D: string;
+
+  /**
+   * A conventional noise generator
+   */
+  static NOISE: string;
+
+  /**
+   * Convert a Hue-Saturation-Brightness color to RGB - useful to convert polar coordinates to RGB
+   */
+  static HSB2RGB: string;
+
+  /**
+   * Fast approximate perceived brightness computation
+   * Using Digital ITU BT.709 : Exact luminance factors
+   */
+  static PERCEIVED_BRIGHTNESS: string;
+
+  /**
+   * Switch between an inner and outer color, by comparing distance from center to ratio
+   * Apply a strong gradient between the two areas if gradual uniform is set to true
+   */
+  static SWITCH_COLOR: string;
+
+  /**
+   * Transition between bright and dim colors, if requested
+   */
+  static TRANSITION: string;
+
+  /**
+   * Constrain light to LOS
+   */
+  static CONSTRAIN_TO_LOS: string;
+
+  /**
+   * Incorporate falloff if a gradual uniform is requested
+   */
+  static FALLOFF: string;
+
+  /**
+   * Compute distance from the light center
+   */
+  static DISTANCE: string;
+
+  /**
+   * A mapping of available coloration techniques
+   */
+  static COLORATION_TECHNIQUES: AdaptiveLightingShader.ColorationTechniques;
+}
+
+declare namespace AdaptiveLightingShader {
+  interface ColorationTechniques extends Record<string, LightingTechnique> {
+    LEGACY: LightingTechnique;
+    LUMINANCE: LightingTechnique;
+    INTERNAL_HALO: LightingTechnique;
+    EXTERNAL_HALO: LightingTechnique;
+    COLOR_BURN: LightingTechnique;
+    INTERNAL_BURN: LightingTechnique;
+    EXTERNAL_BURN: LightingTechnique;
+    LOW_ABSORPTION: LightingTechnique;
+    HIGH_ABSORPTION: LightingTechnique;
+    INVERT_ABSORPTION: LightingTechnique;
+  }
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveBackgroundShader.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The default coloration shader used by standard rendering and animations
+ * A fragment shader which creates a solid light source.
+ */
+declare class AdaptiveBackgroundShader extends AdaptiveLightingShader {
+  /**
+   * Constrain light to LOS
+   */
+  static CONSTRAIN_TO_LOS: string;
+
+  /**
+   * Color adjustments : exposure, contrast and shadows
+   */
+  static ADJUSTMENTS: string;
+
+  /**
+   * Incorporate falloff if a gradual uniform is requested
+   */
+  static FALLOFF: string;
+
+  /**
+   * Memory allocations for the Adaptive Background Shader
+   */
+  static SHADER_HEADER: string;
+
+  /** @override */
+  static fragmentShader: string;
+
+  /**
+   * @override
+   * @defaultValue
+   * ```javascript
+   * {
+   *   shadows: 0.0,
+   *   contrast: 0.0,
+   *   exposure: 0.0,
+   *   saturation: 0.0,
+   *   alpha: 1.0,
+   *   ratio: 0.5,
+   *   time: 0,
+   *   screenDimensions: [1, 1],
+   *   uBkgSampler: 0,
+   *   fovTexture: 0,
+   *   darkness: false,
+   *   gradual: false,
+   *   useFov: true
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * Flag whether the background shader is currently required.
+   * If key uniforms are at their default values, we don't need to render the background container.
+   */
+  get isRequired(): boolean;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShader.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a light source.
+ */
+declare class AdaptiveColorationShader extends AdaptiveLightingShader {
+  /**
+   * Incorporate falloff if a falloff uniform is requested
+   */
+  static FALLOFF: string;
+
+  /**
+   * Color adjustments : exposure, contrast and shadows
+   */
+  static ADJUSTMENTS: string;
+
+  /**
+   * Memory allocations for the Adaptive Coloration Shader
+   */
+  static SHADER_HEADER: string;
+
+  /** @override */
+  static fragmentShader: string;
+
+  /**
+   * @override
+   * @defaultValue
+   * ```javascript
+   * {
+   *   technique: 1,
+   *   ratio: 0.0,
+   *   shadows: 0.0,
+   *   saturation: 0.0,
+   *   alpha: 1.0,
+   *   color: [1.0, 1.0, 1.0],
+   *   time: 0,
+   *   intensity: 5,
+   *   darkness: false,
+   *   screenDimensions: [1, 1],
+   *   uBkgSampler: 0,
+   *   fovTexture: 0,
+   *   gradual: true,
+   *   useFov: true
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/bewitchingWaveColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bewitching Wave animation coloration shader
+ */
+declare class BewitchingWaveColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/chromaColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Chroma animation coloration shader
+ */
+declare class ChromaColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/emanationColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Emanation animation coloration shader
+ */
+declare class EmanationColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/energyFieldColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Energy field animation coloration shader
+ */
+declare class EnergyFieldColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/fairyLightColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fairy light animation coloration shader
+ */
+declare class FairyLightColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/fogColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fog animation coloration shader
+ */
+declare class FogColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/ghostLightColorationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Ghost light animation coloration shader
  */
-declare class GhostLightColorationShader extends StandardColorationShader {
+declare class GhostLightColorationShader extends AdaptiveColorationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/hexaDomeColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hexagonal dome animation coloration shader
+ */
+declare class HexaDomeColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/index.d.ts

@@ -1,11 +1,16 @@
+import './bewitchingWaveColorationShader';
 import './chromaColorationShader';
 import './emanationColorationShader';
 import './energyFieldColorationShader';
+import './fairyLightColorationShader';
 import './fogColorationShader';
 import './ghostLightColorationShader';
 import './hexaDomeColorationShader';
 import './lightDomeColorationShader';
 import './pulseColorationShader';
+import './radialRainbowColorationShader';
 import './sunburstColorationShader';
+import './swirlingRainbowColorationShader';
 import './torchColorationShader';
+import './vortexColorationShader';
 import './waveColorationShader';

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/lightDomeColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Light dome animation coloration shader
+ */
+declare class LightDomeColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/pulseColorationShader.d.ts

@@ -1,7 +1,7 @@
 /**
  * Pulse animation coloration shader
  */
-declare class PulseColorationShader extends StandardColorationShader {
+declare class PulseColorationShader extends AdaptiveColorationShader {
   static fragmentShader: string;
 
   /**

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/radialRainbowColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Radial rainbow animation coloration shader
+ */
+declare class RadialRainbowColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/sunburstColorationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Sunburst animation coloration shader
  */
-declare class SunburstColorationShader extends StandardColorationShader {
+declare class SunburstColorationShader extends AdaptiveColorationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/swirlingRainbowColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Swirling rainbow animation coloration shader
+ */
+declare class SwirlingRainbowColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/torchColorationShader.d.ts

@@ -1,7 +1,7 @@
 /**
  * Torch animation coloration shader
  */
-declare class TorchColorationShader extends StandardColorationShader {
+declare class TorchColorationShader extends AdaptiveColorationShader {
   static fragmentShader: string;
 
   /**
@@ -9,7 +9,8 @@ declare class TorchColorationShader extends StandardColorationShader {
    * @defaultValue
    * ```typescript
    * Object.assign({}, super.defaultUniforms, {
-   *   ratio: 0
+   *   ratio: 0,
+   *   brightnessPulse: 1
    * })
    * ```
    */

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveColorationShaders/vortexColorationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vortex animation coloration shader
+ */
+declare class VortexColorationShader extends AdaptiveColorationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardColorationShaders → adaptiveLightingShaders/adaptiveColorationShaders}/waveColorationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Wave animation coloration shader
  */
-declare class WaveColorationShader extends StandardColorationShader {
+declare class WaveColorationShader extends AdaptiveColorationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveIlluminationShader.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The default coloration shader used by standard rendering and animations
+ * A fragment shader which creates a solid light source.
+ */
+declare class AdaptiveIlluminationShader extends AdaptiveLightingShader {
+  /**
+   * Constrain light to LOS
+   */
+  static CONSTRAIN_TO_LOS: string;
+
+  /**
+   * Incorporate falloff if a gradual uniform is requested
+   */
+  static FALLOFF: string;
+
+  /**
+   * Color adjustments : exposure, contrast and shadows
+   */
+  static ADJUSTMENTS: string;
+
+  /**
+   * Memory allocations for the Adaptive Illumination Shader
+   */
+  static SHADER_HEADER: string;
+
+  /** @override */
+  static fragmentShader: string;
+
+  /**
+   * @override
+   * @defaultValue
+   * ```javascript
+   * {
+   *   alpha: 1.0,
+   *   ratio: 0.5,
+   *   color: [0.9333333333333333, 0.9333333333333333, 0.9333333333333333],
+   *   colorDim: [0.5, 0.5, 0.5],
+   *   colorBright: [1.0, 1.0, 1.0],
+   *   colorBackground: [1.0, 1.0, 1.0],
+   *   darkness: false,
+   *   exposure: 0.0,
+   *   fovTexture: 0,
+   *   gradual: false,
+   *   intensity: 5,
+   *   saturation: 0.0,
+   *   screenDimensions: [1, 1],
+   *   shadows: 0.0,
+   *   time: 0,
+   *   uBkgSampler: 0,
+   *   useFov: true
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * Determine the correct illumination penalty to apply for a given darkness level and luminosity
+   * @param darknessLevel - The current darkness level on [0,1]
+   * @param luminosity    - The light source luminosity on [-1,1]
+   * @returns The amount of penalty to apply on [0,1]
+   */
+  getDarknessPenalty(darknessLevel: number, luminosity: number): number;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveIlluminationShaders/bewitchingWaveIlluminationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bewitching Wave animation illumination shader
+ */
+declare class BewitchingWaveIlluminationShader extends AdaptiveIlluminationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/blackHoleIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Black Hole animation illumination shader
  */
-declare class BlackHoleIlluminationShader extends StandardIlluminationShader {
+declare class BlackHoleIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveIlluminationShaders/fairyLightIlluminationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fairy light animation illumination shader
+ */
+declare class FairyLightIlluminationShader extends AdaptiveIlluminationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/ghostLightIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Ghost light animation illumination shader
  */
-declare class GhostLightIlluminationShader extends StandardIlluminationShader {
+declare class GhostLightIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/index.d.ts

@@ -1,7 +1,10 @@
+import './bewitchingWaveIlluminationShader';
 import './blackHoleIlluminationShader';
+import './fairyLightIlluminationShader';
 import './ghostLightIlluminationShader';
 import './pulseIlluminationShader';
 import './roilingIlluminationShader';
 import './sunburstIlluminationShader';
 import './torchIlluminationShader';
+import './vortexIlluminationShader';
 import './waveIlluminationShader';

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/pulseIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Pulse animation illumination shader
  */
-declare class PulseIlluminationShader extends StandardIlluminationShader {
+declare class PulseIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/roilingIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Roiling mass illumination shader - intended primarily for darkness
  */
-declare class RoilingIlluminationShader extends StandardIlluminationShader {
+declare class RoilingIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/sunburstIlluminationShader.d.ts

@@ -1,7 +1,6 @@
 /**
  * Sunburst animation illumination shader
-
  */
-declare class SunburstIlluminationShader extends StandardIlluminationShader {
+declare class SunburstIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/torchIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Allow coloring of illumination
  */
-declare class TorchIlluminationShader extends StandardIlluminationShader {
+declare class TorchIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/adaptiveIlluminationShaders/vortexIlluminationShader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vortex animation coloration shader
+ */
+declare class VortexIlluminationShader extends AdaptiveIlluminationShader {
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/{standardIlluminationShaders → adaptiveLightingShaders/adaptiveIlluminationShaders}/waveIlluminationShader.d.ts

@@ -1,6 +1,6 @@
 /**
  * Wave animation illumination shader
  */
-declare class WaveIlluminationShader extends StandardIlluminationShader {
+declare class WaveIlluminationShader extends AdaptiveIlluminationShader {
   static fragmentShader: string;
 }

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/adaptiveLightingShaders/index.d.ts

@@ -0,0 +1,5 @@
+import './adaptiveBackgroundShader';
+import './adaptiveColorationShader';
+import './adaptiveColorationShaders';
+import './adaptiveIlluminationShader';
+import './adaptiveIlluminationShaders';

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/baseSamplerShader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A simple shader to emulate a PIXI.Sprite with a PIXI.Mesh (but faster!)
+ */
+declare class BaseSamplerShader extends AbstractBaseShader {
+  /** @override */
+  static vertexShader: string;
+
+  /** @override */
+  static fragmentShader: string;
+
+  /**
+   * @override
+   * @defaultValue
+   * ```javascript
+   * {
+   *   screenDimensions: [1, 1],
+   *   sampler: 0
+   * };
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/index.d.ts

@@ -1,4 +1,3 @@
-import './standardColorationShader';
-import './standardColorationShaders';
-import './standardIlluminationShader';
-import './standardIlluminationShaders';
+import './adaptiveLightingShader';
+import './adaptiveLightingShaders';
+import './baseSamplerShader';

package/src/foundry/foundry.js/pixi/texts/preciseText.d.ts

@@ -5,6 +5,14 @@
 declare class PreciseText extends PIXI.Text {
   constructor(...args: ConstructorParameters<typeof PIXI.Text>);
 
-  _autoResolution: false;
-  _resolution: 2;
+  /**
+   * Prepare a TextStyle object which merges the canvas defaults with user-provided options
+   * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
+   * @param options - Additional options merged with the default TextStyle
+   * @returns The prepared TextStyle
+   */
+  static getTextStyle({
+    anchor,
+    ...options
+  }?: { anchor?: foundry.CONST.TEXT_ANCHOR_POINTS } & ConstructorParameters<typeof PIXI.TextStyle>[0]): PIXI.TextStyle;
 }

package/src/foundry/foundry.js/pixi/transforms/index.d.ts

@@ -0,0 +1 @@
+import './synchronizedTransform';

package/src/foundry/foundry.js/pixi/transforms/synchronizedTransform.d.ts

@@ -0,0 +1,38 @@
+/**
+ * An extension of PIXI.Transform.
+ * This uses a different DisplayObject than the current parent as the reference for the worldTransform.
+ */
+declare class SynchronizedTransform extends PIXI.Transform {
+  constructor(transform: PIXI.Transform);
+
+  /**
+   * A list of attributes from the transform reference which should be synchronized
+   * @defaultValue
+   * ```javascript
+   * [
+   *   "localTransform", "position", "scale", "pivot", "skew", "_rotation",
+   *   "_cx", "_sx", "_cy", "_sy", "_localID", "_currentLocalID"
+   * ];
+   * ```
+   */
+  static synchronizedAttributes: string[];
+
+  /**
+   * A Transform instance which defines the reference point for the worldTransform
+   */
+  get reference(): PIXI.Transform;
+
+  set reference(value: PIXI.Transform);
+
+  /** @internal */
+  protected _reference: PIXI.Transform;
+
+  /** @internal */
+  protected _syncLocalID: number;
+
+  /** @override */
+  updateTransform(parentTransform: PIXI.Transform): void;
+
+  /** @override */
+  updateLocalTransform(): void;
+}