@heswell/vuu-data-engine-local 0.0.0-stage → 1.0.0

package/src/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./ArrayProxy";
+export * from "./core/filter/PermissionFilter";
+export * from "./core/module/VuuModule";
+export { ensureVuuModule } from "./core/module/ModuleContainer";
+export * from "./core/user/CurrentUser";
+export { default as tableContainer } from "./core/table/TableContainer";
+export * from "./local-datasource-provider/LocalDatasourceProvider";
+export * from "./makeSuggestions";
+export * from "./notifications";
+export * from "./schemas";
+export * from "./simul";
+export * from "./basket";
+export * from "./module-admin";
+export * from "./user-admin";
+export { buildDataColumnMap, buildDataColumnMapFromSchema, Table, type TableEvents, } from "./Table";
+export * from "./test";
+export * from "./EngineDataSource";
+export * from "./ModuleDataSource";
+export * from "./vuu-row-generator";

package/src/local-datasource-provider/LocalDatasourceProvider.d.ts

@@ -0,0 +1,18 @@
+import { type LocalVuuServer } from "@vuu-ui/core";
+import type { ReactNode } from "react";
+import type { VuuModule } from "../core/module/VuuModule";
+/** Data context covering every VuuModule registered in the browser. */
+export declare const LocalDataSourceProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+export interface LocalVuuServerOptions {
+    /** Matches the `vuu.connectionId` of the modules this server serves. */
+    connectionId: string;
+    modules: VuuModule<any>[];
+}
+/**
+ * Simulates a Vuu server in the browser, publishing the tables of the given
+ * modules. Pass the result to a local-mode `AuthenticationProvider` as one of
+ * its `localServers`.
+ */
+export declare const createLocalVuuServer: ({ connectionId, modules, }: LocalVuuServerOptions) => LocalVuuServer;

package/src/makeSuggestions.d.ts

@@ -0,0 +1,3 @@
+import type { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+export declare const makeSuggestions: (data: DataSourceRow<bigint | VuuRowDataItemType>[], columnIndex: number, pattern?: string) => Promise<string[]>;

package/src/module-admin/ModuleAdminModule.d.ts

@@ -0,0 +1,32 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
+import { type Table } from "../Table";
+import { type ModuleAdminTableName } from "./module-admin-schemas";
+import { type ModuleAdminSnapshot } from "./snapshot-projection";
+type ModuleAdminTables = Record<ModuleAdminTableName, Table>;
+export declare const MODULE_ADMIN_INITIAL_SNAPSHOT: ModuleAdminSnapshot;
+/**
+ * In-browser MODULE_DISCOVERY server. Supports the module admin RPCs from
+ * `@heswell/module-admin/contracts` on both tables; state is held in memory.
+ */
+export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
+    #private;
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
+    get menus(): {
+        modulePermissions: undefined;
+        modules: undefined;
+    };
+    protected get includeDefaultServices(): boolean;
+    get menuServices(): undefined;
+    get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
+    get tables(): ModuleAdminTables;
+    get visualLinks(): undefined;
+}
+export declare const moduleAdminModule: ModuleAdminModule;
+export {};

package/src/module-admin/index.d.ts

@@ -0,0 +1,4 @@
+export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, moduleAdminModule, } from "./ModuleAdminModule";
+export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS, type ModuleAdminTableName, } from "./module-admin-schemas";
+export { projectModuleAdminSnapshot, reconcileModuleAdminTables, type ModuleAdminSnapshot, } from "./snapshot-projection";
+export type { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";

package/src/module-admin/module-admin-schemas.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export declare const MODULE_ADMIN_MODULE_NAME = "MODULE_DISCOVERY";
+export type ModuleAdminTableName = "modules" | "modulePermissions";
+export declare const MODULE_ADMIN_TABLE_SCHEMAS: Readonly<Record<ModuleAdminTableName, Readonly<TableSchema>>>;

package/src/module-admin/snapshot-projection.d.ts

@@ -0,0 +1,13 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "../Table";
+import type { ModuleAdminTableName } from "./module-admin-schemas";
+type Row = Array<bigint | VuuRowDataItemType>;
+type Tables = Record<ModuleAdminTableName, Table>;
+export type ModuleAdminSnapshot = {
+    modules: readonly ManagedModule[];
+};
+export declare const projectModuleAdminSnapshot: (snapshot: ModuleAdminSnapshot, tables: Tables) => Record<ModuleAdminTableName, Row[]>;
+/** Brings the tables into line with the snapshot, emitting row-level updates. */
+export declare const reconcileModuleAdminTables: (snapshot: ModuleAdminSnapshot, tables: Tables) => void;
+export {};

package/src/notifications/NotificationModule.d.ts

@@ -0,0 +1,39 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { type RpcService, VuuModule } from "../core/module/VuuModule";
+import type { PermissionFunction } from "../core/filter/PermissionFilter";
+import { type Table } from "../Table";
+import { type ColumnDefinition } from "./NotificationsSchema";
+export type NotificationsTableName = "notifications";
+/**
+ * Source of notifications. Started when the first dataSource is
+ * created for the notifications table, or explicitly via module.start().
+ */
+export interface NotificationsProvider {
+    start: () => void;
+    stop: () => void;
+}
+export type NotificationsProviderFactory = (table: Table) => NotificationsProvider;
+export type NotificationsServiceFactory = (table: Table, module: NotificationModule) => RpcService[];
+/**
+ * A generic Notifications module, exposing a single 'notifications' table.
+ * The source of notifications (provider), the rows visible to each user
+ * (permissionFunction) and any rpc services (serviceFactory) are supplied
+ * by the consumer. Any additional columns are appended to the generic
+ * notification columns (see NotificationsSchema).
+ */
+export declare class NotificationModule extends VuuModule<NotificationsTableName> {
+    #private;
+    static readonly NAME = "NOTIFICATIONS";
+    static readonly TABLE_NAME: "notifications";
+    constructor(providerFactory: NotificationsProviderFactory, permissionFunction: PermissionFunction, serviceFactory: NotificationsServiceFactory, ...additionalColumns: ColumnDefinition[]);
+    protected beforeCreateDataSource(): void;
+    get isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    get menus(): undefined;
+    get menuServices(): undefined;
+    get schemas(): Record<"notifications", TableSchema>;
+    get services(): Record<"notifications", RpcService[]>;
+    get tables(): Record<"notifications", Table>;
+    get visualLinks(): undefined;
+}

package/src/notifications/NotificationsSchema.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaColumn } from "@vuu-ui/vuu-data-types";
+/**
+ * Accepts either a SchemaColumn or a column definition in the Scala server
+ * 'name:Type' format, e.g. "source:String", "priority:Int".
+ */
+export type ColumnDefinition = SchemaColumn | string;
+export declare const toColumn: (columnDefinition: ColumnDefinition) => SchemaColumn;
+export declare const NotificationsSchema: {
+    Id: string;
+    Type: string;
+    ExpiryTime: string;
+    Title: string;
+    Message: string;
+    Level: string;
+    Audience: string;
+    /**
+     * The generic notification columns, plus any additional columns.
+     */
+    allFrom: (...additionalColumns: ColumnDefinition[]) => SchemaColumn[];
+};

package/src/notifications/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./NotificationModule";
+export * from "./NotificationsSchema";
+export * from "./simulated/DismissNotificationRpcHandler";
+export * from "./simulated/SimulatedNotificationsModule";
+export * from "./simulated/SimulatedNotificationsProvider";
+export * from "./simulated/notificationsModule";

package/src/notifications/simulated/DismissNotificationRpcHandler.d.ts

@@ -0,0 +1,8 @@
+import type { RpcService } from "../../core/module/VuuModule";
+import type { Table } from "../../Table";
+import type { NotificationModule } from "../NotificationModule";
+/**
+ * Marks the notifications selected in the requesting viewport as dismissed
+ * by the user that owns the viewport.
+ */
+export declare const DismissNotificationRpcHandler: (table: Table, module: NotificationModule) => RpcService[];

package/src/notifications/simulated/SimulatedNotificationsModule.d.ts

@@ -0,0 +1,2 @@
+import { NotificationModule } from "../NotificationModule";
+export declare const SimulatedNotificationsModule: () => NotificationModule;

package/src/notifications/simulated/SimulatedNotificationsProvider.d.ts

@@ -0,0 +1,21 @@
+import type { Table } from "../../Table";
+import type { NotificationsProvider } from "../NotificationModule";
+/**
+ * Minimal implementation of the subset of Java String.format used by
+ * the message templates: %d, %0nd and %%. Args are consumed in order.
+ */
+export declare const formatMessage: (format: string, ...args: number[]) => string;
+/**
+ * Generates random notifications. Seeds an initial set of notifications on
+ * start then, on each cycle, deletes expired notifications and adds a new
+ * notification if fewer than the maximum are active.
+ */
+export declare class SimulatedNotificationsProvider implements NotificationsProvider {
+    #private;
+    constructor(table: Table);
+    start(): void;
+    stop(): void;
+    runOnce: () => void;
+    private generateRandomNotification;
+    private toDataRow;
+}

package/src/notifications/simulated/notificationsModule.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simulated notifications. The provider starts generating notifications
+ * when the first dataSource is created for the notifications table.
+ */
+export declare const notificationsModule: import("..").NotificationModule;

package/src/rowUpdates.d.ts

@@ -0,0 +1,15 @@
+import type { VuuRange, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "./Table";
+export type UpdateHandler = (updates: (RowUpdates | RowInsert | RowDelete)[]) => void;
+export interface UpdateGenerator {
+    setTable: (table: Table) => void;
+    setRange: (range: VuuRange) => void;
+}
+export type UpdateType = "I" | "D" | "U";
+type MAXIMUM_ALLOWED_BOUNDARY = 20;
+type RepeatingTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [], Count extends ReadonlyArray<number> = []> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result : Tuple extends [] ? [] : Result extends [] ? RepeatingTuple<Tuple, Tuple, [...Count, 1]> : RepeatingTuple<Tuple, Result | [...Result, ...Tuple], [...Count, 1]>;
+type UpdatePairs = RepeatingTuple<[number, VuuRowDataItemType]>;
+export type RowUpdates = ["U", number, ...UpdatePairs];
+export type RowInsert = ["I", ...VuuRowDataItemType[]];
+export type RowDelete = ["D", string];
+export {};

package/src/schemas.d.ts

@@ -0,0 +1,10 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { type BasketsTableName } from "./basket/basket-schemas";
+import { type SimulTableName } from "./simul/simul-schemas";
+import { type TestTableName } from "./test/TestModule";
+import { type UserAdminTableName } from "@heswell/user-admin/contracts";
+import { type ModuleAdminTableName } from "./module-admin";
+export type VuuTableName = BasketsTableName | SimulTableName | TestTableName | UserAdminTableName | ModuleAdminTableName;
+export declare const schemas: Record<VuuTableName, TableSchema>;
+export declare const getAllSchemas: () => Record<VuuTableName, TableSchema>;
+export declare const getSchema: (tableName: VuuTableName) => Readonly<TableSchema>;

package/src/session-table-utils.d.ts

@@ -0,0 +1,6 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { Table } from "./Table";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export declare const sessionTableRow: (row: Array<bigint | VuuRowDataItemType>, schema: TableSchema) => (bigint | VuuRowDataItemType)[];
+export declare const createSessionTableFromSelectedRows: (table: Table, selectedRowIds: string[]) => Table;
+export declare const sessionTableSchema: (schema: TableSchema) => TableSchema;

package/src/simul/SimulModule.d.ts

@@ -0,0 +1,24 @@
+import type { VuuLink, VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { type MenuServiceHandler, type RpcMenuService, type RpcService, type ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import type { Table } from "../Table";
+import { type SimulTableName } from "./simul-schemas";
+/**
+ * This is an example of how we might extend the built-in VuuModule to
+ * implement a module-specific service in such a way that it can invoke
+ * methods on the VuuModule.
+ */
+export declare class SimulModule extends VuuModule<SimulTableName> {
+    #private;
+    constructor();
+    get menus(): Record<SimulTableName, VuuMenu | undefined> | undefined;
+    get schemas(): Readonly<Record<SimulTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
+    get editServices(): undefined;
+    get menuServices(): Record<SimulTableName, RpcMenuService[] | undefined> | undefined;
+    get services(): Record<SimulTableName, RpcService[] | undefined> | undefined;
+    get tables(): Record<SimulTableName, Table>;
+    get visualLinks(): Record<SimulTableName, VuuLink[] | undefined>;
+    cancelOrder: MenuServiceHandler;
+    startOrders: ServiceHandler;
+    stopOrders: ServiceHandler;
+}
+export declare const simulModule: SimulModule;

package/src/simul/index.d.ts

@@ -0,0 +1,2 @@
+export { type SimulTableName, isSimulTable, schemas as simulSchemas, } from "./simul-schemas";
+export { simulModule } from "./SimulModule";

package/src/simul/reference-data/accounts.d.ts

@@ -0,0 +1 @@
+export declare const accounts: string[];

package/src/simul/reference-data/algos.d.ts

@@ -0,0 +1 @@
+export declare const algos: string[];

package/src/simul/reference-data/currencies.d.ts

@@ -0,0 +1 @@
+export declare const currencies: string[];

package/src/simul/reference-data/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./currencies";
+export * from "./instruments";
+export * from "./instrument-prices";
+export * from "./prices";
+export * from "./locations";

package/src/simul/reference-data/instrument-prices.d.ts

@@ -0,0 +1,60 @@
+type ask = number;
+type askSize = number;
+type bbg = string;
+type bid = number;
+type bidSize = number;
+type close = number;
+type currency = string;
+type description = string;
+type exchange = string;
+type isin = string;
+type last = number;
+type lotSize = number;
+type open = number;
+type phase = string;
+type ric = string;
+type scenario = string;
+type vuuCreatedTimestamp = number;
+type vuuUpdatedTimestamp = number;
+export type InstrumentPricesDataRow = [
+    ask,
+    askSize,
+    bbg,
+    bid,
+    bidSize,
+    close,
+    currency,
+    description,
+    exchange,
+    isin,
+    last,
+    lotSize,
+    open,
+    phase,
+    ric,
+    scenario,
+    vuuCreatedTimestamp,
+    vuuUpdatedTimestamp
+];
+export declare const InstrumentPricesColumnMap: {
+    ask: number;
+    askSize: number;
+    bbg: number;
+    bid: number;
+    bidSize: number;
+    close: number;
+    currency: number;
+    description: number;
+    exchange: number;
+    isin: number;
+    last: number;
+    lotSize: number;
+    open: number;
+    phase: number;
+    ric: number;
+    scenario: number;
+    vuuCreatedTimestamp: number;
+    vuuUpdatedTimestamp: number;
+};
+declare const instrumentPrices: InstrumentPricesDataRow[];
+export { instrumentPrices };

package/src/simul/reference-data/instruments-extended.d.ts

@@ -0,0 +1 @@
+export declare const instrumentsExtendedTable: import("../..").Table;

package/src/simul/reference-data/instruments.d.ts

@@ -0,0 +1,35 @@
+export type bbg = string;
+export type currency = string;
+export type ric = string;
+export type description = string;
+export type exchange = string;
+export type price = string;
+export type date = number;
+export type InstrumentsDataRow = [
+    bbg,
+    currency,
+    description,
+    exchange,
+    string,
+    number,
+    ric,
+    date,
+    date,
+    string
+];
+export declare const InstrumentColumnMap: {
+    readonly bbg: 0;
+    readonly currency: 1;
+    readonly description: 2;
+    readonly exchange: 3;
+    readonly string: 4;
+    readonly number: 5;
+    readonly ric: 6;
+    readonly vuuCreatedTimestamp: 7;
+    readonly vuuUpdatedTimestamp: 8;
+    readonly vuuMsg: 9;
+};
+declare const instrumentsData: InstrumentsDataRow[];
+export declare const getRic: (defaultRic: string) => string;
+export declare const instrumentsTable: import("../..").Table;
+export { instrumentsData };

package/src/simul/reference-data/isin-generator/convert-string-to-base-ten-number.d.ts

@@ -0,0 +1 @@
+export declare const convertStringToBaseTenNumber: (value: string) => number;

package/src/simul/reference-data/isin-generator/fixtures/alphabet.d.ts

@@ -0,0 +1 @@
+export declare const alphabet: string[];

package/src/simul/reference-data/isin-generator/fixtures/alphanumeric-values.d.ts

@@ -0,0 +1 @@
+export declare const alphanumeric: (string | number)[];

package/src/simul/reference-data/isin-generator/fixtures/base-ten-numbers.d.ts

@@ -0,0 +1 @@
+export declare const baseTenNumbers: number[];

package/src/simul/reference-data/isin-generator/generate-cusip-check-code.d.ts

@@ -0,0 +1 @@
+export declare const generateCusipCheckCode: (cusip: string) => number;

package/src/simul/reference-data/isin-generator/generate-cusip-without-check-code.d.ts

@@ -0,0 +1 @@
+export declare const generateCusipWithoutCheckCode: () => string;

package/src/simul/reference-data/isin-generator/generate-cusip.d.ts

@@ -0,0 +1 @@
+export declare const generateCusip: () => string;

package/src/simul/reference-data/isin-generator/generate-random-alphanumeric.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomAlphanumeric: () => string | number;

package/src/simul/reference-data/isin-generator/generate-random-base-ten-number.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomBaseTenNumber: () => number;

package/src/simul/reference-data/isin-generator/generate-random-string-of-alphanumeric-chars.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomStringOfAlphanumericChars: () => string;

package/src/simul/reference-data/isin-generator/generate-random-string-of-base-ten-chars.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomStringOfBaseTenChars: () => string;

package/src/simul/reference-data/isin-generator/index.d.ts

@@ -0,0 +1 @@
+export declare const isinGenerator: () => string;

package/src/simul/reference-data/isin-generator/is-odd.d.ts

@@ -0,0 +1 @@
+export declare const isOdd: (value: number) => boolean;

package/src/simul/reference-data/locations.d.ts

@@ -0,0 +1,4 @@
+export declare const locations: {
+    [key: string]: string[];
+};
+export declare const suffixes: string[];

package/src/simul/reference-data/lotsizes.d.ts

@@ -0,0 +1 @@
+export declare const lotsizes: number[];

package/src/simul/reference-data/orderStatus.d.ts

@@ -0,0 +1 @@
+export declare const orderStatus: string[];

package/src/simul/reference-data/orders.d.ts

@@ -0,0 +1,36 @@
+export type status = string;
+export type ccy = string;
+export type created = number;
+export type filledQuantity = number;
+export type lastUpdate = number;
+export type orderId = string;
+export type quantity = number;
+export type ric = string;
+export type side = string;
+export type trader = string;
+export type OrdersDataRow = [
+    status,
+    ccy,
+    created,
+    filledQuantity,
+    lastUpdate,
+    orderId,
+    quantity,
+    ric,
+    side,
+    trader
+];
+export declare const OrderColumnMap: {
+    readonly ccy: 0;
+    readonly created: 1;
+    readonly filledQuantity: 2;
+    readonly lastUpdate: 3;
+    readonly orderId: 4;
+    readonly quantity: 5;
+    readonly ric: 6;
+    readonly side: 7;
+    readonly trader: 8;
+};
+declare const ordersData: OrdersDataRow[];
+export declare const ordersTable: import("../..").Table;
+export { ordersData };

package/src/simul/reference-data/parent-child-orders.d.ts

@@ -0,0 +1,4 @@
+export declare const parentOrdersTable: import("../..").Table;
+export declare const childOrdersTable: import("../..").Table;
+export declare function startGeneratingNewOrders(): void;
+export declare function stopGeneratingNewOrders(): void;

package/src/simul/reference-data/priceStrategies.d.ts

@@ -0,0 +1 @@
+export declare const priceStrategies: string[];

package/src/simul/reference-data/prices.d.ts

@@ -0,0 +1,34 @@
+type ask = number;
+type askSize = number;
+type bid = number;
+type bidSize = number;
+type close = number;
+type last = number;
+type open = number;
+type phase = "C";
+type ric = string;
+type scenario = "close";
+type lastUpdate = number;
+type created = number;
+type vuuMsg = string;
+export type PricesDataRow = [
+    ask,
+    askSize,
+    bid,
+    bidSize,
+    close,
+    last,
+    open,
+    phase,
+    ric,
+    scenario,
+    lastUpdate,
+    created,
+    vuuMsg
+];
+declare const bid: number, bidSize: number, ask: number, askSize: number;
+declare const lastUpdate: number;
+declare const created: number;
+declare const pricesData: Array<PricesDataRow>;
+export declare const pricesTable: import("../..").Table;
+export { pricesData };

package/src/simul/reference-data/sides.d.ts

@@ -0,0 +1 @@
+export declare const sides: string[];

package/src/simul/simul-schemas.d.ts

@@ -0,0 +1,9 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type SimulTableName = "instruments" | "instrumentsExtended" | "instrumentPrices" | "orders" | "childOrders" | "parentOrders" | "prices";
+export declare const schemas: Readonly<Record<SimulTableName, Readonly<TableSchema>>>;
+export type SimulVuuTable = {
+    module: "SIMUL";
+    table: SimulTableName;
+};
+export declare const isSimulTable: (table: VuuTable) => table is SimulVuuTable;

package/src/test/TestModule.d.ts

@@ -0,0 +1,16 @@
+import { type RpcMenuService, VuuModule } from "../core/module/VuuModule";
+import { type Table } from "../Table";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export type TestTableName = "TestDates" | "TwoHundredColumns" | "LinkParent" | "LinkChild" | "ChartTable" | "MaxScrollEndTable" | "TestEditEmpty" | "TestEdit";
+declare class TestModule extends VuuModule<TestTableName> {
+    #private;
+    constructor();
+    get menus(): undefined;
+    get services(): undefined;
+    get menuServices(): Record<TestTableName, RpcMenuService[] | undefined> | undefined;
+    get schemas(): Record<TestTableName, TableSchema>;
+    get tables(): Record<TestTableName, Table>;
+    get visualLinks(): undefined;
+}
+export declare const testModule: TestModule;
+export {};

package/src/test/index.d.ts

@@ -0,0 +1 @@
+export * from "./TestModule";

package/src/user-admin/UserAdminModule.d.ts

@@ -0,0 +1,54 @@
+import { type UserAdminSnapshot, type UserAdminTableName } from "@heswell/user-admin/contracts";
+import { InMemoryUserAdminStore } from "@heswell/user-admin/in-memory";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
+import { Table } from "../Table";
+type UserAdminTables = Record<UserAdminTableName, Table>;
+export declare class UserAdminModule extends VuuModule<UserAdminTableName> {
+    #private;
+    readonly store: InMemoryUserAdminStore;
+    constructor(snapshot?: UserAdminSnapshot);
+    get schemas(): Record<UserAdminTableName, Readonly<TableSchema>>;
+    get tables(): UserAdminTables;
+    get menus(): {
+        clients: undefined;
+        group_roles: undefined;
+        groups: undefined;
+        roles: undefined;
+        user_group_roles: undefined;
+        user_groups: undefined;
+        users: undefined;
+    };
+    get visualLinks(): undefined;
+    get menuServices(): undefined;
+    get services(): Record<UserAdminTableName, RpcService[]>;
+    reconcile(): Promise<void>;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: import("@vuu-ui/vuu-data-types").EditSessionMode | import("@vuu-ui/vuu-data-types").CopyOption, dataSource: import("../ModuleDataSource").ModuleDataSource, sessionType?: import("@vuu-ui/vuu-data-types").SessionType): Table;
+    protected beforeSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    protected afterSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    private saveGroupsFromSession;
+    private saveGroupRoleAssignments;
+    private resolveGroupRoleAssignments;
+    private saveClientRolesFromSession;
+    private mutation;
+    private addUser;
+    private updateUser;
+    private deleteUser;
+    private addGroup;
+    private updateGroup;
+    private deleteGroup;
+    private addClient;
+    private updateClient;
+    private addRole;
+    private addClientRole;
+    private updateRole;
+    private assignGroupRole;
+    private removeGroupRole;
+    private assignUserToGroup;
+    private removeUserFromGroup;
+    private getUserModuleAccessOptions;
+    private setUserModuleAccess;
+    private assertUsernameIsUnique;
+}
+export declare const userAdminModule: UserAdminModule;
+export {};

package/src/user-admin/index.d.ts

@@ -0,0 +1,3 @@
+export { UserAdminModule, userAdminModule, } from "./UserAdminModule";
+export { USER_ADMIN_INITIAL_SNAPSHOT } from "./initialSnapshot";
+export { projectUserAdminSnapshot, reconcileUserAdminTables, } from "./snapshot-projection";

package/src/user-admin/initialSnapshot.d.ts

@@ -0,0 +1,2 @@
+import type { UserAdminSnapshot } from "@heswell/user-admin";
+export declare const USER_ADMIN_INITIAL_SNAPSHOT: UserAdminSnapshot;