@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-graphics.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { Identity, NullishProps } from "#utils";
 
 declare global {
   /**
@@ -9,16 +9,10 @@ declare global {
      * @param options - A config object
      */
     constructor(
-      options?: InexactPartial<{
-        /** A geometry passed to the graphics. */
-        geometry: PIXI.GraphicsGeometry;
-
-        /** The name of the PCO. */
-        name: string;
-
-        /** Any object that owns this PCO. */
-        object: PlaceableObject;
-      }>,
+      /**
+       * @remarks Passing `null`, or an object where the `geometry` property is either missing or nullish, will result in an effective default of `new PIXI.GraphicsGeometry()`
+       */
+      options?: PIXI.GraphicsGeometry | PrimaryGraphics.ConstructorOptions | null,
     );
 
     override _calculateCanvasBounds(): void;
@@ -27,4 +21,40 @@ declare global {
 
     override containsCanvasPoint(point: PIXI.IPointData): boolean;
   }
+
+  namespace PrimaryGraphics {
+    interface Any extends AnyPrimaryGraphics {}
+    interface AnyConstructor extends Identity<typeof AnyPrimaryGraphics> {}
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * A geometry passed to the graphics.
+       * @defaultValue `new PIXI.GraphicsGeometry()`
+       * @remarks Default via calling `super(geometry)` with a falsey value
+       */
+      geometry: PIXI.GraphicsGeometry;
+
+      /**
+       * The name of the PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * */
+      name: string;
+
+      /**
+       * Any object that owns this PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * @privateRemarks Foundry types as `*`, but the only place they use this class is for `Drawing`s
+       */
+      object: PlaceableObject.Any;
+    }>;
+
+    interface ConstructorOptions extends _ConstructorOptions {}
+  }
+}
+
+declare abstract class AnyPrimaryGraphics extends PrimaryGraphics {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-occludable-object.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin, NullishProps } from "#utils";
 
 declare class PrimaryOccludableObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -20,7 +20,7 @@ declare class PrimaryOccludableObject {
    * The occlusion mode of this occludable object.
    * @defaultValue `CONST.OCCLUSION_MODES.NONE`
    */
-  occlusionMode: typeof CONST.OCCLUSION_MODES;
+  occlusionMode: CONST.OCCLUSION_MODES;
 
   /**
    * The unoccluded alpha of this object.
@@ -44,18 +44,40 @@ declare class PrimaryOccludableObject {
 
   /**
    * The amount of rendered FADE, RADIAL, and VISION occlusion.
+   * @defaultValue
+   * ```js
+   * {
+   *   fade: 0.0,
+   *   radial: 0.0,
+   *   vision: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+  _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
 
   /**
    * The state of hover-fading.
-   */
-  protected _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+   * @defaultValue
+   * ```js
+   * {
+   *   hovered: false,
+   *   hoveredTime: 0,
+   *   faded: false,
+   *   fading: false,
+   *   fadingTime: 0,
+   *   occlusion: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
+   */
+  _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
 
   /**
    * Get the blocking option bitmask value.
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected get _restrictionState(): number;
+  get _restrictionState(): number;
 
   /**
    * Is this object blocking light?
@@ -81,12 +103,13 @@ declare class PrimaryOccludableObject {
    * change PCO appearance.
    * Uses a 50ms debounce threshold.
    * Objects which are in the hovered state remain occluded until their hovered state ends.
+   * @remarks Actually the return value of an arrow function passed to `foundry.utils.debounce` with a timeout of 50ms
    */
-  debounceSetOcclusion: (occluded: boolean) => void;
+  debounceSetOcclusion: (occluded: boolean) => boolean;
 
   updateCanvasTransform(): void;
 
-  _shouldRenderDepth: boolean;
+  _shouldRenderDepth(): boolean;
 
   /**
    * Test whether a specific Token occludes this PCO.
@@ -95,37 +118,55 @@ declare class PrimaryOccludableObject {
    * @param options - Additional options that affect testing
    * @returns Is the Token occluded by the PCO?
    */
-  testOcclusion(
-    token: Token,
-    options?: InexactPartial<{
-      /** Test corners of the hit-box in addition to the token center? */
-      corners: boolean;
-    }>,
-  ): boolean;
+  testOcclusion(token: Token.Object, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
 
   /**
    * @deprecated since v12, will be removed in v14
+   * @remarks "`#roof` is deprecated in favor of more granular options: `#restrictsLight` and `#restrictsWeather`"
    */
   get roof(): boolean;
 
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#roof is deprecated in favor of more granular options: #restrictsLight and #restrictsWeather"
+   */
+  set roof(enabled);
+
   /**
    * @deprecated since v12, will be removed in v14
+   * @remarks "#containsPixel is deprecated. Use #containsCanvasPoint instead."
    */
-  containsPixel(x: number, y: number, alphaThreshold: number): boolean;
+  containsPixel(x: number, y: number, alphaThreshold?: number): boolean;
 
   /**
    * @deprecated since v11, will be removed in v13
+   * @remarks "PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepth"
    */
   renderOcclusion(renderer: PIXI.Renderer): void;
 }
 
 declare global {
-  function PrimaryOccludableObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+  function PrimaryOccludableObjectMixin<BaseClass extends PrimaryOccludableObjectMixin.BaseClass>(
     DisplayObject: BaseClass,
   ): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
 
   namespace PrimaryOccludableObjectMixin {
-    type MixinClass = typeof PrimaryOccludableObject;
+    interface AnyMixedConstructor extends ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>> {}
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
+
+    /** @internal */
+    type _TestOcclusionOptions = NullishProps<{
+      /**
+       * Test corners of the hit-box in addition to the token center?
+       * @defaultValue `0`
+       */
+      corners: boolean;
+    }>;
+
+    /** Additional options that affect testing */
+    interface TestOcclusionOptions extends _TestOcclusionOptions {}
 
     interface OcclusionState {
       /** The amount of FADE occlusion */

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-sprite-mesh.d.mts

@@ -1,11 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-// TODO: Remove when #2570 is completed
-declare const PrimaryBaseSamplerShader: BaseSamplerShader;
-
-declare namespace PrimaryBaseSamplerShader {
-  type AnyConstructor = unknown;
-}
+import type { Identity, InexactPartial, NullishProps } from "#utils";
 
 declare global {
   /**
@@ -13,30 +6,31 @@ declare global {
    */
   class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
     constructor(
-      options?:
-        | InexactPartial<{
-            /** Texture passed to the SpriteMesh. */
-            texture: PIXI.Texture;
-
-            /** The shader class used to render this sprite. */
-            shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
-
-            /** The name of this sprite. */
-            name: string;
-          }>
-        | PIXI.Texture,
-      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor,
+      /**
+       * The constructor options.
+       * @defaultValue `{}`
+       * @remarks Default is applied if `options` is `instanceof PIXI.Texture`, or neither that nor `instanceof Object`
+       */
+      options?: PrimarySpriteMesh.ConstructorOptions | PIXI.Texture | null,
+      /**
+       * The shader class used to render this sprite.
+       * @defaultValue `PrimaryBaseSamplerShader`
+       * @remarks If `options` is an object, `options.shaderClass` takes precedence. If omitted,
+       * or if `options` is a `PIXI.Texture`, default is provided by `??` in function body.
+       */
+      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor | null,
     );
 
     /**
      * The texture alpha data.
      */
-    _textureAlphaData: TextureLoader.TextureAlphaData | null;
+    protected _textureAlphaData: TextureLoader.TextureAlphaData | null;
 
     /**
      * The texture alpha threshold used for point containment tests.
      * If set to a value larger than 0, the texture alpha data is
      * extracted from the texture at 25% resolution.
+     * @defaultValue `0`
      */
     textureAlphaThreshold: number;
 
@@ -67,21 +61,9 @@ declare global {
      * @param baseWidth  - The base width used for computations.
      * @param baseHeight - The base height used for computations.
      * @param options    - The options.
+     * @throws If either `baseWidth` or `baseHeight` are less than 0, or if `options.fit` is not a FitType
      */
-    resize(
-      baseWidth: number,
-      baseHeight: number,
-      options?: InexactPartial<{
-        /** The fit type. */
-        fit: "fill" | "cover" | "contain" | "width" | "height";
-
-        /** The scale on X axis. */
-        scaleX: number;
-
-        /** The scale on Y axis. */
-        scaleY: number;
-      }>,
-    ): void;
+    resize(baseWidth: number, baseHeight: number, options?: PrimarySpriteMesh.ResizeOptions): void;
 
     protected override _updateBatchData(): void;
 
@@ -92,7 +74,22 @@ declare global {
      * @param point                 - The point in canvas space
      * @param textureAlphaThreshold - The minimum texture alpha required for containment
      */
-    containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+    containsCanvasPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      textureAlphaThreshold?: number,
+    ): boolean;
+
+    /**
+     * Is the given point in world space contained in this object?
+     * @param point                 - The point in world space
+     * @param textureAlphaThreshold - The minimum texture alpha required for containment
+     */
+    containsPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      textureAlphaThreshold?: number,
+    ): boolean;
 
     override renderDepthData(renderer: PIXI.Renderer): void;
 
@@ -105,7 +102,93 @@ declare global {
 
     /**
      * @deprecated since v12, will be removed in v14
+     * @remarks "#getPixelAlpha is deprecated without replacement."
      */
     getPixelAlpha(x: number, y: number): number;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getAlphaBounds is deprecated without replacement."
+     */
+    _getAlphaBounds(): PIXI.Rectangle;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getTextureCoordinate is deprecated without replacement."
+     */
+    _getTextureCoordinate(testX: number, testY: number): PIXI.IPointData;
   }
+
+  namespace PrimarySpriteMesh {
+    interface Any extends AnyPrimarySpriteMesh {}
+    interface AnyConstructor extends Identity<typeof AnyPrimarySpriteMesh> {}
+
+    type FitType = "fill" | "cover" | "contain" | "width" | "height";
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * Texture passed to the SpriteMesh.
+       * @defaultValue `null`
+       * @remarks Default ultimately provided by the `SpriteMesh` constructor
+       */
+      texture: PIXI.Texture;
+
+      /**
+       * The shader class used to render this sprite.
+       * @defaultValue `PrimaryBaseSamplerShader`
+       * @remarks Default provided by `??=` in function body
+       */
+      shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+
+      /**
+       * The name of this sprite.
+       * @defaultValue `null`
+       * @remarks Default provided by `?? null` in function body
+       */
+      name: string;
+
+      /**
+       * Any object that owns this PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * @privateRemarks Foundry types as `*`, but the only things passed in practice are `Tile`s, `Token`s, and the `PrimaryCanvasGroup`
+       */
+      // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+      object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
+    }>;
+
+    /** The constructor options */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ResizeOptions = InexactPartial<{
+      /**
+       * The fit type.
+       * @defaultValue `"fill"`
+       * @remarks Can't be `null` because it only has a parameter default, and is then fed into a switch statement where the default is throw
+       * */
+      fit: FitType;
+
+      /**
+       * The scale on X axis.
+       * @defaultValue `1`
+       * @remarks Can't be `null` because it only has a parameter default and a width scale of 0 is, if not nonsensical, not to be done by accident.
+       */
+      scaleX: number;
+
+      /**
+       * The scale on Y axis.
+       * @defaultValue `1`
+       * @remarks Can't be `null` because it only has a parameter default and a height scale of 0 is, if not nonsensical, not to be done by accident.
+       */
+      scaleY: number;
+    }>;
+
+    interface ResizeOptions extends _ResizeOptions {}
+  }
+}
+
+declare abstract class AnyPrimarySpriteMesh extends PrimarySpriteMesh {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/placeables/region.d.mts

@@ -0,0 +1,280 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { Brand, FixedInstanceType, HandleEmptyObject, NullishProps } from "#utils";
+import type RegionShape from "../../../client-esm/canvas/regions/shape.d.mts";
+import type RegionPolygonTree from "../../../client-esm/canvas/regions/polygon-tree.d.mts";
+import type RegionGeometry from "../../../client-esm/canvas/regions/geometry.d.mts";
+
+declare global {
+  /**
+   * A Region is an implementation of PlaceableObject which represents a Region document
+   * within a viewed Scene on the game canvas.
+   * @see {@link RegionDocument | `RegionDocument`}
+   * @see {@link RegionLayer | `RegionLayer`}
+   */
+  class Region extends PlaceableObject<RegionDocument.Implementation> {
+    constructor(document: RegionDocument.Implementation);
+
+    // fake override; super has to type as if this could be a ControlIcon, but Regions don't use one
+    override controlIcon: null;
+
+    static override embeddedName: "Region";
+
+    static override RENDER_FLAGS: Region.RENDER_FLAGS;
+
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<Region.RENDER_FLAGS>;
+
+    /**
+     * The scaling factor used for Clipper paths.
+     * @defaultValue `100`
+     * @remarks Defined using `Object.defineProperty` in a static initialization block
+     */
+    static readonly CLIPPER_SCALING_FACTOR: 100;
+
+    /**
+     * The three movement segment types: ENTER, MOVE, and EXIT.
+     * @remarks Defined using `Object.defineProperty` in a static initialization block
+     */
+    static readonly MOVEMENT_SEGMENT_TYPES: Region.MovementSegmentTypes;
+
+    /**
+     * The shapes of this Region in draw order.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get shapes(): RegionShape.Any[];
+
+    /** The bottom elevation of this Region. */
+    get bottom(): number;
+
+    /** The top elevation of this Region. */
+    get top(): number;
+
+    /**
+     * The polygons of this Region.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get polygons(): PIXI.Polygon[];
+
+    /** The polygon tree of this Region. */
+    get polygonTree(): RegionPolygonTree;
+
+    /**
+     * The Clipper paths of this Region.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get clipperPaths(): ClipperLib.Paths;
+
+    /**
+     * The triangulation of this Region
+     * @privateRemarks Foundry types this as `Readonly<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get triangulation(): Region.TriangulationData;
+
+    /** The geometry of this Region */
+    get geometry(): RegionGeometry;
+
+    override get bounds(): PIXI.Rectangle;
+
+    override get center(): PIXI.Point;
+
+    /** Is this Region currently visible on the Canvas? */
+    get isVisible(): boolean;
+
+    /**
+     * @throws "`Region#getSnappedPosition` is not supported: `RegionDocument` does not have a (x, y) position"
+     */
+    override getSnappedPosition(position?: never): never;
+
+    protected override _draw(options: HandleEmptyObject<Region.DrawOptions>): Promise<void>;
+
+    // fake override; super has to account for misbehaving siblings returning void
+    override clear(): this;
+
+    protected override _applyRenderFlags(flags: Region.RenderFlags): void;
+
+    /** Refresh the state of the Region. */
+    protected _refreshState(): void;
+
+    /** Refreshes the border of the Region. */
+    protected _refreshBorder(): void;
+
+    protected override _canDrag(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
+
+    protected override _canHUD(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
+
+    protected override _onControl(options: Region.ControlOptions): void;
+
+    protected override _onRelease(options: HandleEmptyObject<Region.ReleaseOptions>): void;
+
+    // options: not null (destructured)
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: Region.HoverInOptions): void;
+
+    // options: not null (destructured)
+    protected override _onHoverOut(event: PIXI.FederatedEvent, options?: Region.HoverOutOptions): void;
+
+    protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
+
+    /**
+     * Test whether the given point (at the given elevation) is inside this Region.
+     * @param point       - The point.
+     * @param elevation   - The elevation of the point.
+     * @returns Is the point (at the given elevation) inside this Region?
+     * @remarks Only tests elevation if provided, always forwards `position` to {@link RegionPolygonTree.testPoint | `RegionPolygonTree#testPoint`}
+     */
+    // elevation: not null (`=== undefined` check)
+    testPoint(point: Canvas.Point, elevation?: number): boolean;
+
+    /**
+     * Split the movement into its segments.
+     * @param waypoints - The waypoints of movement.
+     * @param samples   - The points relative to the waypoints that are tested. Whenever one of them is inside the region, the moved object is considered to be inside the region.
+     * @param options   - Additional options
+     * @returns The movement split into its segments.
+     */
+    // options: not null (destructured)
+    segmentizeMovement(
+      waypoints: Region.MovementWaypoint[],
+      samples: Canvas.Point[],
+      options?: Region.SegmentizeMovementOptions,
+    ): Region.MovementSegment[];
+
+    // _onUpdate is overridden but with no signature changes.
+    // For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): PlaceableObject.DragLeftDropUpdate[];
+  }
+
+  namespace Region {
+    // eslint-disable-next-line no-restricted-syntax
+    interface ObjectClass extends ConfiguredObjectClassOrDefault<typeof Region> {}
+    interface Object extends FixedInstanceType<ObjectClass> {}
+
+    /**
+     * @deprecated {@link Region.ObjectClass | `Region.ObjectClass`}
+     */
+    type ConfiguredClass = ObjectClass;
+
+    /**
+     * @deprecated {@link Region.Object | `Region.Object`}
+     */
+    type ConfiguredInstance = Object;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Region` (the `PlaceableObject` that appears on the canvas) and
+     * `RegionDocument` (the `Document` that represents the data for a `Region`) is so common that
+     * it is useful to have a type to forward to `RegionDocument`.
+     *
+     * @deprecated {@link RegionDocument.Implementation | `RegionDocument.Implementation`}
+     */
+    type Implementation = RegionDocument.Implementation;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Region` (the `PlaceableObject` that appears on the canvas) and
+     * `RegionDocument` (the `Document` that represents the data for a `Region`) is so common that
+     * it is useful to have a type to forward to `RegionDocument`.
+     *
+     * @deprecated {@link RegionDocument.ImplementationClass | `RegionDocument.ImplementationClass`}
+     */
+    type ImplementationClass = RegionDocument.ImplementationClass;
+
+    interface RENDER_FLAGS {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<this, "redraw">;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
+      refresh: RenderFlag<this, "refresh">;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<this, "refreshState">;
+
+      /** @defaultValue `{}` */
+      refreshBorder: RenderFlag<this, "refreshBorder">;
+    }
+
+    interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+    interface TriangulationData {
+      vertices: Float32Array;
+      indices: Uint16Array | Uint32Array;
+    }
+
+    interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+    interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+    interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+    interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+    type _HoverInOptions = NullishProps<{
+      /** @defaultValue `true` */
+      updateLegend: boolean;
+    }>;
+
+    interface HoverInOptions extends _HoverInOptions, PlaceableObject.HoverInOptions {}
+
+    interface HoverOutOptions extends _HoverInOptions {}
+
+    interface MovementWaypoint {
+      /** The x-coordinates in pixels (integer) */
+      x: number;
+
+      /** The y-coordinates in pixels (integer) */
+      y: number;
+
+      /** The elevation in grid units. */
+      elevation: number;
+    }
+
+    interface MovementSegment {
+      /** The type of this segment (see {@link Region.MovementSegmentTypes | `Region.MovementSegmentTypes`}) */
+      type: MOVEMENT_SEGMENT_TYPES;
+
+      /** The waypoint that this segment starts from */
+      from: MovementWaypoint;
+
+      /** The waypoint that this segment goes to */
+      to: MovementWaypoint;
+    }
+
+    type MOVEMENT_SEGMENT_TYPES = Brand<number, "Region.MOVEMENT_SEGMENT_TYPES">;
+
+    interface MovementSegmentTypes
+      extends Readonly<{
+        /**
+         * The segment crosses the boundary of the region and exits it.
+         */
+        EXIT: -1 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment does not cross the boundary of the region and is contained within it.
+         */
+        MOVE: 0 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment crosses the boundary of the region and enters it.
+         */
+        ENTER: 1 & MOVEMENT_SEGMENT_TYPES;
+      }> {}
+
+    /** @internal */
+    type _SegmentizeMovementOptions = NullishProps<{
+      /**
+       * Is it teleportation?
+       * @defaultValue `false`
+       * @remarks Can't be `null` because it only has a parameter default
+       */
+      teleport: boolean;
+    }>;
+
+    interface SegmentizeMovementOptions extends _SegmentizeMovementOptions {}
+  }
+}