@gg-web-engine/core 0.0.58 → 0.0.60

package/dist/base/entities/i-renderer.entity.d.ts

@@ -3,11 +3,12 @@ import { GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../gg-world';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { Point2 } from '../models/points';
 import { RendererOptions } from '../components/rendering/i-renderer.component';
+import { IPositionable } from '../interfaces/i-positionable';
 /**
  * Represents a base class for a renderer entity.
  * @class
  */
-export declare abstract class IRendererEntity<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> {
+export declare abstract class IRendererEntity<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> implements IPositionable<D, R> {
     readonly renderer: VTypeDoc['renderer'];
     readonly tickOrder = TickOrder.RENDERING;
     /** Represents the current size of the renderer. */
@@ -23,6 +24,11 @@ export declare abstract class IRendererEntity<D, R, VTypeDoc extends VisualTypeD
      */
     get rendererSize(): Point2 | null;
     get rendererOptions(): RendererOptions;
+    get camera(): VTypeDoc['camera'];
+    get position(): D;
+    set position(value: D);
+    get rotation(): R;
+    set rotation(value: R);
     /** get flag whether renderer shows physics debugger view */
     get physicsDebugViewActive(): boolean;
     /** turns on/off physics debugger view for this renderer */

package/dist/base/entities/i-renderer.entity.js

@@ -23,6 +23,21 @@ export class IRendererEntity extends IEntity {
     get rendererOptions() {
         return this.renderer.rendererOptions;
     }
+    get camera() {
+        return this.renderer.camera;
+    }
+    get position() {
+        return this.camera.position;
+    }
+    set position(value) {
+        this.renderer.camera.position = value;
+    }
+    get rotation() {
+        return this.renderer.camera.rotation;
+    }
+    set rotation(value) {
+        this.renderer.camera.rotation = value;
+    }
     /** get flag whether renderer shows physics debugger view */
     get physicsDebugViewActive() {
         return this.renderer.physicsDebugViewActive;

package/dist/base/gg-world.d.ts

@@ -6,6 +6,7 @@ export type VisualTypeDocRepo<D, R> = {
     displayObject: IDisplayObjectComponent<D, R>;
     renderer: IRendererComponent<D, R>;
     rendererExtraOpts: {};
+    camera: IPositionable<D, R>;
 };
 export type PhysicsTypeDocRepo<D, R> = {
     factory: unknown;
@@ -32,6 +33,8 @@ export type GgWorldSceneTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo2D
 export type GgWorldSceneTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'physicsWorld'> & {
     physicsWorld: PW;
 };
+export type TypeDocOf<W extends GgWorld<any, any>> = W extends GgWorld<infer D, infer R, infer TypeDoc> ? TypeDoc : never;
+export type SceneTypeDocOf<W extends GgWorld<any, any>> = W extends GgWorld<infer D, infer R, infer TypeDoc, infer SceneTypeDoc> ? SceneTypeDoc : never;
 export declare abstract class GgWorld<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>, SceneTypeDoc extends GgWorldSceneTypeRepo<D, R, TypeDoc> = GgWorldSceneTypeRepo<D, R, TypeDoc>> {
     private static default_name_counter;
     private static _documentWorlds;
@@ -67,6 +70,16 @@ export declare abstract class GgWorld<D, R, TypeDoc extends GgWorldTypeDocRepo<D
     position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, TypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
+    /**
+     * Find an entity anywhere in the world by name. `children` is a flat list of every entity ever
+     * added via `addEntity` (nested entities included - `addChildren`/`onSpawned` cascade into it
+     * too), so this is a plain linear scan, not a tree walk; to search inside one particular
+     * entity's own subtree instead, use `IEntity.getChildEntityByName`.
+     * @param name - The entity's `name`
+     * @returns The first entity found with that name (insertion order), if more than one shares it
+     * @throws if no entity in the world has that name
+     */
+    getEntityByName<T extends IEntity = IEntity>(name: string): T;
     private onGgStaticInitialized;
     protected registerConsoleCommands(ggstatic: {
         registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;

package/dist/base/gg-world.js

@@ -134,7 +134,13 @@ export class GgWorld {
         this.disposed$.complete();
     }
     addEntity(entity) {
-        if (!!entity.world) {
+        if (entity.world === this) {
+            // Already a member of this world - e.g. reparented (via addChildren) after having been
+            // added directly, as level-loaded entities are. Not an error: just a no-op, since
+            // addChildren already updated the parent/children bookkeeping before calling back in here.
+            return;
+        }
+        if (entity.world) {
             console.warn('Trying to spawn entity, which is already spawned');
             return;
         }
@@ -156,6 +162,22 @@ export class GgWorld {
             entity.dispose();
         }
     }
+    /**
+     * Find an entity anywhere in the world by name. `children` is a flat list of every entity ever
+     * added via `addEntity` (nested entities included - `addChildren`/`onSpawned` cascade into it
+     * too), so this is a plain linear scan, not a tree walk; to search inside one particular
+     * entity's own subtree instead, use `IEntity.getChildEntityByName`.
+     * @param name - The entity's `name`
+     * @returns The first entity found with that name (insertion order), if more than one shares it
+     * @throws if no entity in the world has that name
+     */
+    getEntityByName(name) {
+        const found = this.children.find(e => e.name === name);
+        if (!found) {
+            throw new Error(`No entity named "${name}" found in the world`);
+        }
+        return found;
+    }
     onGgStaticInitialized() {
         window.removeEventListener('ggstatic_added', this.onGgStaticInitialized);
         this.registerConsoleCommands(window.ggstatic);
@@ -174,6 +196,19 @@ export class GgWorld {
             }
             return this.worldClock.tickRateLimit.toString();
         }), 'args: [ int? ]; Get current tick rate limit of selected world clock or set it. 0 means no limit applied');
+        ggstatic.registerConsoleCommand(this, 'step', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.worldClock.isPaused) {
+                throw new Error('World must be paused first (run "timescale 0") before it can be stepped');
+            }
+            const ms = args[0] === undefined ? 1000 / 120 : +args[0];
+            if (isNaN(ms) || ms <= 0) {
+                throw new Error('usage: step [ms]; ms must be a positive number');
+            }
+            this.worldClock.step(ms);
+            return `stepped ${ms} ms`;
+        }), 'args: [ float? ]; Advance a paused world clock by exactly one tick of the given duration ' +
+            'in milliseconds (default 8, i.e. 1000/120). Only works while the world is paused via ' +
+            '"timescale 0"; rejects otherwise');
         ggstatic.registerConsoleCommand(this, 'renderers', () => __awaiter(this, void 0, void 0, function* () {
             return this.renderers.map(r => r.name).join('\n');
         }), 'no args; Print all renderers in selected world');
@@ -236,6 +271,53 @@ export class GgWorld {
         }), 'args: [ int?, avg|peak? ]; Measure how much time was spent per ' +
             'entity in world. Arguments are samples amount (20 by default) and "peak" or "avg" choice, both arguments are ' +
             'optional. "avg" report sorts entities by average time consumed, "peak" records highest value for each entity');
+        ggstatic.registerConsoleCommand(this, 'entities', (...args) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const filter = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const list = this.children.filter(e => !filter || e.name.toLowerCase().includes(filter));
+            if (list.length === 0) {
+                return '<span style="color:#aaa">(no entities)</span>';
+            }
+            return list
+                .map(e => `<span style='color:yellow'>${e.name}</span>\t<span style='color:#aaa'>${e.constructor.name}</span>`)
+                .join('\n');
+        }), 'args: [ string? ]; List all entities in this world (name and class), optionally filtered by ' +
+            'a case-insensitive substring of the name. Use "entity <name>" to inspect one of them');
+        ggstatic.registerConsoleCommand(this, 'entity', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const name = args[0];
+            if (!name) {
+                throw new Error('usage: entity <name>; use "entities" to list available names');
+            }
+            const entity = this.getEntityByName(name);
+            const lines = [
+                `class: ${entity.constructor.name}`,
+                `active: ${entity.active}`,
+                `parent: ${entity.parent ? entity.parent.name : '(none)'}`,
+            ];
+            if ('visible' in entity) {
+                lines.push(`visible: ${entity.visible}`);
+            }
+            if ('position' in entity) {
+                lines.push(`position: ${JSON.stringify(entity.position)}`);
+            }
+            if ('rotation' in entity) {
+                lines.push(`rotation: ${JSON.stringify(entity.rotation)}`);
+            }
+            lines.push(`children: ${entity.children.length === 0 ? '(none)' : entity.children.map(c => c.name).join(', ')}`);
+            return lines.join('\n');
+        }), 'args: [ string ]; Print class, position/rotation (if any) and children of one entity. Use ' +
+            '"entities" to list available names, "set_position"/"set_rotation" to move it');
+        ggstatic.registerConsoleCommand(this, 'remove', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const name = args[0];
+            if (!name) {
+                throw new Error('usage: remove <name> [dispose=0|1]');
+            }
+            const entity = this.getEntityByName(name);
+            const dispose = args[1] === undefined ? true : args[1] === '1';
+            this.removeEntity(entity, dispose);
+            return `removed "${name}"`;
+        }), 'args: [ string, 0|1? ]; Remove the named entity from this world, disposing it by default. ' +
+            'Pass 0 as second arg to detach without disposing (e.g. before re-adding it elsewhere)');
     }
 }
 GgWorld.default_name_counter = 0;

package/dist/base/index.d.ts

@@ -1,3 +1,6 @@
+export * from './blueprint/blueprint';
+export * from './blueprint/blueprint-node';
+export * from './blueprint/nodes/remove-entity.node';
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
@@ -14,6 +17,7 @@ export * from './data-structures/bitmask';
 export * from './data-structures/graph';
 export * from './entities/controllers/animation-mixer';
 export * from './entities/controllers/inline-controller';
+export * from './entities/group.entity';
 export * from './entities/i-entity';
 export * from './entities/i-renderer.entity';
 export * from './entities/i-renderable.entity';
@@ -36,3 +40,4 @@ export * from './math/matrix4';
 export * from './math/splines';
 export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';
+export * from './level-loader';

package/dist/base/index.js

@@ -1,3 +1,6 @@
+export * from './blueprint/blueprint';
+export * from './blueprint/blueprint-node';
+export * from './blueprint/nodes/remove-entity.node';
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
@@ -14,6 +17,7 @@ export * from './data-structures/bitmask';
 export * from './data-structures/graph';
 export * from './entities/controllers/animation-mixer';
 export * from './entities/controllers/inline-controller';
+export * from './entities/group.entity';
 export * from './entities/i-entity';
 export * from './entities/i-renderer.entity';
 export * from './entities/i-renderable.entity';
@@ -36,3 +40,4 @@ export * from './math/matrix4';
 export * from './math/splines';
 export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';
+export * from './level-loader';

package/dist/base/inputs/mouse.input.js

@@ -10,6 +10,7 @@ const DEFAULT_MOUSE_INPUT_OPTIONS = {
  */
 export var MouseInputState;
 (function (MouseInputState) {
+    //MouseInputState {
     /**
      No mouse or touch input is detected. Mouse move can still be emitted
      */

package/dist/base/level-loader.d.ts

@@ -0,0 +1,217 @@
+import { GgWorld, GgWorldTypeDocRepo } from './gg-world';
+import { GroupEntity } from './entities/group.entity';
+import { BlueprintJson, BlueprintNodeFactory } from './blueprint/blueprint';
+/**
+ * A function that turns per-entity JSON settings into a spawned `IEntity` (e.g. a primitive body,
+ * a trigger, a camera). Registered against a class alias via {@link LevelLoader.registerClass}.
+ * May be `async`/return a `Promise` (e.g. the built-in `"Glb"` 3D class, which fetches a model) -
+ * {@link LevelLoader.loadLevel} awaits every generator before moving to the next entity. A
+ * generator that returns anything other than an `IEntity` (including `null`/`undefined`) has its
+ * result discarded - see {@link LevelLoader.loadLevel}.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ * @template Settings - The settings object type
+ * @template W - The world type
+ */
+export type EntityGenerator<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R>, Settings = any, W = GgWorld<D, R, TypeDoc>> = (world: W, settings: Settings) => any;
+/**
+ * A level/scene, serializable as a single JSON document (e.g. to be hosted as a static file and
+ * loaded via {@link LevelLoader.loadLevelFromUrl}).
+ */
+export interface LevelJson {
+    /**
+     * Entities in the level
+     */
+    entities: EntityJson[];
+    /**
+     * Blueprint graphs available to this level's entities, keyed by name - referenced from an
+     * `EntityJson.events` entry to run a blueprint whenever the named observable on that entity
+     * fires. See {@link BlueprintJson} and the `gg-engine-level-json` skill's "Blueprints" section.
+     */
+    blueprints?: Record<string, BlueprintJson>;
+}
+/**
+ * JSON description of a single entity in a level. `position`/`rotation` are left untyped here
+ * since their shape depends on the dimensionality (`Point2`/`number` for 2D, `Point3`/`Point4`
+ * for 3D) of whichever `LevelLoader` subclass parses this JSON.
+ */
+export interface EntityJson {
+    /**
+     * Class alias for the entity, matching a class registered via `registerClass`. Built-in
+     * primitive shapes (box/sphere/square/circle/...) all share the single `"Primitive"` alias and
+     * are distinguished by `shape` instead of by a per-shape class - e.g. `{ class: "Primitive",
+     * shape: "BOX" }` rather than `{ class: "BOX" }`. Apps register their own aliases (e.g.
+     * `"ShapeSpawner"`) the same way the dimensionality-specific `LevelLoader` subclasses register
+     * their built-ins, via `registerClass`.
+     */
+    class: string;
+    /**
+     * Shape identifier for the built-in `"Primitive"` entity class (e.g. `"Box"`, `"Circle"`) - see
+     * the dimensionality-specific `LevelLoader` subclass (`Gg2dLevelLoader`/`Gg3dLevelLoader`) for
+     * the supported values. Ignored for any other `class`.
+     */
+    shape?: string;
+    /**
+     * Position of the entity
+     */
+    position?: any;
+    /**
+     * Rotation of the entity
+     */
+    rotation?: any;
+    /**
+     * Name of the entity. `loadLevel` sets the generator's returned `IEntity`'s `.name` to this
+     * (overriding whatever default the generator gave it), so it can be found afterwards with
+     * `GgWorld.getEntityByName`/`IEntity.getChildEntityByName`. Moot if the generator doesn't return
+     * an `IEntity` - that result is discarded (with a console warning) before naming is applied.
+     */
+    name?: string;
+    /**
+     * Configuration for the entity, passed to its generator alongside position/rotation/name
+     */
+    config?: any;
+    /**
+     * Maps an observable property name on this entity's generated `IEntity` (e.g. `Trigger3dEntity`'s
+     * `"onEntityEntered"`) to what should run whenever that observable fires - see
+     * {@link EntityEventBinding}. `loadLevel` subscribes to the observable and triggers a fresh
+     * `Blueprint` instance (via its `"in"` entry point) with whatever value it emits, each time it
+     * fires - see `LevelLoader.loadLevel` and the `gg-engine-level-json` skill's "Blueprints"
+     * section. Silently ignored (with a console warning) if the binding can't be resolved to a
+     * blueprint, or the named property isn't an `Observable`.
+     */
+    events?: Record<string, EntityEventBinding>;
+}
+/**
+ * What an `EntityJson.events` entry runs. Either:
+ * - a plain `string` - first tried as a key into the level's top-level `blueprints` map (a named,
+ *   possibly multi-node graph); if not found there, tried as a blueprint node type alias
+ *   registered via `registerBlueprintNode` (e.g. the built-in `"RemoveEntity"`) instead, with no
+ *   settings - shorthand for the single-node form below with `settings` omitted.
+ * - `{ type, settings? }` - a single built-in/registered blueprint node used directly as the
+ *   handler, with inline `settings`, no `blueprints` entry needed at all - e.g.
+ *   `{ "type": "RemoveEntity", "settings": { "dispose": true } }`. Only node types registered with
+ *   a default input pin (every built-in one is - see `registerBlueprintNode`) support this form;
+ *   others require a full graph declared in `blueprints` instead, addressing the desired input pin
+ *   explicitly via `inputs`.
+ */
+export type EntityEventBinding = string | {
+    type: string;
+    settings?: Record<string, any>;
+};
+/**
+ * Base class for level loaders: parses a {@link LevelJson} document into world entities by
+ * dispatching each `EntityJson.class` to a generator function registered with {@link registerClass}.
+ *
+ * A generator is required to return an `IEntity`. Every `IEntity` a generator produces is parented
+ * under one {@link GroupEntity} per `loadLevel`/`loadLevelFromUrl` call (added to the world
+ * immediately, and handed back once loading completes) - so a whole level can be torn down in one
+ * shot with `world.removeEntity(level, true)`, which cascades removal/disposal to every child, and
+ * any named entity can be found afterwards with `level.getChildEntityByName(name)`. If a generator
+ * returns anything other than an `IEntity` (including `null`/`undefined`), `loadLevel` logs a
+ * `console.warn` and skips that entity - it's never parented, named, or tracked.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export declare abstract class LevelLoader<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R>> {
+    protected readonly world: GgWorld<D, R, TypeDoc>;
+    /**
+     * Map of class aliases to generator functions
+     */
+    protected generators: Map<string, EntityGenerator<D, R, TypeDoc, any, any>>;
+    /**
+     * Map of blueprint node type aliases to node factory functions - see {@link registerBlueprintNode}.
+     */
+    protected blueprintNodes: Map<string, BlueprintNodeFactory<D, R, TypeDoc>>;
+    /**
+     * Map of blueprint node type aliases to their default input pin name, for node types registered
+     * with one - see {@link registerBlueprintNode}.
+     */
+    protected blueprintNodeDefaultInputs: Map<string, string>;
+    /**
+     * Constructor
+     * @param world - The world instance
+     */
+    constructor(world: GgWorld<D, R, TypeDoc>);
+    /**
+     * Register a generator function for a class alias
+     * @param classAlias - The class alias
+     * @param generator - The generator function
+     */
+    registerClass<Settings, W = any>(classAlias: string, generator: EntityGenerator<D, R, TypeDoc, Settings, W>): void;
+    /**
+     * Register a {@link BlueprintNode} factory for a node type alias, so a `BlueprintJson`'s
+     * `nodes` can reference it by `type` (e.g. the built-in `"RemoveEntity"`, registered by every
+     * `LevelLoader` out of the box). Same pattern as {@link registerClass}, one level down (node
+     * types within a blueprint graph, rather than entity classes within a level).
+     * @param typeAlias - The node type alias
+     * @param factory - Builds a node instance from its baked-in settings
+     * @param defaultInputPin - This node type's sole "trigger me" input pin name, if it has one
+     * canonical one (e.g. `"RemoveEntity"`'s `"entity"`). Enables the node type to be used directly
+     * as an `EntityJson.events` binding (`{ "eventName": "TypeAlias" }` or
+     * `{ "eventName": { "type": "TypeAlias", "settings": {...} } }`) without declaring a full
+     * `BlueprintJson` graph in `blueprints` - see {@link EntityEventBinding}. Omit for a node type
+     * with zero or multiple input pins, or one with no single obviously-correct default; it remains
+     * usable from a full graph either way.
+     */
+    registerBlueprintNode(typeAlias: string, factory: BlueprintNodeFactory<D, R, TypeDoc>, defaultInputPin?: string): void;
+    /**
+     * Load a level from an already-parsed JSON document. Every `IEntity` the level's entities
+     * produce is parented under - and, on failure, torn down along with - the returned
+     * {@link GroupEntity}, already added to the world.
+     * @param levelJson - The level JSON
+     * @param levelName - Optional name for the returned group entity (e.g. so a debugger/console
+     * listing entities by name shows something more meaningful than the default auto-generated one)
+     * @returns The level's root group entity
+     */
+    loadLevel(levelJson: LevelJson, levelName?: string): Promise<GroupEntity<D, R, TypeDoc>>;
+    /**
+     * Resolve `eventBinding` (see {@link EntityEventBinding}) to a `BlueprintJson`, instantiate a
+     * fresh `Blueprint` from it, and subscribe it to `entity[eventName]` so every value that
+     * observable emits triggers the blueprint's `"in"` entry point. Wrapped in a
+     * `BlueprintBindingEntity` so the subscription (and the blueprint's own node state) is torn down
+     * automatically once that entity is disposed - the caller parents the returned entity under the
+     * level's group for that reason.
+     * @param entity - The entity carrying the observable property
+     * @param eventName - Name of the observable property on `entity`
+     * @param eventBinding - What to run - a `blueprints` name, a bare node type alias, or `{ type,
+     * settings? }`
+     * @param blueprints - The level's top-level blueprint map, if any
+     * @returns The binding entity to parent under the level, or `undefined` if `eventBinding`
+     * couldn't be resolved or the named property isn't an `Observable` (both logged via
+     * `console.warn`)
+     */
+    private bindEvent;
+    /**
+     * Turn an `EntityEventBinding` into a `BlueprintJson` to run. An object form (`{ type,
+     * settings? }`) always builds a single-node inline graph via {@link inlineNodeBlueprint}. A
+     * string form is tried first as a key into `blueprints` (a named, possibly multi-node graph),
+     * then - if not found there - as a bare node type alias, same as the object form with no
+     * settings.
+     * @param eventName - Name of the observable property being bound, for warning messages
+     * @param eventBinding - The binding to resolve
+     * @param blueprints - The level's top-level blueprint map, if any
+     * @returns The resolved graph, or `undefined` (logged via `console.warn`) if it couldn't be
+     */
+    private resolveEventBlueprint;
+    /**
+     * Build a single-node `BlueprintJson` wrapping one blueprint node type, wired so the node's
+     * registered default input pin (see {@link registerBlueprintNode}) is reachable as `"in"` - what
+     * powers the `EntityEventBinding` shorthand that skips declaring a `blueprints` entry entirely.
+     * @param eventName - Name of the observable property being bound, for warning messages
+     * @param nodeType - The blueprint node type alias
+     * @param settings - Settings to bake into the node, if any
+     * @returns The single-node graph, or `undefined` (logged via `console.warn`) if `nodeType` isn't
+     * registered, or was registered without a default input pin
+     */
+    private inlineNodeBlueprint;
+    /**
+     * Fetch a level JSON document hosted at `url` and load it, so a whole level/scene can be
+     * shipped and consumed as a single static JSON file.
+     * @param url - URL (or path) of the level JSON document
+     * @param levelName - Optional name for the returned group entity, see {@link loadLevel}
+     * @returns The level's root group entity
+     */
+    loadLevelFromUrl(url: string, levelName?: string): Promise<GroupEntity<D, R, TypeDoc>>;
+}