@mayhem93/nexxus-core-lib 0.0.1

package/dist-types/common/BuiltinSchemas.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Universal fields present in all models
+ * Note: 'type' and 'appId' are excluded as they are handled separately in queries
+ */
+export declare const NEXXUS_UNIVERSAL_FIELDS: {
+    readonly id: {
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly createdAt: {
+        readonly type: "date";
+        readonly required: true;
+    };
+    readonly updatedAt: {
+        readonly type: "date";
+        readonly required: true;
+    };
+};
+/**
+ * Schema definitions for built-in (reserved) models. Only used for
+ */
+export declare const NEXXUS_BUILTIN_MODEL_SCHEMAS: {
+    readonly user: {
+        readonly userType: {
+            readonly type: "string";
+            readonly required: false;
+            readonly filterable: true;
+        };
+        readonly username: {
+            readonly type: "string";
+            readonly required: true;
+            readonly filterable: true;
+        };
+        readonly password: {
+            readonly type: "string";
+            readonly required: false;
+        };
+        readonly authProviders: {
+            readonly type: "array";
+            readonly required: true;
+            readonly arrayType: "string";
+        };
+        readonly devices: {
+            readonly type: "array";
+            readonly required: true;
+            readonly arrayType: "string";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly required: false;
+            readonly properties: {};
+        };
+    };
+    readonly application: {
+        readonly name: {
+            readonly type: "string";
+            readonly required: true;
+            readonly filterable: true;
+        };
+    };
+};
+/**
+ * Type helper to get valid built-in model types
+ */
+export type NexxusBuiltinModelType = keyof typeof NEXXUS_BUILTIN_MODEL_SCHEMAS;
+/**
+ * Helper to check if a model type is built-in
+ */
+export declare function isBuiltinModel(modelType: string): modelType is NexxusBuiltinModelType;

package/dist-types/common/FilterQuery.d.ts

@@ -0,0 +1,58 @@
+import type { NexxusModelDef } from '../common/ModelTypes';
+import { type NexxusBuiltinModelType } from './BuiltinSchemas';
+import type { NexxusAppModelType } from '../models/AppModel';
+import type { NexxusUserDetailSchema } from '../models/User';
+export type NexxusComparisonOperator = 'gte' | 'lte' | 'gt' | 'lt' | 'ne' | 'in';
+export type NexxusLogicalOperator = '$and' | '$or';
+export type NexxusFieldValue = string | number | boolean;
+export type NexxusFieldCondition = NexxusFieldValue | Partial<Record<NexxusComparisonOperator, NexxusFieldValue | NexxusFieldValue[]>>;
+export type NexxusFilterQueryType = {
+    [field: string]: NexxusFieldCondition;
+} | {
+    [op in NexxusLogicalOperator]?: NexxusFilterQueryType[];
+};
+export type FilterNode = {
+    type: 'field';
+    field: string;
+    operator: 'eq';
+    value: NexxusFieldValue;
+} | {
+    type: 'field';
+    field: string;
+    operator: NexxusComparisonOperator;
+    value: NexxusFieldValue | NexxusFieldValue[];
+} | {
+    type: 'logical';
+    operator: NexxusLogicalOperator;
+    conditions: FilterNode[];
+};
+type FilterNodeWithContext = FilterNode & {
+    depth: number;
+    parentOperator?: NexxusLogicalOperator;
+};
+export type NexxusFilterQueryConfig = {
+    appModelDef: NexxusModelDef;
+} | {
+    modelType: NexxusBuiltinModelType;
+    userDetailsSchema?: NexxusUserDetailSchema;
+};
+export declare class NexxusFilterQuery {
+    private query;
+    private nodes;
+    private modelDef;
+    constructor(query: NexxusFilterQueryType, config: NexxusFilterQueryConfig);
+    getNodes(): FilterNode[];
+    getNormalizedQuery(): NexxusFilterQueryType;
+    [Symbol.iterator](): Generator<FilterNodeWithContext>;
+    test(object: Partial<NexxusAppModelType>): boolean;
+    private testNode;
+    private validateAndParse;
+    private parseQuery;
+    private testFieldCondition;
+    private parseFieldCondition;
+    private getFieldFromPath;
+    private validateOperator;
+    private validateValueType;
+    private traverseNodes;
+}
+export {};

package/dist-types/common/JsonPatch.d.ts

@@ -0,0 +1,78 @@
+import { NexxusApplicationSchema } from '../models/Application';
+import type { NexxusModelFieldType } from '../common/ModelTypes';
+import { NexxusAppModelType } from '../models/AppModel';
+import { NexxusBuiltinModelType } from './BuiltinSchemas';
+import type { NexxusUserDetailSchema } from '../models/User';
+declare const JSON_OPS: readonly ["replace", "append", "prepend", "incr", "decr"];
+export type NexxusJsonPatchConstructor = {
+    op: typeof JSON_OPS[number];
+    path: string[];
+    value: any[];
+    metadata: NexxusJsonPatchMetadata;
+};
+export type NexxusJsonPatchMetadata = {
+    appId: string;
+    id: string;
+    type: string;
+    userId?: string;
+};
+export type NexxusJsonPatchInternal = {
+    op: typeof JSON_OPS[number];
+    path: string[];
+    value: any[];
+    metadata: NexxusJsonPatchMetadataInternal;
+};
+type NexxusJsonPatchMetadataInternal = NexxusJsonPatchMetadata & {
+    pathFieldTypes?: NexxusModelFieldType[];
+};
+export type NexxusJsonPatchMetadataConstructor = Omit<NexxusJsonPatchMetadata, 'pathFieldTypes'>;
+export type NexxusJsonPatchValidationConfig = {
+    appSchema: NexxusApplicationSchema;
+} | {
+    modelType: NexxusBuiltinModelType;
+    userDetailsSchema?: NexxusUserDetailSchema;
+};
+export declare class NexxusJsonPatch {
+    private valid;
+    private fullPatch;
+    private static readonly OPERATION_RULES;
+    constructor(fullPatch: NexxusJsonPatchConstructor | NexxusJsonPatchInternal);
+    get(): NexxusJsonPatchInternal;
+    isValid(): boolean;
+    getPartialModel(): Partial<NexxusAppModelType>;
+    validate(config: NexxusJsonPatchValidationConfig): void;
+    private static validateAgainstType;
+    private static traverseSchema;
+    private static validateValueType;
+    /**
+   * Validate string type
+   */
+    private static validateString;
+    /**
+     * Validate number type
+     */
+    private static validateNumber;
+    /**
+     * Validate boolean type
+     */
+    private static validateBoolean;
+    /**
+     * Validate date type
+     */
+    private static validateDate;
+    /**
+     * Validate object type (recursively validates properties)
+     */
+    private static validateObject;
+    /**
+   * Validate array type (recursively validates elements)
+   */
+    private static validateArray;
+    /**
+   * Helper to validate primitive types (reusable for arrays)
+   */
+    private static validatePrimitiveType;
+    private static isObjectFieldDef;
+    private static isArrayFieldDef;
+}
+export {};

package/dist-types/common/ModelTypes.d.ts

@@ -0,0 +1,24 @@
+export type NexxusModelPrimitiveType = 'string' | 'number' | 'boolean' | 'date';
+export type NexxusModelFieldType = NexxusModelPrimitiveType | 'array' | 'object';
+interface BaseFieldDef {
+    type: NexxusModelFieldType;
+    required?: boolean;
+}
+export interface PrimitiveFieldDef extends BaseFieldDef {
+    type: NexxusModelPrimitiveType;
+    filterable?: boolean;
+}
+export interface NexxusArrayFieldDef extends BaseFieldDef {
+    type: 'array';
+    arrayType: NexxusModelPrimitiveType | 'object';
+    properties?: Record<string, NexxusFieldDef>;
+}
+export interface NexxusObjectFieldDef extends BaseFieldDef {
+    type: 'object';
+    properties: Record<string, NexxusFieldDef>;
+}
+export type NexxusFieldDef = PrimitiveFieldDef | NexxusArrayFieldDef | NexxusObjectFieldDef;
+export interface NexxusModelDef {
+    [fieldName: string]: NexxusFieldDef;
+}
+export {};

package/dist-types/common/QueuePayloads.d.ts

@@ -0,0 +1,78 @@
+import { NexxusAppModelType } from '../models/AppModel';
+import { NexxusJsonPatchInternal, NexxusJsonPatchMetadata } from '../common/JsonPatch';
+export interface NexxusBaseQueuePayload {
+    event: string;
+    [key: string]: any;
+}
+export type NexxusModelCreatedPayload = {
+    event: 'model_created';
+    data: NexxusAppModelType;
+};
+export type NexxusModelUpdatedPayload = {
+    event: 'model_updated';
+    data: Array<NexxusJsonPatchInternal>;
+};
+export type NexxusModelDeletedData = Pick<NexxusAppModelType, 'id' | 'type' | 'appId' | 'userId'>;
+export type NexxusModelDeletedPayload = {
+    event: 'model_deleted';
+    data: NexxusModelDeletedData;
+};
+export type NexxusWriterPayload = NexxusModelCreatedPayload | NexxusModelUpdatedPayload | NexxusModelDeletedPayload;
+export type NexxusTransportManagetJsonPatch = Omit<NexxusJsonPatchInternal, 'metadata'> & {
+    metadata: NexxusJsonPatchMetadata & {
+        partialModel: Partial<NexxusAppModelType>;
+    };
+};
+export type NexxusTransportManagerModelUpdatedPayload = {
+    event: 'model_updated';
+    data: Array<NexxusTransportManagetJsonPatch>;
+};
+export type NexxusTransportManagerPayload = NexxusModelCreatedPayload | NexxusTransportManagerModelUpdatedPayload | NexxusModelDeletedPayload;
+export interface NexxusWebSocketJsonPatchMetadata {
+    id: string;
+    channels: Array<string>;
+}
+/**
+ * JsonPatch type for WebSocket transport workers
+ */
+export type NexxusWebSocketJsonPatch = Omit<NexxusJsonPatchInternal, 'metadata'> & {
+    metadata: NexxusWebSocketJsonPatchMetadata;
+};
+/**
+ * Payload for WebSocket Transport - slim metadata with just channel
+ */
+export type NexxusWebSocketModelUpdatedPayload = {
+    event: 'model_updated';
+    data: Array<NexxusWebSocketJsonPatch>;
+};
+export type NexxusWebsocketPayload = {
+    event: 'device_message';
+    deviceIds: Array<string>;
+    data: NexxusModelCreatedPayload | NexxusWebSocketModelUpdatedPayload | NexxusModelDeletedPayload;
+};
+export type NexxusMqttPayload = {
+    event: 'mqtt_publish';
+    topic: string;
+    payload: Buffer;
+} | {
+    event: 'mqtt_subscribe';
+    topic: string;
+};
+export interface NexxusBuiltInQueuePayloadMap {
+    'writer': NexxusWriterPayload;
+    'transport-manager': NexxusTransportManagerPayload;
+}
+export interface NexxusDynamicQueuePayloadMap {
+    'websockets-transport': NexxusWebsocketPayload;
+    'mqtt-transport': NexxusMqttPayload;
+}
+export type NexxusBuiltInQueueName = keyof NexxusBuiltInQueuePayloadMap;
+export type NexxusDynamicQueueType = keyof NexxusDynamicQueuePayloadMap;
+export type NexxusDynamicQueuePattern = keyof NexxusDynamicQueuePayloadMap;
+export type NexxusDynamicQueueName<T extends NexxusDynamicQueuePattern = NexxusDynamicQueuePattern> = `${T}_${number}`;
+export type NexxusKnownQueueName = NexxusBuiltInQueueName | NexxusDynamicQueueName;
+export type NexxusQueueName = NexxusKnownQueueName | (string & {});
+type ExtractQueuePattern<Q extends string> = Q extends `${infer Pattern}_${number}` ? Pattern extends NexxusDynamicQueuePattern ? Pattern : never : never;
+export type ExtractQueueType<Q extends string> = Q extends `${infer Type}_${number}` ? Type extends NexxusDynamicQueueType ? Type : never : never;
+export type NexxusQueuePayload<Q extends NexxusQueueName> = Q extends NexxusBuiltInQueueName ? NexxusBuiltInQueuePayloadMap[Q] : Q extends NexxusDynamicQueueName ? ExtractQueuePattern<Q> extends NexxusDynamicQueuePattern ? NexxusDynamicQueuePayloadMap[ExtractQueuePattern<Q>] : NexxusBaseQueuePayload : NexxusBaseQueuePayload;
+export {};

package/dist-types/common/SchemaValidator.d.ts

@@ -0,0 +1,4 @@
+import { NexxusUserDetailSchema } from "../models/User";
+export declare class NexxusSchemaValidator {
+    static validateUserDetails(partialDetails: Record<string, any>, userDetailSchema: NexxusUserDetailSchema): boolean;
+}

package/dist-types/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./lib/Exceptions";
+export * from "./lib/ConfigProvider";
+export * from "./lib/ConfigManager";
+export * from "./lib/BaseService";
+export * from "./lib/Logger";
+export * from "./common/QueuePayloads";
+export * from "./common/JsonPatch";
+export * from "./common/FilterQuery";
+export * from "./models/BaseModel";
+export * from './common/BuiltinSchemas';
+export * from "./models/AppModel";
+export * from "./models/Application";
+export * from "./models/User";
+export declare const NEXXUS_PREFIX_LC = "nxx";
+export declare const NEXXUS_PREFIX_UC = "NXX";

package/dist-types/lib/BaseService.d.ts

@@ -0,0 +1,28 @@
+import type { ConfigEnvVars, ConfigCliArgs, AddJsonSchemaDefFuncArg, NexxusConfigManager } from './ConfigManager';
+import type { NexxusBaseLogger } from "./Logger";
+import { NexxusConfig } from './ConfigProvider';
+export type EventMap = Record<string | symbol, any[]>;
+export interface INexxusBaseServices {
+    configManager: NexxusConfigManager;
+    logger: NexxusBaseLogger<NexxusConfig>;
+}
+declare class TypedEventEmitter<E> {
+    private emitter;
+    constructor();
+    on<K extends keyof E>(event: K, listener: (...payload: E[K] extends any[] ? E[K] : never) => void): this;
+    once<K extends keyof E>(event: K, listener: (...payload: E[K] extends any[] ? E[K] : never) => void): this;
+    off<K extends keyof E>(event: K, listener: (...payload: E[K] extends any[] ? E[K] : never) => void): this;
+    emit<K extends keyof E>(event: K, ...payload: E[K] extends any[] ? E[K] : never): boolean;
+}
+export declare abstract class NexxusBaseService<T extends NexxusConfig, Ev extends EventMap = {}> extends TypedEventEmitter<Ev> {
+    protected config: Readonly<T>;
+    protected static envVars: ConfigEnvVars;
+    protected static cliArgs: ConfigCliArgs;
+    protected static schemaPath: string;
+    private static schemaContents;
+    constructor(config: Readonly<T>);
+    static envVarConfig(): ConfigEnvVars;
+    static cliArgConfig(): ConfigCliArgs;
+    static schema(): AddJsonSchemaDefFuncArg;
+}
+export {};

package/dist-types/lib/ConfigManager.d.ts

@@ -0,0 +1,48 @@
+import { NexxusBaseService } from './BaseService';
+import { CliArgType, NexxusConfig, INexxusConfigProvider } from "./ConfigProvider";
+import type { JSONSchema7Definition } from "json-schema";
+export type AddJsonSchemaDefFuncArg = {
+    name: string;
+    where: string;
+    definition: JSONSchema7Definition;
+    required: boolean;
+};
+type EnvVarsSpec = {
+    name: string;
+    location: string;
+};
+export type ConfigEnvVars = {
+    source: string;
+    specs: Array<EnvVarsSpec>;
+};
+type CliArgsSpec = {
+    name: string;
+    location: string;
+    type: CliArgType;
+};
+export type ConfigCliArgs = {
+    source: string;
+    specs: Array<CliArgsSpec>;
+};
+export declare class NexxusConfigManager {
+    private static CONF_FILE_NAME;
+    private jsonSchema;
+    private envVarsSpecs;
+    private cliArgsSpecs;
+    private data;
+    private configProviders;
+    private customProviders;
+    constructor(confFile?: string);
+    addCustomProvider(provider: INexxusConfigProvider): void;
+    private addJsonSchemaDef;
+    validateServices(svcs: Array<typeof NexxusBaseService>): void;
+    private addCliArgsToSpec;
+    private addEnvVarsToSpec;
+    private populateFromCliArgs;
+    private populateFromEnvVars;
+    private populateFromCustomProviders;
+    private formatAjvErrors;
+    private validate;
+    getConfig(field?: string): NexxusConfig;
+}
+export {};

package/dist-types/lib/ConfigProvider.d.ts

@@ -0,0 +1,27 @@
+export type NexxusConfig = Record<string, any>;
+export type CliArgType = "int" | "str" | "boolean" | "float";
+export interface INexxusConfigProvider {
+    getConfig(): NexxusConfig | Promise<NexxusConfig>;
+}
+export declare abstract class NexxusConfigProvider implements INexxusConfigProvider {
+    abstract getConfig(): NexxusConfig;
+}
+export declare abstract class NexxusAsyncConfigProvider implements INexxusConfigProvider {
+    abstract getConfig(): Promise<NexxusConfig>;
+}
+export declare class NexxusFileConfigProvider extends NexxusConfigProvider {
+    private filePath;
+    constructor(filePath: string);
+    getConfig(): NexxusConfig;
+}
+export declare class NexxusEnvVarsConfigProvider extends NexxusConfigProvider {
+    static ENV_VAR_PREFIX: Readonly<string>;
+    getConfig(): NexxusConfig;
+}
+export declare class NexxusCliArgConfigProvider extends NexxusConfigProvider {
+    private argParser;
+    private originalExit;
+    constructor();
+    addArgument(name: string, type: CliArgType): void;
+    getConfig(): NexxusConfig;
+}

package/dist-types/lib/Exceptions.d.ts

@@ -0,0 +1,33 @@
+export declare enum NexxusExceptions {
+    FATAL_ERROR = "FatalErrorException",
+    BAD_REQUEST = "BadRequestException",
+    CONNECTION_ERROR = "ConnectionErrorException",
+    INVALID_CONFIG = "InvalidConfigException",
+    INVALID_JSON_PATCH = "InvalidJsonPatchException",
+    INVALID_QUERY_FILTER = "InvalidQueryFilterException",
+    INVALID_USER_MODEL = "InvalidUserModelException"
+}
+export declare class NexxusException extends Error {
+    constructor(type: string, message: string);
+}
+export declare class FatalErrorException extends NexxusException {
+    constructor(message: string);
+}
+export declare class BadRequestException extends NexxusException {
+    constructor(message: string);
+}
+export declare class ConnectionException extends NexxusException {
+    constructor(message: string);
+}
+export declare class InvalidConfigException extends NexxusException {
+    constructor(message: string);
+}
+export declare class InvalidJsonPatchException extends NexxusException {
+    constructor(message: string);
+}
+export declare class InvalidQueryFilterException extends NexxusException {
+    constructor(message: string);
+}
+export declare class InvalidUserModelException extends NexxusException {
+    constructor(message: string);
+}

package/dist-types/lib/GlobalServices.d.ts

@@ -0,0 +1,19 @@
+import { NexxusBaseLogger } from "./Logger";
+import { NexxusConfig } from "./ConfigProvider";
+import { NexxusConfigManager } from "./ConfigManager";
+type GlobalServicesInitParams = {
+    logger?: NexxusBaseLogger<NexxusConfig>;
+    configManager?: NexxusConfigManager;
+    database?: unknown;
+    messageQueue?: unknown;
+    redis?: unknown;
+};
+export declare class NexxusGlobalServices {
+    static logger: Readonly<NexxusBaseLogger<NexxusConfig>>;
+    static configManager: Readonly<NexxusConfigManager>;
+    static database: unknown;
+    static messageQueue: unknown;
+    static redis: unknown;
+    static init(params: GlobalServicesInitParams): void;
+}
+export {};

package/dist-types/lib/Logger.d.ts

@@ -0,0 +1,48 @@
+import { ConfigEnvVars, ConfigCliArgs } from './ConfigManager';
+import { NexxusBaseService, INexxusBaseServices } from './BaseService';
+import { NexxusConfig } from './ConfigProvider';
+type LoggableType = string | object | number | boolean | null | undefined;
+export declare const enum NexxusLoggerLevels {
+    EMERGENCY = "emerg",
+    ALERT = "alert",
+    CRITICAL = "crit",
+    ERROR = "error",
+    WARNING = "warn",
+    NOTICE = "notice",
+    INFO = "info",
+    DEBUG = "debug"
+}
+type WinstonNexxusLoggerConfig = {
+    level: NexxusLoggerLevels;
+    logType: "json" | "text";
+    timestamps: boolean;
+    colors: boolean;
+} & NexxusConfig;
+export interface INexxusLogger {
+    log(level: NexxusLoggerLevels, message: LoggableType, label?: string): void;
+}
+export interface INexxusAsyncLogger extends INexxusLogger {
+    log(level: NexxusLoggerLevels, message: LoggableType, label?: string): Promise<void>;
+}
+interface NexxusLoggerServices extends Omit<INexxusBaseServices, 'logger'> {
+}
+export declare abstract class NexxusBaseLogger<T extends NexxusConfig> extends NexxusBaseService<T> implements INexxusLogger {
+    constructor(services: NexxusLoggerServices);
+    abstract log(level: NexxusLoggerLevels, message: LoggableType, label?: string): void;
+    debug(message: LoggableType, label?: string): void;
+    info(message: LoggableType, label?: string): void;
+    warn(message: LoggableType, label?: string): void;
+    error(message: LoggableType, label?: string): void;
+    critical(message: LoggableType, label?: string): void;
+    alert(message: LoggableType, label?: string): void;
+    emerg(message: LoggableType, label?: string): void;
+}
+export declare class WinstonNexxusLogger extends NexxusBaseLogger<WinstonNexxusLoggerConfig> {
+    private winston;
+    protected static schemaPath: string;
+    protected static envVars: ConfigEnvVars;
+    protected static cliArgs: ConfigCliArgs;
+    constructor(services: NexxusLoggerServices);
+    log(level: NexxusLoggerLevels, message: LoggableType, label?: string): void;
+}
+export {};

package/dist-types/models/AppModel.d.ts

@@ -0,0 +1,9 @@
+import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
+export type NexxusAppModelType = INexxusBaseModel & {
+    appId: string;
+    userId?: string;
+    [key: string]: any;
+};
+export declare class NexxusAppModel extends NexxusBaseModel<NexxusAppModelType> {
+    constructor(props: NexxusAppModelType);
+}

package/dist-types/models/Application.d.ts

@@ -0,0 +1,29 @@
+import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
+import { NexxusModelDef } from "../common/ModelTypes";
+import { NexxusUserDetailSchema } from "./User";
+export interface NexxusApplicationSchema {
+    [modelName: string]: NexxusModelDef;
+}
+export interface NexxusUserTypeConfig {
+    private?: boolean;
+}
+export type NexxusApplicationModelType = INexxusBaseModel<'application'> & {
+    name: string;
+    description?: string;
+    schema: NexxusApplicationSchema;
+    authEnabled: boolean;
+    allowMultipleLogin: boolean | null;
+    userTypes?: {
+        [userType: string]: NexxusUserTypeConfig;
+    };
+    userDetailSchema?: {
+        [userType: string]: NexxusUserDetailSchema;
+    };
+};
+export declare class NexxusApplication extends NexxusBaseModel<NexxusApplicationModelType> {
+    constructor(data: NexxusApplicationModelType);
+    getSchema(): NexxusApplicationSchema;
+    getUserDetailSchema(userType?: string): NexxusUserDetailSchema | null;
+    getAppModelFieldType(modelType: string, fieldPath: string): string | undefined;
+    getModelFilterableFields(modelType: string): Set<string>;
+}

package/dist-types/models/BaseModel.d.ts

@@ -0,0 +1,23 @@
+import { NexxusApplication, NexxusApplicationModelType } from "./Application";
+import { NexxusApplicationUser, NexxusUserModelType } from "./User";
+import { NexxusAppModel, NexxusAppModelType } from "./AppModel";
+export type AnyNexxusModel = NexxusApplication | NexxusApplicationUser | NexxusAppModel;
+export type AnyNexxusModelType = NexxusApplicationModelType | NexxusUserModelType | NexxusAppModelType;
+export interface INexxusBaseModel<TType extends string = string> {
+    id?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    type: TType;
+}
+export declare const MODEL_REGISTRY: {
+    readonly application: "application";
+    readonly user: "user";
+};
+export type NexxusBuiltinModelTypeName = typeof MODEL_REGISTRY[keyof typeof MODEL_REGISTRY];
+export type NexxusModelTypeName = NexxusBuiltinModelTypeName | string;
+export declare abstract class NexxusBaseModel<T extends INexxusBaseModel = INexxusBaseModel> {
+    protected data: T;
+    static readonly modelType: string | undefined;
+    constructor(data: T);
+    getData(): T;
+}

package/dist-types/models/User.d.ts

@@ -0,0 +1,17 @@
+import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
+import { NexxusFieldDef } from "../common/ModelTypes";
+export type NexxusUserModelType = INexxusBaseModel<'user'> & {
+    appId: string;
+    userType: string;
+    username: string;
+    password: string | null;
+    authProviders: Array<string>;
+    devices: Array<string>;
+    details?: Record<string, any>;
+};
+export interface NexxusUserDetailSchema {
+    [field: string]: NexxusFieldDef;
+}
+export declare class NexxusApplicationUser extends NexxusBaseModel<NexxusUserModelType> {
+    constructor(data: NexxusUserModelType);
+}