@nice2dev/game-engine 0.1.0

package/dist/types/editor/NiceGameEditor.d.ts

@@ -0,0 +1,115 @@
+import React from 'react';
+import type { GameProject, EntityId } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import { World } from '../ecs/World';
+import { SceneManager } from '../scene/SceneManager';
+export interface UndoEntry {
+    description: string;
+    undo: () => void;
+    redo: () => void;
+}
+export declare class UndoStack {
+    private stack;
+    private pointer;
+    readonly maxSize: number;
+    readonly events: EventBus;
+    constructor(maxSize?: number);
+    push(entry: UndoEntry): void;
+    undo(): string | null;
+    redo(): string | null;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    clear(): void;
+}
+export type EditorTool = 'select' | 'move' | 'rotate' | 'scale' | 'pan';
+export type EditorMode = 'edit' | 'play' | 'pause';
+export interface EditorPanel {
+    id: string;
+    title: string;
+    visible: boolean;
+    position: 'left' | 'right' | 'bottom' | 'floating';
+    width?: number;
+    height?: number;
+}
+export interface EditorState {
+    mode: EditorMode;
+    tool: EditorTool;
+    selectedEntities: EntityId[];
+    clipboard: EntityId[];
+    gridSize: number;
+    snapToGrid: boolean;
+    showGrid: boolean;
+    showRulers: boolean;
+    zoom: number;
+    panOffset: {
+        x: number;
+        y: number;
+    };
+    panels: EditorPanel[];
+    currentSceneId: string | null;
+    projectPath: string | null;
+    dirty: boolean;
+}
+type EditorAction = {
+    type: 'SET_MODE';
+    mode: EditorMode;
+} | {
+    type: 'SET_TOOL';
+    tool: EditorTool;
+} | {
+    type: 'SELECT';
+    entities: EntityId[];
+} | {
+    type: 'ADD_SELECTION';
+    entities: EntityId[];
+} | {
+    type: 'DESELECT_ALL';
+} | {
+    type: 'SET_CLIPBOARD';
+    entities: EntityId[];
+} | {
+    type: 'SET_GRID_SIZE';
+    size: number;
+} | {
+    type: 'TOGGLE_SNAP';
+} | {
+    type: 'TOGGLE_GRID';
+} | {
+    type: 'SET_ZOOM';
+    zoom: number;
+} | {
+    type: 'SET_PAN';
+    offset: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'TOGGLE_PANEL';
+    panelId: string;
+} | {
+    type: 'SET_SCENE';
+    sceneId: string | null;
+} | {
+    type: 'MARK_DIRTY';
+} | {
+    type: 'MARK_CLEAN';
+};
+export interface EditorContextValue {
+    state: EditorState;
+    dispatch: React.Dispatch<EditorAction>;
+    world: World;
+    undoStack: UndoStack;
+    sceneManager: SceneManager;
+    events: EventBus;
+}
+export declare function useEditor(): EditorContextValue;
+export declare function serializeProject(project: GameProject): string;
+export declare function deserializeProject(json: string): GameProject;
+export interface NiceGameEditorProps {
+    project?: GameProject;
+    onSave?: (project: GameProject) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const NiceGameEditor: React.FC<NiceGameEditorProps>;
+export {};

package/dist/types/editor/SceneEditor.d.ts

@@ -0,0 +1,37 @@
+import type { Vec2, Rect, EntityId } from '../core/types';
+import { World, type Entity } from '../ecs/World';
+import { Camera2D } from '../rendering/Camera2D';
+export type GizmoMode = 'translate' | 'rotate' | 'scale';
+export type GizmoAxis = 'x' | 'y' | 'xy' | 'none';
+export interface GizmoState {
+    mode: GizmoMode;
+    activeAxis: GizmoAxis;
+    dragging: boolean;
+    startWorld: Vec2;
+    startLocal: Vec2;
+    delta: Vec2;
+}
+export declare function createGizmoState(mode?: GizmoMode): GizmoState;
+export interface SelectionBox {
+    active: boolean;
+    start: Vec2;
+    end: Vec2;
+}
+export declare function getSelectionRect(box: SelectionBox): Rect;
+export declare function entitiesInRect(world: World, rect: Rect): EntityId[];
+export declare function snapToGrid(value: number, gridSize: number): number;
+export declare function snapVec2ToGrid(v: Vec2, gridSize: number): Vec2;
+export declare function renderGrid(ctx: CanvasRenderingContext2D, camera: Camera2D, canvasW: number, canvasH: number, gridSize: number, color?: string, majorColor?: string, majorEvery?: number): void;
+export declare function renderTranslateGizmo(ctx: CanvasRenderingContext2D, screenPos: Vec2, activeAxis: GizmoAxis, size?: number): void;
+export declare function renderRotateGizmo(ctx: CanvasRenderingContext2D, screenPos: Vec2, active: boolean, radius?: number): void;
+export declare function renderScaleGizmo(ctx: CanvasRenderingContext2D, screenPos: Vec2, activeAxis: GizmoAxis, size?: number): void;
+export declare function hitTestGizmoAxis(screenPos: Vec2, cursorScreen: Vec2, size?: number, threshold?: number): GizmoAxis;
+export declare function pickEntityAt(world: World, worldPos: Vec2, margin?: number): Entity | null;
+export interface ClipboardEntry {
+    entityId: EntityId;
+    /** Deep-cloned component data snapshot. */
+    components: Record<string, unknown>;
+    position: Vec2;
+}
+export declare function copyEntities(world: World, ids: EntityId[]): ClipboardEntry[];
+export declare function pasteEntities(world: World, entries: ClipboardEntry[], offset?: Vec2): EntityId[];

package/dist/types/editor/index.d.ts

@@ -0,0 +1,8 @@
+export { NiceGameEditor, UndoStack, useEditor, serializeProject, deserializeProject } from './NiceGameEditor';
+export type { NiceGameEditorProps, EditorContextValue, EditorState, EditorTool, EditorMode, EditorPanel, UndoEntry, } from './NiceGameEditor';
+export { createGizmoState, getSelectionRect, entitiesInRect, snapToGrid, snapVec2ToGrid, renderGrid, renderTranslateGizmo, renderRotateGizmo, renderScaleGizmo, hitTestGizmoAxis, pickEntityAt, copyEntities, pasteEntities, } from './SceneEditor';
+export type { GizmoMode, GizmoAxis, GizmoState, SelectionBox, ClipboardEntry, } from './SceneEditor';
+export { AssetManager } from './AssetManager';
+export type { AssetMetadata, AssetFolder } from './AssetManager';
+export { Profiler, FPSCounter, ConsoleLogger, snapshotEntity, snapshotWorld, renderCollisionDebug, getMemoryStats, } from './DebugTools';
+export type { ProfilerSample, ProfilerFrame, LogLevel, LogEntry, EntitySnapshot, MemoryStats, } from './DebugTools';

package/dist/types/engine/NiceGameEngine.d.ts

@@ -0,0 +1,53 @@
+import type { GameState, GameSettings } from '../core/types';
+import { GameClock } from '../core/GameClock';
+import { GameConfig } from '../core/GameConfig';
+import { EventBus } from '../core/EventBus';
+import { ServiceLocator } from '../core/ServiceLocator';
+import { World } from '../ecs/World';
+import { InputManager } from '../input/InputManager';
+import { AudioManager } from '../audio/AudioManager';
+import { Camera2D } from '../rendering/Camera2D';
+import { Renderer2D } from '../rendering/Renderer2D';
+import { PhysicsEngine2D } from '../physics/PhysicsEngine2D';
+import { SceneManager } from '../scene/SceneManager';
+import { GameUI } from '../ui/GameUI';
+import { PlayerManager, SplitScreenManager } from '../multiplayer/LocalMultiplayer';
+export interface EngineOptions {
+    canvas: HTMLCanvasElement;
+    settings?: Partial<GameSettings>;
+    debug?: boolean;
+}
+export declare class NiceGameEngine {
+    readonly events: EventBus;
+    readonly config: GameConfig;
+    readonly clock: GameClock;
+    readonly services: ServiceLocator;
+    readonly world: World;
+    readonly input: InputManager;
+    readonly audio: AudioManager;
+    readonly renderer: Renderer2D;
+    readonly physics: PhysicsEngine2D;
+    readonly scenes: SceneManager;
+    readonly ui: GameUI;
+    readonly players: PlayerManager;
+    readonly splitScreen: SplitScreenManager;
+    private loop;
+    private canvas;
+    private _state;
+    private _debug;
+    constructor(options: EngineOptions);
+    get state(): GameState;
+    get camera(): Camera2D;
+    get debug(): boolean;
+    set debug(v: boolean);
+    start(): Promise<void>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    /** Alias for destroy() — unified cleanup pattern. */
+    dispose(): void;
+    private update;
+    private fixedUpdate;
+    private render;
+}

package/dist/types/engine/index.d.ts

@@ -0,0 +1,2 @@
+export { NiceGameEngine } from './NiceGameEngine';
+export type { EngineOptions } from './NiceGameEngine';

package/dist/types/enterprise/Enterprise.d.ts

@@ -0,0 +1,217 @@
+export interface BrandingConfig {
+    appName: string;
+    appLogo: string;
+    appIcon: string;
+    companyName: string;
+    primaryColor: string;
+    secondaryColor: string;
+    accentColor: string;
+    backgroundColor: string;
+    textColor: string;
+    fontFamily: string;
+    borderRadius: number;
+    customCSS?: string;
+    splashScreen?: string;
+    loginBackground?: string;
+    footerText?: string;
+    helpUrl?: string;
+    privacyUrl?: string;
+    termsUrl?: string;
+}
+export declare const DEFAULT_BRANDING: BrandingConfig;
+export declare function generateCSSVariables(branding: BrandingConfig): string;
+export type AuthProvider = 'local' | 'ldap' | 'saml' | 'oidc' | 'oauth2' | 'azure-ad' | 'google' | 'github';
+export interface AuthConfig {
+    providers: AuthProviderConfig[];
+    sessionTimeout: number;
+    maxSessions: number;
+    mfa: MFAConfig;
+    passwordPolicy: PasswordPolicy;
+    loginAttempts: number;
+    lockoutDuration: number;
+    jwtSecret?: string;
+    jwtExpiry: number;
+    refreshTokenExpiry: number;
+    corsOrigins: string[];
+}
+export interface AuthProviderConfig {
+    type: AuthProvider;
+    enabled: boolean;
+    displayName: string;
+    icon?: string;
+    config: Record<string, string>;
+}
+export interface MFAConfig {
+    enabled: boolean;
+    required: boolean;
+    methods: ('totp' | 'sms' | 'email' | 'webauthn')[];
+    gracePeriod: number;
+}
+export interface PasswordPolicy {
+    minLength: number;
+    maxLength: number;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireDigit: boolean;
+    requireSpecial: boolean;
+    preventReuse: number;
+    expiryDays: number;
+}
+export declare const DEFAULT_PASSWORD_POLICY: PasswordPolicy;
+export declare function validatePassword(password: string, policy: PasswordPolicy): string[];
+export type Permission = 'project.create' | 'project.read' | 'project.edit' | 'project.delete' | 'project.publish' | 'asset.upload' | 'asset.edit' | 'asset.delete' | 'user.manage' | 'user.invite' | 'user.delete' | 'role.manage' | 'role.assign' | 'settings.view' | 'settings.edit' | 'billing.view' | 'billing.manage' | 'audit.view' | 'api.access' | 'api.admin' | 'marketplace.publish' | 'marketplace.moderate' | 'admin.all';
+export interface RoleDef {
+    id: string;
+    name: string;
+    description: string;
+    permissions: Permission[];
+    inherits?: string[];
+    isSystem: boolean;
+}
+export declare const SYSTEM_ROLES: RoleDef[];
+export declare function hasPermission(userPermissions: Permission[], required: Permission): boolean;
+export declare function resolveRolePermissions(roleId: string, allRoles: RoleDef[]): Permission[];
+export type AuditAction = 'login' | 'logout' | 'login_failed' | 'project_create' | 'project_update' | 'project_delete' | 'project_publish' | 'asset_upload' | 'asset_delete' | 'user_create' | 'user_update' | 'user_delete' | 'user_role_change' | 'settings_change' | 'permission_change' | 'api_key_create' | 'api_key_revoke' | 'export_start' | 'export_complete';
+export interface AuditEntry {
+    id: string;
+    timestamp: number;
+    action: AuditAction;
+    userId: string;
+    userEmail: string;
+    ipAddress: string;
+    userAgent: string;
+    resourceType: string;
+    resourceId: string;
+    details: Record<string, unknown>;
+    success: boolean;
+    severity: 'info' | 'warning' | 'critical';
+}
+export interface AuditQuery {
+    userId?: string;
+    action?: AuditAction;
+    resourceType?: string;
+    resourceId?: string;
+    severity?: AuditEntry['severity'];
+    startDate?: number;
+    endDate?: number;
+    page: number;
+    pageSize: number;
+}
+export declare class AuditLog {
+    private entries;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    log(entry: Omit<AuditEntry, 'id' | 'timestamp'>): AuditEntry;
+    query(q: AuditQuery): {
+        entries: AuditEntry[];
+        total: number;
+    };
+    getRecent(count: number): AuditEntry[];
+    getFailedLogins(since: number): AuditEntry[];
+    clear(): void;
+}
+export interface Organization {
+    id: string;
+    name: string;
+    slug: string;
+    ownerId: string;
+    members: OrgMember[];
+    plan: OrgPlan;
+    branding: BrandingConfig;
+    settings: OrgSettings;
+    createdAt: number;
+}
+export interface OrgMember {
+    userId: string;
+    email: string;
+    roleId: string;
+    joinedAt: number;
+    invitedBy: string;
+    status: 'active' | 'invited' | 'suspended';
+}
+export type OrgPlan = 'free' | 'starter' | 'professional' | 'enterprise';
+export interface OrgSettings {
+    maxProjects: number;
+    maxMembers: number;
+    maxStorageGB: number;
+    customDomain: boolean;
+    ssoEnabled: boolean;
+    apiAccess: boolean;
+    prioritySupport: boolean;
+    sla: string;
+    dataRetentionDays: number;
+}
+export declare const PLAN_LIMITS: Record<OrgPlan, OrgSettings>;
+export interface APIKey {
+    id: string;
+    name: string;
+    prefix: string;
+    hashedKey: string;
+    userId: string;
+    orgId: string;
+    permissions: Permission[];
+    rateLimit: number;
+    expiresAt?: number;
+    createdAt: number;
+    lastUsedAt?: number;
+    active: boolean;
+}
+export interface RateLimitConfig {
+    windowMs: number;
+    maxRequests: number;
+    burstLimit: number;
+    slowDownAfter: number;
+    slowDownDelay: number;
+}
+export declare const DEFAULT_RATE_LIMITS: Record<string, RateLimitConfig>;
+export declare class RateLimiter {
+    private windows;
+    private config;
+    constructor(config: RateLimitConfig);
+    tryConsume(key: string): {
+        allowed: boolean;
+        remaining: number;
+        retryAfter?: number;
+    };
+    getRemainingRequests(key: string): number;
+    reset(key: string): void;
+}
+export interface DeploymentConfig {
+    mode: 'cloud' | 'self-hosted' | 'hybrid';
+    region: string;
+    database: DatabaseConfig;
+    storage: StorageConfig;
+    cache: CacheConfig;
+    scaling: ScalingConfig;
+}
+export interface DatabaseConfig {
+    type: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite';
+    host: string;
+    port: number;
+    database: string;
+    ssl: boolean;
+    poolSize: number;
+    maxConnections: number;
+}
+export interface StorageConfig {
+    type: 's3' | 'azure-blob' | 'gcs' | 'local';
+    bucket: string;
+    region: string;
+    publicUrl: string;
+    maxFileSizeMB: number;
+}
+export interface CacheConfig {
+    type: 'redis' | 'memcached' | 'memory';
+    host: string;
+    port: number;
+    defaultTTL: number;
+    maxMemoryMB: number;
+}
+export interface ScalingConfig {
+    minInstances: number;
+    maxInstances: number;
+    targetCPU: number;
+    targetMemory: number;
+    scaleUpCooldown: number;
+    scaleDownCooldown: number;
+}

package/dist/types/enterprise/index.d.ts

@@ -0,0 +1 @@
+export * from './Enterprise';

package/dist/types/epic/index.d.ts

@@ -0,0 +1,10 @@
+export * from '../ai/AI';
+export * from '../xr/ARVR';
+export * from '../social/Social';
+export * from '../release/MobileExport';
+export * from '../editor/AdvancedEditor';
+export * from '../physics/PhysicsAdvanced';
+export * from '../audio/AudioAdvanced';
+export * from '../procedural/WorldBuilding';
+export * from '../monetization/Monetization';
+export * from '../enterprise/Enterprise';

package/dist/types/i18n/I18n.d.ts

@@ -0,0 +1,107 @@
+import { EventBus } from '../core/EventBus';
+/** Supported locale codes */
+export type Locale = 'pl' | 'en' | 'de' | 'fr' | 'es' | 'it' | 'pt' | 'nl' | 'sv' | 'no' | 'da' | 'fi' | 'cs' | 'sk' | 'hu' | 'ro' | 'bg' | 'uk' | 'ja' | 'ko';
+/** All supported locales as array */
+export declare const SUPPORTED_LOCALES: readonly Locale[];
+/** Human-readable locale names */
+export declare const LOCALE_NAMES: Record<Locale, string>;
+/** RTL locales (none currently, but extensible for ar, he) */
+export declare const RTL_LOCALES: ReadonlySet<string>;
+/** Nested translation dictionary */
+export interface TranslationDict {
+    [key: string]: string | TranslationDict;
+}
+/** Translation namespace = module-specific translations */
+export interface TranslationNamespace {
+    locale: Locale;
+    namespace: string;
+    translations: TranslationDict;
+}
+/** Interpolation values */
+export interface InterpolationValues {
+    [key: string]: string | number | boolean;
+}
+/** Pluralization rules per language family */
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export interface PluralRule {
+    select(count: number): PluralCategory;
+}
+/** Config for I18nManager */
+export interface I18nConfig {
+    defaultLocale: Locale;
+    fallbackLocale: Locale;
+    debug: boolean;
+    missingKeyHandler?: (locale: Locale, ns: string, key: string) => string;
+    interpolationPrefix: string;
+    interpolationSuffix: string;
+    pluralSeparator: string;
+    namespaceSeparator: string;
+    keySeparator: string;
+}
+export declare class I18nManager {
+    private locale;
+    private readonly config;
+    private readonly namespaces;
+    private readonly loadedNamespaces;
+    readonly events: EventBus;
+    constructor(config?: Partial<I18nConfig>);
+    getLocale(): Locale;
+    setLocale(locale: Locale): void;
+    isRTL(): boolean;
+    /** Auto-detect locale from browser settings */
+    detectLocale(): Locale;
+    /**
+     * Add translations for a namespace + locale.
+     * Can be called multiple times (merges).
+     */
+    addTranslations(namespace: string, locale: Locale, translations: TranslationDict): void;
+    /** Check if translations are loaded for namespace + locale */
+    isLoaded(namespace: string, locale?: Locale): boolean;
+    /** Load translations from async source (e.g., dynamic import) */
+    loadNamespace(namespace: string, locale: Locale, loader: () => Promise<TranslationDict>): Promise<void>;
+    /**
+     * Translate a key.
+     *
+     * @param fullKey - Key with optional namespace: 'ns:path.to.key' or just 'path.to.key'
+     * @param values - Interpolation values (including `count` for pluralization)
+     * @returns Translated string or fallback
+     *
+     * @example
+     * i18n.t('editor:tools.select') // → 'Select'
+     * i18n.t('game:score', { score: 100 }) // → 'Score: 100'
+     * i18n.t('items', { count: 5 }) // → '5 items' (pluralized)
+     */
+    t(fullKey: string, values?: InterpolationValues): string;
+    /** Get plural category for current locale */
+    getPluralCategory(count: number): PluralCategory;
+    /** Format number using locale conventions */
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    /** Format date using locale conventions */
+    formatDate(date: Date, options?: Intl.DateTimeFormatOptions): string;
+    /** Format relative time (e.g., "2 days ago") — requires ES2020+ runtime */
+    formatRelativeTime(value: number, unit: string): string;
+    private parseKey;
+    private resolve;
+    private interpolate;
+    /** Get all loaded namespaces */
+    getLoadedNamespaces(): string[];
+    /** Get all translations for a namespace + locale (for debugging) */
+    getTranslations(namespace: string, locale?: Locale): TranslationDict | undefined;
+    /** Get count of missing translations for a locale compared to fallback */
+    getMissingKeys(namespace: string, locale: Locale): string[];
+    dispose(): void;
+}
+/** Get or create the default I18nManager instance */
+export declare function getI18n(): I18nManager;
+/** Initialize the default I18nManager with config */
+export declare function initI18n(config?: Partial<I18nConfig>): I18nManager;
+/** Convenience shorthand for getI18n().t() */
+export declare function t(key: string, values?: InterpolationValues): string;
+/** Core engine UI strings in English */
+export declare const ENGINE_TRANSLATIONS_EN: TranslationDict;
+/** Core engine UI strings in Polish */
+export declare const ENGINE_TRANSLATIONS_PL: TranslationDict;
+/** Core engine UI strings in German */
+export declare const ENGINE_TRANSLATIONS_DE: TranslationDict;
+/** Register built-in translations on an I18nManager instance */
+export declare function registerEngineTranslations(i18n: I18nManager): void;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export * from './I18n';
+export * from './useTranslation';

package/dist/types/i18n/useTranslation.d.ts

@@ -0,0 +1,74 @@
+import type { Locale, InterpolationValues } from './I18n';
+import { I18nManager } from './I18n';
+/**
+ * Provider component to supply a custom I18nManager to the tree.
+ * If not used, the global singleton (getI18n()) is used automatically.
+ */
+export declare function I18nProvider({ i18n, children, }: {
+    i18n: I18nManager;
+    children: React.ReactNode;
+}): React.ReactElement;
+export interface UseTranslationResult {
+    /** Translate a key */
+    t: (key: string, values?: InterpolationValues) => string;
+    /** Current locale */
+    locale: Locale;
+    /** Change locale */
+    setLocale: (locale: Locale) => void;
+    /** Is current locale RTL? */
+    isRTL: boolean;
+    /** The underlying I18nManager */
+    i18n: I18nManager;
+    /** All supported locales */
+    locales: readonly Locale[];
+    /** Get human-readable name for a locale */
+    localeName: (locale: Locale) => string;
+    /** Format a number */
+    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
+    /** Format a date */
+    formatDate: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+}
+/**
+ * React hook for translations.
+ *
+ * @param defaultNamespace - Optional default namespace prefix
+ * @returns Translation utilities
+ *
+ * @example
+ * // Without namespace
+ * const { t } = useTranslation();
+ * t('engine:editor.tools.select');
+ *
+ * @example
+ * // With default namespace
+ * const { t } = useTranslation('engine');
+ * t('editor.tools.select'); // auto-prefixed to 'engine:editor.tools.select'
+ */
+export declare function useTranslation(defaultNamespace?: string): UseTranslationResult;
+/**
+ * Declarative translated text component.
+ *
+ * @example
+ * <TranslatedText tKey="game:hud.score" values={{ score: 100 }} />
+ * <TranslatedText tKey="editor:tools.select" as="h2" />
+ */
+export declare function TranslatedText({ tKey, values, ns, as: Tag, className, style, }: {
+    tKey: string;
+    values?: InterpolationValues;
+    ns?: string;
+    as?: keyof JSX.IntrinsicElements;
+    className?: string;
+    style?: React.CSSProperties;
+}): React.ReactElement;
+/**
+ * Dropdown for switching locale.
+ *
+ * @example
+ * <LocaleSelect />
+ * <LocaleSelect showNativeName />
+ */
+export declare function LocaleSelect({ showNativeName, className, style, }?: {
+    showNativeName?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}): React.ReactElement;