@7h3laughingman/foundry-types 13.351.0

package/src/client/utils/helpers.d.mts

@@ -0,0 +1,148 @@
+import Document from "./../../common/abstract/document.mjs";
+import { COMPENDIUM_DOCUMENT_TYPES } from "./../../common/constants.mjs";
+import {
+    Actor,
+    ActorUUID,
+    CompendiumDocument,
+    Item,
+    ItemUUID,
+    TokenDocument,
+    TokenDocumentUUID,
+    User,
+    UserUUID,
+    WorldDocumentUUID,
+} from "./../documents/_module.mjs";
+import { ClientDocument } from "./../documents/abstract/client-document.mjs";
+import { CompendiumIndexData } from "./../documents/collections/compendium-collection.mjs";
+
+/**
+ * Clean a provided HTML fragment, closing unbalanced tags and stripping some undesirable properties
+ * @param raw A raw HTML string
+ * @returns The cleaned HTML content
+ */
+export function cleanHTML(raw: string): string;
+
+/**
+ * Export data content to be saved to a local file
+ * @param data Data content converted to a string
+ * @param type The type of file
+ * @param filename The filename of the resulting download
+ */
+
+export function saveDataToFile(data: string, type: string, filename: string): void;
+
+/**
+ * Read text data from a user provided File object
+ * @param file A File object
+ * @returns A Promise which resolves to the loaded text data
+ */
+export function readTextFromFile(file: File): Promise<string>;
+
+/**
+ * Retrieve a Document by its Universally Unique Identifier (uuid).
+ * @param uuid The uuid of the Document to retrieve.
+ * @param options Options to configure how a UUID is resolved.
+ * @param options.relative A Document to resolve relative UUIDs against.
+ * @param options.invalid Allow retrieving an invalid Document.
+ * @returns Returns the Document if it could be found, otherwise null.
+ */
+export function fromUuid(uuid: CompendiumUUID, relative?: Maybe<ClientDocument>): Promise<CompendiumDocument | null>;
+export function fromUuid(uuid: ActorUUID, relative?: Maybe<ClientDocument>): Promise<Actor | null>;
+export function fromUuid(uuid: ItemUUID, relative?: Maybe<ClientDocument>): Promise<Item | null>;
+export function fromUuid(uuid: TokenDocumentUUID, relative?: Maybe<ClientDocument>): Promise<TokenDocument | null>;
+export function fromUuid<TDocument extends ClientDocument>(uuid: string, relative?: Maybe<ClientDocument>): Promise<TDocument | null>;
+
+export type CompendiumDocumentType = (typeof COMPENDIUM_DOCUMENT_TYPES)[number];
+export type CompendiumUUID = `Compendium.${string}.${CompendiumDocumentType}.${string}`;
+export type DocumentUUID = WorldDocumentUUID | CompendiumUUID | TokenDocumentUUID;
+
+/**
+ * Retrieve a Document by its Universally Unique Identifier (uuid) synchronously. If the uuid resolves to a compendium
+ * document, that document's index entry will be returned instead.
+ * @param uuid The uuid of the Document to retrieve.
+ * @param options Options to configure how a UUID is resolved.
+ * @param options.relative A Document to resolve relative UUIDs against.
+ * @param options.invalid Allow retrieving an invalid Document.
+ * @param options.strict Throw an error if the UUID cannot be resolved synchronously.
+ * @returns The Document or its index entry if it resides in a Compendium, otherwise null.
+ * @throws If the uuid resolves to a Document that cannot be retrieved synchronously, and the strict option is true.
+ */
+export function fromUuidSync<TResult extends User = User>(
+    uuid: UserUUID,
+    options?: {
+        relative?: ClientDocument;
+        invalid?: boolean;
+        strict?: boolean;
+    },
+): TResult | null;
+export function fromUuidSync<TResult extends Actor | CompendiumIndexData = Actor | CompendiumIndexData>(
+    uuid: UserUUID,
+    options?: {
+        relative?: ClientDocument;
+        invalid?: boolean;
+        strict?: boolean;
+    },
+): TResult | null;
+export function fromUuidSync<TResult extends (Document & { name?: string }) | CompendiumIndexData = (ClientDocument & { name?: string }) | CompendiumIndexData>(
+    uuid: string,
+    options?: {
+        relative?: ClientDocument;
+        invalid?: boolean;
+        strict?: boolean;
+    },
+): TResult | null;
+
+/**
+ * Return a reference to the Document class implementation which is configured for use.
+ * @param documentName The canonical Document name, for example "Actor"
+ * @returns The configured Document class implementation
+ */
+export function getDocumentClass(documentName: string): typeof Document | undefined;
+
+/**
+ * Given a source object to sort, a target to sort relative to, and an Array of siblings in the container:
+ * Determine the updated sort keys for the source object, or all siblings if a reindex is required.
+ * Return an Array of updates to perform, it is up to the caller to dispatch these updates.
+ * Each update is structured as:
+ * {
+ *   target: object,
+ *   update: {sortKey: sortValue}
+ * }
+ *
+ * @param source The source object being sorted
+ * @param options Options which modify the sort behavior
+ * @returns An Array of updates for the caller of the helper function to perform
+ */
+export function performIntegerSort<TObject extends object>(
+    source: TObject,
+    options?: SortOptions<TObject>,
+): { target: TObject; update: Record<string, number> }[];
+
+declare interface SortOptions<TObject extends object> {
+    /** The target object relative which to sort */
+    target?: TObject;
+    /** The Array of siblings which the source should be sorted within */
+    siblings?: TObject[];
+    /** The property name within the source object which defines the sort key */
+    sortKey?: string;
+    /**
+     * Explicitly sort before (true) or sort after( false).
+     * If undefined the sort order will be automatically determined.
+     */
+    sortBefore?: boolean;
+}
+
+/**
+ * Express a timestamp as a relative string.
+ * This helper internally uses GameTime#format using the relative formatter and the Earth calendar.
+ * @param timeStamp A timestamp string or Date object to be formatted as a relative time
+ * @returns A string expression for the relative time
+ */
+export function timeSince(timeStamp: Date | string): string;
+
+/**
+ * Parse an HTML string, returning a processed HTMLElement or HTMLCollection.
+ * A single HTMLElement is returned if the provided string contains only a single top-level element.
+ * An HTMLCollection is returned if the provided string contains multiple top-level elements.
+ */
+export function parseHTML<THTML extends HTMLCollection | HTMLElement>(htmlString: string): THTML;

package/src/common/_types.d.mts

@@ -0,0 +1,151 @@
+import { TokenShape } from "./../client/canvas/placeables/token.mjs";
+import { DataModelConstructionContext } from "./abstract/_types.mjs";
+import Document from "./abstract/document.mjs";
+import { GridOffset2D } from "./grid/_types.mjs";
+import Color from "./utils/color.mjs";
+
+/* ----------------------------------------- */
+/*  Data Model                               */
+/* ----------------------------------------- */
+
+export interface DocumentConstructionContext<TParent extends Document | null> extends DataModelConstructionContext<TParent> {
+    /** The compendium collection ID which contains this Document, if any */
+    pack?: string | null;
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | symbol | null | undefined;
+
+/* ----------------------------------------- */
+/*  Reusable Type Definitions                */
+/* ----------------------------------------- */
+
+/**
+ * Make all properties in T recursively readonly.
+ */
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: T[K] extends undefined | null | boolean | number | string | symbol | bigint | Function
+        ? T[K]
+        : T[K] extends Array<infer V>
+          ? ReadonlyArray<DeepReadonly<V>>
+          : T[K] extends Map<infer K, infer V>
+            ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+            : T[K] extends Set<infer V>
+              ? ReadonlySet<DeepReadonly<V>>
+              : DeepReadonly<T[K]>;
+};
+
+/**
+ * A 2D point, expressed as an array [x, y].
+ */
+export interface Point {
+    /** The x-coordinate in pixels */
+    x: number;
+    /** The y-coordinate of the top-left corner */
+    y: number;
+}
+
+/**
+ * A single point, expressed as an array [x,y]
+ */
+export type PointArray = [x: number, y: number];
+
+/**
+ * A 3D point, expessed as {x, y, elevation}.
+ */
+export interface ElevatedPoint extends Point {
+    /** The elevation in grid units */
+    elevation: number;
+}
+
+/**
+ * A standard rectangle interface.
+ */
+interface Rectangle {
+    /** The x-coordinate of the top-left corner */
+    x: number;
+    /** The y-coordinate of the top-left corner */
+    y: number;
+    /** The width */
+    width: number;
+    /** The height */
+    height: number;
+}
+
+type BuiltinTypes = NumberConstructor | StringConstructor | BooleanConstructor;
+
+type ColorSource = number | [red: number, green: number, blue: number] | string | Color;
+
+/* ----------------------------------------- */
+/*  Socket Requests and Responses            */
+/* ----------------------------------------- */
+
+export type RequestData = object | object[] | string | string[];
+
+export interface SocketRequest {
+    /** The type of object being modified */
+    type?: string;
+    /** The server-side action being requested */
+    action?: string;
+    /** Data applied to the operation */
+    data?: RequestData;
+    query?: object;
+    /** The type of parent document */
+    parentType?: string;
+    /** The ID of a parent document */
+    parentId?: string;
+    /** A Compendium pack name */
+    pack?: string | null;
+    /** Additional options applied to the request */
+    options?: object;
+}
+
+export interface SocketResponse {
+    /** The initial request */
+    request: SocketRequest;
+    /** An error, if one occurred */
+    error?: Error;
+    /** The status of the request */
+    status?: string;
+    /** The ID of the requesting User */
+    userId?: string;
+    /** Data returned as a result of the request */
+    result: Record<string, unknown>[];
+}
+
+/* ----------------------------------------- */
+/*  Token Typedefs                           */
+/* ----------------------------------------- */
+
+interface TokenPosition extends ElevatedPoint {
+    /** The width in grid spaces (positive). */
+    width: number;
+    /** The height in grid spaces (positive). */
+    height: number;
+    /** The shape type (see {@link CONST.TOKEN_SHAPES}). */
+    shape: TokenShape;
+}
+
+type TokenDimensions = Pick<TokenPosition, "width" | "height" | "shape">;
+
+interface TokenHexagonalOffsetsData {
+    /** The occupied offsets in an even grid in the 0th row/column */
+    even: GridOffset2D[];
+    /** The occupied offsets in an odd grid in the 0th row/column */
+    odd: GridOffset2D[];
+    /** The anchor in normalized coordiantes */
+    anchor: Point;
+}
+
+/**
+ * The hexagonal shape of a Token.
+ */
+interface TokenHexagonalShapeData {
+    /** The occupied offsets in even/odd rows/columns */
+    offsets: { even: GridOffset2D[]; odd: GridOffset2D[] };
+    /** The points in normalized coordinates */
+    points: number[];
+    /** The center of the shape in normalized coordiantes */
+    center: Point;
+    /** The snapping anchor in normalized coordiantes, i.e. the top-left grid hex center in the snapped position */
+    anchor: Point;
+}

package/src/common/abstract/_module.d.mts

@@ -0,0 +1,8 @@
+export * from "./_types.mjs";
+export { default as DatabaseBackend } from "./backend.mjs";
+export { default as DataModel } from "./data.mjs";
+export * from "./document.mjs";
+export { default as Document } from "./document.mjs";
+export { default as EmbeddedCollection } from "./embedded-collection.mjs";
+export { default as DocumentSocketResponse } from "./socket.mjs";
+export { default as TypeDataModel } from "./type-data.mjs";

package/src/common/abstract/_types.d.mts

@@ -0,0 +1,187 @@
+import { DocumentUUID } from "./../../client/utils/helpers.mjs";
+import { DataField } from "./../data/fields.mjs";
+import { DataModel, Document } from "./_module.mjs";
+
+export type DataSchema = { [K in string]: DataField<JSONValue, unknown> };
+
+export interface DataModelValidationOptions {
+    /** Validate each individual field */
+    fields?: boolean;
+    /**
+     * Perform joint validation on the full data model?
+     * Joint validation will be performed by default if no changes are passed.
+     * Joint validation will be disabled by default if changes are passed.
+     * Joint validation can be performed on a complete set of changes (for example
+     * testing a complete data model) by explicitly passing true.
+     */
+    joint?: boolean;
+    /** A specific set of proposed changes to validate, rather than the full source data of the model. */
+    changes?: object;
+    /**
+     * If changes are provided, attempt to clean the changes before validating them? This option mutates the provided
+     * changes.
+     */
+    clean?: boolean;
+    /** Throw an error if validation fails. */
+    strict?: boolean;
+    /** Allow replacement of invalid values with valid defaults? This option mutates the provided changes. */
+    fallback?: boolean;
+    /**
+     * If true, invalid embedded documents will emit a warning and be placed in the invalidDocuments collection rather
+     * than causing the parent to be considered invalid. This option mutates the provided changes.
+     */
+    dropInvalidEmbedded?: boolean;
+}
+
+interface DataModelConstructionContext<TParent extends DataModel | null> extends Pick<
+    DataModelValidationOptions,
+    "strict" | "fallback" | "dropInvalidEmbedded"
+> {
+    /** A parent DataModel instance to which this DataModel belongs */
+    parent?: TParent;
+    /** Allow partial source data, ignoring absent fields? */
+    partial?: boolean;
+}
+
+export interface DataModelUpdateOptions {
+    /** Do not finally apply the change, but instead simulate the update workflow */
+    dryRun?: boolean;
+
+    /** Allow automatic fallback to a valid initial value if the value provided for a field in the model is invalid. */
+    fallback?: boolean;
+
+    /** Apply changes to inner objects recursively rather than replacing the top-level object. */
+    recursive?: boolean;
+
+    /** An advanced option used specifically and internally by the ActorDelta model */
+    restoreDelta?: boolean;
+}
+
+export interface DatabaseGetOperation<TParent extends Document | null> {
+    action: "get";
+    /** A query object which identifies the set of Documents retrieved */
+    query: Record<string, unknown>;
+    /** Get requests are never broadcast */
+    broadcast?: false;
+    /** Return indices only instead of full Document records */
+    index?: boolean;
+    /** An array of field identifiers which should be indexed */
+    indexFields?: string;
+    /** A compendium collection ID which contains the Documents */
+    pack?: string | null;
+    /** A parent Document within which Documents are embedded */
+    parent?: TParent;
+    /** A parent Document UUID provided when the parent instance is unavailable */
+    parentUuid?: DocumentUUID;
+}
+
+export interface DatabaseCreateOperation<TParent extends Document | null> {
+    action: "create";
+    /** Whether the database operation is broadcast to other connected clients */
+    broadcast: boolean;
+    /** An array of data objects from which to create Documents */
+    data: object[];
+    /** Retain the _id values of provided data instead of generating new ids */
+    keepId?: boolean;
+    /** Retain the _id values of embedded document data instead of generating new ids for each embedded document */
+    keepEmbeddedIds?: boolean;
+    /** The timestamp when the operation was performed */
+    modifiedTime?: number;
+    /** Block the dispatch of hooks related to this operation */
+    noHook?: boolean;
+    /** Re-render Applications whose display depends on the created Documents */
+    render?: boolean;
+    /** Render the sheet Application for any created Documents */
+    renderSheet?: boolean;
+    /** A parent Document within which Documents are embedded */
+    parent?: TParent;
+    /** A compendium collection ID which contains the Documents */
+    pack?: string | null;
+    /** A parent Document UUID provided when the parent instance is unavailable */
+    parentUuid?: DocumentUUID;
+}
+
+export interface DatabaseCreateCallbackOptions extends Omit<Partial<DatabaseCreateOperation<null>>, "action" | "data" | "pack" | "parent" | "noHook"> {}
+
+export interface DatabaseUpdateOperation<TParent extends Document | null> {
+    action: "update";
+    /** Whether the database operation is broadcast to other connected clients */
+    broadcast: boolean;
+    /**
+     * An array of data objects used to update existing Documents.
+     * Each update object must contain the _id of the target Document
+     */
+    updates: object[];
+    /**
+     * Difference each update object against current Document data and only use differential data for the update
+     * operation
+     */
+    diff?: boolean;
+    /** The timestamp when the operation was performed */
+    modifiedTime?: number;
+    /** Merge objects recursively. If false, inner objects will be replaced explicitly. Use with caution! */
+    recursive?: boolean;
+    /** Re-render Applications whose display depends on the created Documents */
+    render?: boolean;
+    /** Block the dispatch of hooks related to this operation */
+    noHook?: boolean;
+    /** A parent Document within which Documents are embedded */
+    parent?: TParent;
+    /** A compendium collection ID which contains the Documents */
+    pack?: string | null;
+    /** A parent Document UUID provided when the parent instance is unavailable */
+    parentUuid?: DocumentUUID;
+}
+
+export interface DatabaseUpdateCallbackOptions extends Omit<
+    Partial<DatabaseUpdateOperation<null>>,
+    "action" | "pack" | "parent" | "restoreDelta" | "noHook" | "updates"
+> {}
+
+export interface DatabaseDeleteOperation<TParent extends Document | null> {
+    action: "delete";
+    /** Whether the database operation is broadcast to other connected clients */
+    broadcast: boolean;
+    /** An array of Document ids which should be deleted */
+    ids: string[];
+    /** Delete all documents in the Collection, regardless of _id */
+    deleteAll?: boolean;
+    /** The timestamp when the operation was performed */
+    modifiedTime?: number;
+    /** Block the dispatch of hooks related to this operation */
+    noHook?: boolean;
+    /** Re-render Applications whose display depends on the created Documents */
+    render?: boolean;
+    /** A parent Document within which Documents are embedded */
+    parent?: TParent;
+    /** A compendium collection ID which contains the Documents */
+    pack?: string | null;
+    /** A parent Document UUID provided when the parent instance is unavailable */
+    parentUuid?: DocumentUUID;
+}
+
+export interface DatabaseDeleteCallbackOptions extends Omit<
+    Partial<DatabaseDeleteOperation<null>>,
+    "action" | "deleteAll" | "ids" | "pack" | "parent" | "noHook"
+> {}
+
+export type DatabaseAction = "get" | "create" | "update" | "delete";
+
+export type DatabaseOperation<TParent extends Document | null> =
+    | DatabaseGetOperation<TParent>
+    | DatabaseCreateOperation<TParent>
+    | DatabaseUpdateOperation<TParent>
+    | DatabaseDeleteOperation<TParent>;
+
+export interface DocumentSocketRequest {
+    /** The type of Document being transacted */
+    type: string;
+    /** The action of the request */
+    action: DatabaseAction;
+    /** Operation parameters for the request */
+    operation: DatabaseOperation<Document | null>;
+    /** The id of the requesting User */
+    userId: string;
+    /** Should the response be broadcast to other connected clients? */
+    broadcast: boolean;
+}

package/src/common/abstract/backend.d.mts

@@ -0,0 +1,159 @@
+import { CompendiumIndexData } from "./../../client/documents/collections/compendium-collection.mjs";
+import BaseUser from "./../documents/user.mjs";
+import { DatabaseCreateOperation, DatabaseDeleteOperation, DatabaseGetOperation, DatabaseOperation, DatabaseUpdateOperation, Document } from "./_module.mjs";
+
+/**
+ * An interface shared by both the client and server-side which defines how creation, update, and deletion operations are transacted.
+ */
+export default abstract class DatabaseBackend {
+    /* -------------------------------------------- */
+    /*  Get Operations                              */
+    /* -------------------------------------------- */
+
+    /**
+     * Retrieve Documents based on provided query parameters
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the get operation
+     * @param [user]        The requesting User
+     * @returns An array of retrieved Document instances or index objects
+     */
+    get<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseGetOperation<TDocument["parent"] | null>,
+        user?: BaseUser,
+    ): Promise<CompendiumIndexData[] | TDocument[]>;
+
+    protected _getDocuments<TDocument extends Document>(
+        documentClass: AbstractConstructorOf<TDocument>,
+        operation: DatabaseGetOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /* -------------------------------------------- */
+    /*  Create Operations                           */
+    /* -------------------------------------------- */
+
+    create<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseCreateOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /**
+     * Create Document instances using provided data and operation parameters.
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the get operation
+     * @param user          The requesting User
+     * @returns An array of retrieved Document instances or index objects
+     */
+    protected abstract _createDocuments<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseCreateOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<(CompendiumIndexData | TDocument)[]>;
+
+    /* -------------------------------------------- */
+    /*  Update Operations                           */
+    /* -------------------------------------------- */
+
+    /**
+     * Update Documents using provided data and context.
+     * It is recommended to use {@link Document.updateDocuments} or {@link Document#update} rather than calling this
+     * method directly.
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the update operation
+     * @param user          The requesting User
+     * @returns An array of updated Document instances
+     */
+    update<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseUpdateOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /**
+     * Update Document instances using provided data and operation parameters.
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the update operation
+     * @param user          The requesting User
+     * @returns An array of updated Document instances
+     */
+    protected abstract _updateDocuments<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseUpdateOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /* -------------------------------------------- */
+    /*  Delete Operations                           */
+    /* -------------------------------------------- */
+
+    /**
+     * Delete Documents using provided ids and context.
+     * It is recommended to use {@link Document.deleteDocuments} or {@link Document#delete} rather than calling this
+     * method directly.
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the delete operation
+     * @param user          The requesting User
+     * @returns An array of deleted Document instances
+     */
+    delete<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseDeleteOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /**
+     * Delete Document instances using provided ids and operation parameters.
+     * @param documentClass The Document class definition
+     * @param operation     Parameters of the delete operation
+     * @param [user]        The requesting User
+     * @returns An array of deleted Document instances
+     */
+    protected abstract _deleteDocuments<TDocument extends Document>(
+        documentClass: ConstructorOf<TDocument>,
+        operation: DatabaseDeleteOperation<TDocument["parent"]>,
+        user: BaseUser,
+    ): Promise<TDocument[]>;
+
+    /* -------------------------------------------- */
+    /*  Helper Methods                              */
+    /* -------------------------------------------- */
+
+    /**
+     * Get the parent Document (if any) associated with a request context.
+     * @param operation The requested database operation
+     * @returns The parent Document, or null
+     * @internal
+     */
+    protected _getParent(operation: DatabaseOperation<Document | null>): Promise<Document | null>;
+
+    /**
+     * Describe the scopes which are suitable as the namespace for a flag key
+     */
+    abstract getFlagScopes(): string[];
+
+    /**
+     * Describe the scopes which are suitable as the namespace for a flag key
+     */
+    abstract getCompendiumScopes(): string[];
+
+    /**
+     * Log a database operation for an embedded document, capturing the action taken and relevant IDs
+     * @param action         The action performed
+     * @param type           The document type
+     * @param documents      The documents modified
+     * @param options
+     * @param options.level  The logging level
+     * @param options.parent A parent document
+     * @param options.pack   A compendium pack within which the operation occurred
+     */
+    protected _logOperation(action: string, type: string, documents: Document[], options?: { level?: string; parent?: Document; pack: string }): void;
+
+    /**
+     * Construct a standardized error message given the context of an attempted operation
+     */
+    protected _logError(user: BaseUser, action: string, subject: string, options?: { parent: Document; pack?: string }): string;
+
+    protected abstract _log(level: string, message: string): void;
+}