@e-mc/types 0.2.0 → 0.3.1

package/constant.d.ts

@@ -168,8 +168,8 @@ export const enum PACKAGE_NAME {
     DB = '@e-mc/db',
     DB_POOL = '@e-mc/db/pool',
     DOCUMENT = '@e-mc/document',
-    DOCUMENT_ANDROID = '@e-mc/document/android',
-    DOCUMENT_CHROME = '@e-mc/document/chrome',
+    DOCUMENT_ANDROID = '@e-mc2/android',
+    DOCUMENT_CHROME = '@e-mc2/chrome',
     DOCUMENT_TRANSFORM = '@e-mc/document/transform',
     DOCUMENT_UTIL = '@e-mc/document/util',
     FILE_MANAGER = '@e-mc/file-manager',

package/index.d.ts

@@ -210,18 +210,20 @@ declare namespace types {
     }
 
     const WATCH_EVENT: {
-        MODIFIED: string;
-        BROADCAST: string;
-        CLOSE: string;
-        ERROR: string;
+        MODIFIED: "modified";
+        BROADCAST: "broadcast";
+        CLOSE: "close";
+        ERROR: "error";
     };
 
     interface THRESHOLD {
+        FILEMANAGER_INTERVAL: number;
         WATCH_INTERVAL: number;
         WATCH_CHANGE: number;
     }
 
     const THRESHOLD: {
+        FILEMANAGER_INTERVAL: number;
         WATCH_INTERVAL: number;
         WATCH_CHANGE: number;
     };
@@ -272,7 +274,7 @@ declare namespace types {
     function encryptUTF8(algorithm: CipherGCMTypes, key: BinaryLike, iv: BinaryLike, data: string, encoding?: Encoding): Undef<string>;
     function decryptUTF8(algorithm: CipherGCMTypes, key: BinaryLike, iv: BinaryLike, data: string, encoding?: Encoding): Undef<string>;
     function generateUUID(): string;
-    function validateUUID(value: unknown): value is string;
+    function validateUUID(value: unknown): boolean;
     function randomString(format: string, dictionary?: string): string;
     function errorValue(value: string, hint?: string): Error;
     function errorMessage(title: NumString, value: string, hint?: string): Error;

package/index.js

@@ -253,12 +253,6 @@ var IMPORT_MAP;
     IMPORT_MAP["@squared-functions/db/pool"] = "@e-mc/db/pool";
     IMPORT_MAP["@squared-functions/db/util"] = "@e-mc/db/util";
     IMPORT_MAP["@squared-functions/document"] = "@e-mc/document";
-    IMPORT_MAP["@squared-functions/document/android"] = "@e-mc/document/android";
-    IMPORT_MAP["@squared-functions/document/android/extensions/app/manifest"] = "@e-mc/document/android/extensions/app/manifest";
-    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/dependencies"] = "@e-mc/document/android/extensions/gradle/dependencies";
-    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/settings"] = "@e-mc/document/android/extensions/gradle/settings";
-    IMPORT_MAP["@squared-functions/document/android/extensions/task"] = "@e-mc/document/android/extensions/task";
-    IMPORT_MAP["@squared-functions/document/chrome"] = "@e-mc/document/chrome";
     IMPORT_MAP["@squared-functions/document/parse"] = "@e-mc/document/parse";
     IMPORT_MAP["@squared-functions/document/parse/dom"] = "@e-mc/document/parse/dom";
     IMPORT_MAP["@squared-functions/document/transform"] = "@e-mc/document/transform";
@@ -266,16 +260,22 @@ var IMPORT_MAP;
     IMPORT_MAP["@squared-functions/document/util"] = "@e-mc/document/util";
     IMPORT_MAP["@squared-functions/file-manager"] = "@e-mc/file-manager";
     IMPORT_MAP["@squared-functions/file-manager/http/host"] = "@e-mc/request/http/host";
-    IMPORT_MAP["@squared-functions/image/jimp"] = "@e-mc2/jimp";
-    IMPORT_MAP["@squared-functions/image/jimp/util"] = "@e-mc2/jimp/util";
     IMPORT_MAP["@squared-functions/image-v3"] = "@e-mc/image";
-    IMPORT_MAP["@squared-functions/image-v3/jimp"] = "@e-mc2/jimp";
     IMPORT_MAP["@squared-functions/module"] = "@e-mc/module";
     IMPORT_MAP["@squared-functions/task"] = "@e-mc/task";
-    IMPORT_MAP["@squared-functions/task/gulp"] = "@e-mc2/gulp";
     IMPORT_MAP["@squared-functions/types"] = "@e-mc/types";
     IMPORT_MAP["@squared-functions/watch"] = "@e-mc/watch";
     IMPORT_MAP["@squared-functions/watch/filegroup"] = "@e-mc/watch/filegroup";
+    IMPORT_MAP["@squared-functions/document/android"] = "@e-mc2/android";
+    IMPORT_MAP["@squared-functions/document/android/extensions/app/manifest"] = "@e-mc2/android/extensions/app/manifest";
+    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/dependencies"] = "@e-mc2/android/extensions/gradle/dependencies";
+    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/settings"] = "@e-mc2/android/extensions/gradle/settings";
+    IMPORT_MAP["@squared-functions/document/android/extensions/task"] = "@e-mc2/android/extensions/task";
+    IMPORT_MAP["@squared-functions/document/chrome"] = "@e-mc2/chrome";
+    IMPORT_MAP["@squared-functions/image/jimp"] = "@e-mc2/jimp";
+    IMPORT_MAP["@squared-functions/image/jimp/util"] = "@e-mc2/jimp/util";
+    IMPORT_MAP["@squared-functions/image-v3/jimp"] = "@e-mc2/jimp";
+    IMPORT_MAP["@squared-functions/task/gulp"] = "@e-mc2/gulp";
     IMPORT_MAP["@squared-functions/cloud/atlas"] = "@e-mc2/atlas";
     IMPORT_MAP["@squared-functions/cloud/aws"] = "@e-mc2/aws";
     IMPORT_MAP["@squared-functions/cloud/aws/download"] = "@e-mc2/aws/download";
@@ -325,6 +325,7 @@ var IMPORT_MAP;
 })(IMPORT_MAP = exports.IMPORT_MAP || (exports.IMPORT_MAP = {}));
 var THRESHOLD;
 (function (THRESHOLD) {
+    THRESHOLD[THRESHOLD["FILEMANAGER_INTERVAL"] = 100] = "FILEMANAGER_INTERVAL";
     THRESHOLD[THRESHOLD["WATCH_INTERVAL"] = 500] = "WATCH_INTERVAL";
     THRESHOLD[THRESHOLD["WATCH_CHANGE"] = 100] = "WATCH_CHANGE";
 })(THRESHOLD = exports.THRESHOLD || (exports.THRESHOLD = {}));

package/lib/compat-v4.d.ts

@@ -26,7 +26,7 @@ export interface IModuleLibV4 {
     isPlainObject<T = PlainObject>(value: unknown): value is T;
     escapePattern(value: unknown, lookBehind?: boolean): string;
     generateUUID(format?: string, dictionary?: string): string;
-    validateUUID(value: unknown): value is string;
+    validateUUID(value: unknown): boolean;
     cloneObject<T, U = unknown>(data: T, options?: boolean | WeakSet<object> | CloneObjectOptions<U>): T;
     coerceObject<T = unknown>(data: T, parseString?: FunctionType<unknown, string> | boolean, cache?: boolean): T;
     asFunction<T = unknown, U = FunctionType<Promise<T> | T>>(value: unknown, sync?: boolean): Null<U>;
@@ -44,7 +44,7 @@ export interface IModuleLibV4 {
     getSize(value: string, diskUsed?: boolean): number;
     byteLength(value: BufferContent, encoding?: BufferEncoding): number;
     cleanupStream(target: Readable | Writable, pathname?: string): void;
-    allSettled: AllSettledMethod;
+    allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseSettledResult<U>[]>;
 }
 
 export interface IModuleCompatV4<T extends IHost = IHost> extends IModule<T> {
@@ -119,7 +119,4 @@ export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransfo
 export interface TransformSeriesCompatV4Constructor extends TransformSeriesConstructor {
     readonly prototype: ITransformSeriesCompatV4;
     new(...args: unknown[]): ITransformSeriesCompatV4;
-}
-
-export type SupportedMethod = (major: number, minor?: number, patch?: number, lts?: boolean) => boolean;
-export type AllSettledMethod<T extends boolean = false> = <U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType) => Promise<T extends true ? PromiseFulfilledResult<U>[] : PromiseSettledResult<U>[]>;
+}

package/lib/index.d.ts

@@ -7,7 +7,6 @@ import type { CompressLevel, DataSource, DbDataSource, IncrementalMatch, LogStat
 
 import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from './asset';
 import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload } from './cloud';
-import type { AllSettledMethod, SupportedMethod } from './compat-v4';
 import type { BufferResult, CompressFormat, TryFileCompressor, TryFileResult, TryImageResult } from './compress';
 import type { ClientDbConstructor, HostInitConfig, IAbortComponent, IClient, IClientDb, IPermission, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, ThreadCountStat } from './core';
 import type { BatchQueryResult, DB_TYPE, ExecuteBatchQueryOptions, ExecuteQueryOptions, HandleFailOptions, PoolConfig, ProcessRowsOptions, QueryResult, SQL_COMMAND } from './db';
@@ -15,7 +14,7 @@ import type { AsSourceFileOptions, ConfigOrTransformer, CustomizeOptions as Cust
 import type { AssetContentOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, InstallData, PostFinalizeCallback, ReplaceOptions } from './filemanager';
 import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
 import type { CommandData, CropData, QualityData, ResizeData, RotateData, TransformOptions } from './image';
-import type { ExecCommand, LOG_TYPE, LogArguments, LogComponent, LogDate, LogFailOptions, LogMessageOptions, LogOptions, LogProcessOptions, LogTime, LogType, LogValue, ModuleFormatMessageMethod, ModuleWriteFailMethod, STATUS_TYPE, StatusType } from './logger';
+import type { ExecCommand, LOG_TYPE, LogArguments, LogComponent, LogDate, LogFailOptions, LogMessageOptions, LogOptions, LogProcessOptions, LogTime, LogType, LogValue, STATUS_TYPE, StatusType } from './logger';
 import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, GetTempDirOptions, MoveFileOptions, NormalizeFlags, ParseFunctionOptions, PermissionOptions, ProtocolType, ReadFileCallback, ReadFileOptions, RemoveDirOptions, WriteFileOptions } from './module';
 import type { RequestData, Settings } from './node';
 import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HostConfig, OpenOptions, PostOptions, ProxySettings, ReadExpectType, RequestInit } from './request';
@@ -23,8 +22,6 @@ import type { ClientModule, CloudModule, CloudServiceOptions, CompressModule, Co
 import type { Command, SpawnResult } from './task';
 import type { IFileGroup, ModifiedPostFinalizeListener, SecureOptions, WatchInitResult } from './watch';
 
-import type { DOWNLOAD_TYPE, FILE_TYPE } from '../index';
-
 import type { NoParamCallback, WriteStream } from 'fs';
 import type { SpawnOptions } from 'child_process';
 import type { BrotliCompress, Gzip } from 'zlib';
@@ -198,14 +195,14 @@ declare namespace functions {
         LOG_CLOUD_DELETE: LogMessageOptions;
         LOG_CLOUD_DELAYED: LogMessageOptions;
         finalize(this: T, instance: ICloud<T, U, V>): Promise<unknown>;
-        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, ignoreProcess: boolean): Promise<unknown>;
-        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, contentType?: string, ignoreProcess?: boolean): Promise<unknown>;
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, ignoreProcess: boolean): Promise<unknown>[];
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, contentType?: string, ignoreProcess?: boolean): Promise<unknown>[];
         sanitizeAssets<W extends ExternalAsset>(assets: W[]): W[];
         readonly prototype: ICloud<T, U, V>;
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
     }
 
-    interface IDocument<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud> extends IClient<T, V, TransformCallback<T, U>> {
+    interface IDocument<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends IClient<T, V, TransformCallback<T, U>> {
         Db: Null<IDb>;
         assets: U[];
         config: StandardMap;
@@ -241,24 +238,24 @@ declare namespace functions {
         cloudUpload?(state: IScopeOrigin<T, Y>, file: U, url: string, active: boolean): Promise<boolean>;
         cloudFinalize?(state: IScopeOrigin<T, Y>): Promise<unknown[]>;
         watchInit?(watch: IFileGroup<U>, assets: U[], sanitize?: boolean): Undef<WatchInitResult>;
-        watchModified?: ModifiedPostFinalizeListener<U>;
+        watchModified?(watch: IFileGroup<U>, assets?: U[]): PostFinalizeCallback;
         set dataSource(value: DataSource[]);
         get dataSource(): DataSource[];
         get watching(): boolean;
     }
 
-    interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule> extends ModuleConstructor {
-        finalize(this: T, instance: IDocument<T, U, V>): Promise<unknown>;
+    interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends ModuleConstructor {
+        finalize(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
         createSourceMap(code: string, remove: boolean): SourceMap;
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): Undef<string>;
         updateGradle(source: string, namespaces: string[], value: string, options?: UpdateGradleOptions | boolean): string;
         generateLintTable(messages: LintMessage[], options: GenerateLintTableOptions): LogComponent[];
-        using?(this: T, instance: IDocument<T, U, V>, file: U): Promise<unknown>;
-        cleanup?(this: T, instance: IDocument<T, U, V>): Promise<unknown>;
+        using?(this: T, instance: IDocument<T, U, V, W, X, Y>, file: U): Promise<unknown>;
+        cleanup?(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
         sanitizeAssets?(assets: U[], exclusions?: U[]): U[];
-        readonly prototype: IDocument<T, U, V>;
-        new(module?: V, ...args: unknown[]): IDocument<T, U, V>;
+        readonly prototype: IDocument<T, U, V, W, X, Y>;
+        new(module?: V, ...args: unknown[]): IDocument<T, U, V, W, X, Y>;
     }
 
     interface IWatch<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends IClient<T, V, W> {
@@ -390,7 +387,7 @@ declare namespace functions {
         rename(file: T, value: string): boolean;
         performAsyncTask(): void;
         removeAsyncTask(): void;
-        completeAsyncTask(err?: unknown, uri?: string, parent?: T, type?: FILE_TYPE): void;
+        completeAsyncTask(err?: unknown, uri?: string, parent?: T, type?: number): void;
         performFinalize(override?: boolean): void;
         hasDocument(instance: IModule, document: Undef<StringOfArray>): boolean;
         getDocumentAssets(instance: IModule, condition?: FunctionArgs<[T], boolean>): T[];
@@ -405,8 +402,8 @@ declare namespace functions {
         getProcessTimeout(handler: InstallData): number;
         clearProcessTimeout(): void;
         addDownload(value: number | BufferContent, encoding: BufferEncoding): number;
-        addDownload(value: number | BufferContent, type?: DOWNLOAD_TYPE, encoding?: BufferEncoding): number;
-        getDownload(type?: DOWNLOAD_TYPE): TupleOf<number>;
+        addDownload(value: number | BufferContent, type?: number, encoding?: BufferEncoding): number;
+        getDownload(type?: number): TupleOf<number>;
         transformAsset(data: IFileThread<T>, parent?: T): Promise<void>;
         addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): Undef<string>;
         findMime(file: T, rename?: boolean): Promise<string>;
@@ -448,7 +445,7 @@ declare namespace functions {
         get cleared(): boolean;
 
         /* Set */
-        add(value: string, parent?: T, type?: FILE_TYPE): this;
+        add(value: string, parent?: T, type?: number): this;
         delete(value: string, emptyDir?: boolean): boolean;
         has(value: unknown): value is string;
 
@@ -546,7 +543,7 @@ declare namespace functions {
     interface IModule<T extends IHost = IHost> extends EventEmitter, IAbortComponent {
         readonly status: LogStatus<StatusType>[];
         readonly errors: unknown[];
-        supported: SupportedMethod;
+        supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
         supports(name: string, value?: boolean): boolean;
         getTempDir(options: GetTempDirOptions): string;
         getTempDir(uuidDir: boolean, createDir?: boolean): string;
@@ -591,10 +588,10 @@ declare namespace functions {
         removeDir<U extends Promise<boolean>>(src: string, options: RemoveDirOptions, promises: true): U;
         removeDir<U extends NoParamCallback>(src: string, callback: U): void;
         removeDir<U extends NoParamCallback>(src: string, options: RemoveDirOptions, callback: U): void;
-        allSettled: AllSettledMethod<true>;
-        formatMessage: ModuleFormatMessageMethod;
+        allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseFulfilledResult<U>[]>;
+        formatMessage(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions): void;
         formatFail(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogFailOptions): void;
-        writeFail: ModuleWriteFailMethod;
+        writeFail(value: LogValue, message?: unknown, options?: LogFailOptions | LogType): void;
         writeTimeProcess(title: string, value: string, startTime: LogTime, options?: LogProcessOptions): void;
         writeTimeElapsed(title: string, value: LogValue, startTime: LogTime, options?: LogMessageOptions): void;
         checkPackage(err: unknown, name: Undef<string>, options?: LogFailOptions | LogType): boolean;
@@ -677,9 +674,9 @@ declare namespace functions {
         readonly LOG_TYPE: LOG_TYPE;
         readonly STATUS_TYPE: STATUS_TYPE;
         readonly MAX_TIMEOUT: number;
-        supported: SupportedMethod;
-        formatMessage: ModuleFormatMessageMethod;
-        writeFail: ModuleWriteFailMethod;
+        supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
+        formatMessage(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions): void;
+        writeFail(value: LogValue, message?: unknown, options?: LogFailOptions | LogType): void;
         enabled(key: string, username?: string): boolean;
         parseFunction<U = unknown>(value: unknown, options?: ParseFunctionOptions): Null<FunctionType<Promise<U> | U>>;
         parseFunction<U = unknown>(value: unknown, absolute: boolean, sync?: boolean): Null<FunctionType<Promise<U> | U>>;

package/lib/logger.d.ts

@@ -119,6 +119,4 @@ export type ForegroundColor = typeof IForegroundColor | HexColor;
 export type TextAlign = "left" | "center" | "right";
 export type ErrorOutMethod = (err: Error, data: LogTypeValue, require?: NodeRequire) => void;
 export type BroadcastOutMethod = (value: string, options: LogMessageOptions, require?: NodeRequire) => void;
-export type BroadcastValue = StringOfArray | { value: StringOfArray; stripAnsi?: boolean };
-export type ModuleWriteFailMethod = (value: LogValue, message?: unknown, options?: LogFailOptions | LogType) => void;
-export type ModuleFormatMessageMethod = (type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions) => void;
+export type BroadcastValue = StringOfArray | { value: StringOfArray; stripAnsi?: boolean };

package/lib/settings.d.ts

@@ -243,10 +243,14 @@ export interface RequestSettings extends PurgeAction, PlainObject {
     time_format?: "readable" | "relative" | "none";
 }
 
-export interface WatchModule extends HandlerModule, ServerInfo {
+export interface WatchModule<T = WatchSettings> extends HandlerModule<T>, ServerInfo {
     interval?: NumString;
 }
 
+export interface WatchSettings<T = PlainObject> extends PlainObject {
+    users?: ObjectMap<ObjectMap<T>>;
+}
+
 export interface CompressModule<U = CompressSettings> extends HandlerSettings<U> {
     gzip?: ZlibOptions;
     brotli?: BrotliOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",

package/lib/android.d.ts

@@ -1,53 +0,0 @@
-import type { FinalizedElement, ControllerSettingsDirectoryUI as IControllerSettingsDirectoryUI } from './squared';
-
-import type { ExternalAsset } from './asset';
-import type { RequestData as IRequestData } from './node';
-
-export interface DocumentOutput {
-    targetAPI?: NumString;
-    manifest?: ManifestData;
-    namespace?: string;
-    profileable?: boolean | StringOfArray;
-    dependencies?: string[];
-    directories?: ControllerSettingsDirectoryUI;
-    elements?: FinalizedElement[];
-    projectName?: string;
-    mainParentDir?: string;
-    mainSrcDir?: string;
-    mainActivityFile?: string;
-    javaVersion?: NumString;
-    versionName?: string;
-    versionCode?: number;
-    dataBinding?: boolean;
-    commands?: ArrayOf<StringOfArray>;
-    extensionData?: PlainObject;
-}
-
-export interface RequestData extends IRequestData<ExternalAsset>, DocumentOutput {}
-
-export interface ManifestData {
-    package?: string;
-    application?: {
-        supportsRtl?: boolean;
-        label?: string;
-        theme?: string;
-        metaData?: { name?: string; resource?: string; value?: string }[];
-        activity?: ObjectMap<{
-            layout?: {
-                defaultWidth?: string;
-                defaultHeight?: string;
-                minWidth?: string;
-                minHeight?: string;
-                gravity?: string;
-            };
-        }>;
-        activityName?: string;
-        fontProvider?: string;
-    };
-}
-
-export interface ControllerSettingsDirectoryUI extends IControllerSettingsDirectoryUI {
-    main: string;
-    animation: string;
-    theme: string;
-}

package/lib/chrome.d.ts

@@ -1,106 +0,0 @@
-import type { AttributeAction, ConditionProperty, CssConditionData, ElementAction, ExcludeAction, FileAsset, FromAction, HashAction, DataSource as IDataSource, ImportAction, MetadataAction, ViewEngine, XmlTagNode } from './squared';
-
-import type { UploadAction } from './cloud';
-import type { CascadeAction, DbSource } from './db';
-import type { RequestData as IRequestData } from './node';
-
-interface ImportFrom {
-    placeholder: string;
-    original: string;
-    uri: string;
-    type?: string;
-    dynamic?: boolean;
-}
-
-interface DataObject extends CascadeAction {
-    format?: string;
-    options?: PlainObject;
-}
-
-export interface DocumentOutput {
-    productionRelease?: boolean | string;
-    productionIncremental?: boolean;
-    useOriginalHtmlPage?: boolean | string;
-    useUnsafeReplace?: ArrayOf<"html" | "css"> | boolean;
-    stripCommentsAndCDATA?: boolean | string;
-    normalizeHtmlOutput?: boolean | string;
-    escapeReservedCharacters?: boolean;
-    ignoreServerCodeBlocks?: string[];
-    webBundle?: {
-        rootDirAlias?: string;
-        baseUrl?: string;
-        primaryUrl?: string;
-        copyTo?: string;
-        rewriteHtmlPage?: boolean | string;
-        excludeHtmlPage?: boolean;
-        excludeTransforms?: boolean;
-        includeScopes?: string[];
-        excludeScopes?: string[];
-    };
-    templateMap?: TemplateMap;
-}
-
-export interface RequestData extends IRequestData<ChromeAsset>, Readonly<DocumentOutput>, Readonly<CssRuleData> {}
-
-export interface ChromeAsset extends FileAsset, AttributeAction, ElementAction, MetadataAction<PlainObject>, UploadAction, HashAction, ExcludeAction, ImportAction<ImportFrom[] | boolean>, FromAction {
-    preserve?: boolean;
-    static?: boolean;
-    editing?: boolean;
-    inlineContent?: string;
-    originAddress?: boolean;
-}
-
-export interface TemplateMap extends PlainObject {
-    html?: ObjectMap<StringMap>;
-    js?: ObjectMap<StringMap>;
-    css?: ObjectMap<StringMap>;
-    data?: StringMap;
-}
-
-export interface CssRuleData {
-    usedVariables?: string[];
-    usedFontFace?: string[];
-    usedKeyframes?: string[];
-    unusedStyles?: string[];
-    unusedMedia?: string[];
-    unusedContainer?: string[];
-    unusedSupports?: string[];
-    unusedAtRules?: UnusedAtRule[];
-}
-
-export interface UnusedAtRule {
-    selector?: string;
-    media?: ConditionProperty;
-    supports?: ConditionProperty;
-    container?: CssConditionData & Partial<ConditionProperty>;
-    layer?: string[];
-}
-
-export interface DataSource<T = string> extends IDataSource<T>, ElementAction {
-    source: "cloud" | "uri" | "local" | "export" | DbSource;
-    element?: XmlTagNode;
-    type?: "text" | "attribute" | "display";
-    dynamic?: boolean;
-    value?: StringOfArray | ObjectMap<unknown>;
-    template?: string;
-    viewEngine?: ViewEngine | string;
-    ignoreEmpty?: boolean;
-}
-
-export interface UriDataSource extends DataSource, DataObject {
-    source: "uri";
-}
-
-export interface LocalDataSource extends DataSource, DataObject {
-    source: "local";
-    pathname?: string;
-}
-
-export interface ExportDataSource extends DataSource, CascadeAction {
-    source: "export";
-    execute?: FunctionType;
-    pathname?: string;
-    settings?: string;
-    params?: unknown;
-    persist?: boolean;
-}