@vuu-ui/vuu-data-test 4.0.0-alpha.24 → 4.0.0-alpha.26

package/src/basket/reference-data/constituents.js

@@ -1,8 +1,8 @@
-import constituents from "./constituents.js";
+import constituent_data from "./constituent-data.js";
 import { schemas } from "../basket-schemas.js";
-const basketConstituentData = constituents.map((constituent)=>{
+const basketConstituentData = constituent_data.map((constituent)=>{
     const values = constituent;
     return schemas.basketConstituent.columns.map(({ name })=>values[name]);
 });
-var reference_data_constituents = basketConstituentData;
-export default reference_data_constituents;
+var constituents = basketConstituentData;
+export default constituents;

package/types/src/ArrayProxy.d.ts

@@ -0,0 +1,8 @@
+export type RowAtIndexFunc<T = unknown> = (index: number) => T | undefined;
+export declare class ArrayProxy<T = string> {
+    #private;
+    length: number;
+    constructor(size: number, getRow: RowAtIndexFunc);
+    map: (func: (item: T, i: number) => unknown) => ArrayProxy<string>;
+    slice: (from: number, to: number) => unknown[];
+}

package/types/src/RuntimeVisualLink.d.ts

@@ -0,0 +1,9 @@
+import { DataSourceBase, DataSourceRowWithBigint, RowSelectionEventHandler } from "@vuu-ui/vuu-data-types";
+export declare class RuntimeVisualLink {
+    #private;
+    constructor(childDataSource: DataSourceBase<DataSourceRowWithBigint>, parentDataSource: DataSourceBase<DataSourceRowWithBigint>, childColumnName: string, parentColumnName: string);
+    destroy(): void;
+    remove(): void;
+    handleParentSelectEvent: RowSelectionEventHandler;
+    private pickUniqueSelectedValues;
+}

package/types/src/Table.d.ts

@@ -0,0 +1,34 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap, EventEmitter } from "@vuu-ui/vuu-utils";
+import { UpdateGenerator } from "./rowUpdates";
+export type TableEvents = {
+    delete: (key: string) => void;
+    insert: (row: Array<bigint | VuuRowDataItemType>) => void;
+    update: (row: Array<bigint | VuuRowDataItemType>, columnName?: string, sessionId?: string) => void;
+};
+export declare class Table extends EventEmitter<TableEvents> {
+    #private;
+    constructor(schema: TableSchema, data: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator);
+    private buildIndex;
+    get data(): (bigint | VuuRowDataItemType)[][];
+    get map(): ColumnMap;
+    get schema(): TableSchema;
+    get name(): string;
+    delete(key: string, emitEvent?: boolean): void;
+    insert(row: Array<bigint | VuuRowDataItemType>, emitEvent?: boolean): void;
+    findByKey(key: string): (bigint | VuuRowDataItemType)[];
+    update(key: string, columnName: string, value: bigint | VuuRowDataItemType): void;
+    updateRow(row: Array<bigint | VuuRowDataItemType>): void;
+}
+export declare function buildDataColumnMapFromSchema(schema: Readonly<TableSchema>): ColumnMap;
+/**
+ * Build a data ColumnMap for a table in the provided schema.
+ * A data ColumnMap is a mapping from a raw data array to a map, keyed
+ * by column name with no additional metadata.
+ *
+ * @param schemas
+ * @param tableName
+ * @returns
+ */
+export declare function buildDataColumnMap<TableName extends string = string>(schemas: Readonly<Record<TableName, Readonly<TableSchema>>>, tableName: TableName): ColumnMap;

package/types/src/TickingArrayDataSource.d.ts

@@ -0,0 +1,44 @@
+import { ArrayDataSource, type ArrayDataSourceConstructorProps } from "@vuu-ui/vuu-data-local";
+import type { DataSourceBase, DataSource, DataSourceRowWithBigint, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, DeleteRowMode, CopyOption, EditSessionMode, SessionDataSourceOverrides, SessionType } from "@vuu-ui/vuu-data-types";
+import type { LinkDescriptorWithLabel, RpcResult, RpcResultError, RpcResultSuccess, VuuCreateVisualLink, VuuMenu, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
+import type { IVuuModule, RpcMenuService, RpcService } from "./core/module/VuuModule";
+import type { Table } from "./Table";
+export type VisualLinkHandler = (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | void>;
+export interface TickingArrayDataSourceConstructorProps extends Omit<ArrayDataSourceConstructorProps, "data"> {
+    data?: Array<VuuRowDataItemType[]>;
+    getVisualLinks?: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
+    menu?: VuuMenu;
+    rpcMenuServices?: RpcMenuService[];
+    rpcServices?: RpcService[];
+    table?: Table;
+    visualLinkService?: VisualLinkHandler;
+    vuuModule?: IVuuModule;
+}
+export declare class TickingArrayDataSource extends ArrayDataSource {
+    #private;
+    constructor({ data, getVisualLinks, rpcServices, rpcMenuServices, session, table, menu, visualLink, visualLinkService, vuuModule, ...arrayDataSourceProps }: TickingArrayDataSourceConstructorProps);
+    updateRowWithSessionCheck: (row: Array<bigint | VuuRowDataItemType>, columnName?: string, sessionId?: string) => void;
+    subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    unsubscribe(): void;
+    set links(links: LinkDescriptorWithLabel[] | undefined);
+    get links(): LinkDescriptorWithLabel[] | undefined;
+    getSelectedRowIds(): string[];
+    isSessionDataSourceOf(dataSource: DataSource): boolean;
+    createSessionDataSource(copyOption: CopyOption, sessionType?: SessionType, overrides?: SessionDataSourceOverrides): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    beginEditSession(editSessionMode?: EditSessionMode, overrides?: SessionDataSourceOverrides): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultError | RpcResultSuccess>;
+    addRow: (rowData?: Record<string, VuuRowDataItemType>) => Promise<RpcResult>;
+    deleteRow: (key: string, mode?: DeleteRowMode) => Promise<true | string>;
+    deleteSelectedRows: (mode?: DeleteRowMode) => Promise<RpcResultSuccess | RpcResultError>;
+    undoRowChange: (key: string) => Promise<RpcResultSuccess | RpcResultError>;
+    set columns(columns: string[]);
+    get columns(): string[];
+    endEditSession(saveChanges?: boolean): Promise<void>;
+    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;
+    getTypeaheadSuggestions(column: string, pattern?: string): Promise<string[]>;
+    get visualLink(): LinkDescriptorWithLabel | undefined;
+    set visualLink(visualLink: LinkDescriptorWithLabel | undefined);
+    freeze(): void;
+    unfreeze(): void;
+}

package/types/src/UpdateGenerator.d.ts

@@ -0,0 +1,18 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+import type { UpdateGenerator } from "./rowUpdates";
+import { Table } from "./Table";
+export declare class BaseUpdateGenerator implements UpdateGenerator {
+    private table;
+    private range;
+    private updating;
+    private timer;
+    private tickingColumns;
+    constructor(tickingColumns: {
+        [key: string]: number;
+    });
+    setRange(range: VuuRange): void;
+    setTable(table: Table): void;
+    private startUpdating;
+    private stopUpdating;
+    update: () => void;
+}

package/types/src/basket/BasketModule.d.ts

@@ -0,0 +1,55 @@
+import { VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { RpcMenuService, ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import { BasketsTableName } from "./basket-schemas";
+import { type Table } from "../Table";
+export declare const createBasketTradingRow: (basketId: string, basketName: string, side?: string, status?: string) => (string | number)[];
+/**
+ * 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 BasketModule extends VuuModule<BasketsTableName> {
+    #private;
+    constructor();
+    get menus(): Record<BasketsTableName, VuuMenu | undefined>;
+    get schemas(): Readonly<Record<BasketsTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
+    get services(): {
+        algoType: undefined;
+        basketTradingConstituent: undefined;
+        basketConstituent: undefined;
+        priceStrategyType: undefined;
+        basket: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+        basketTrading: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+        basketTradingConstituentJoin: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+    };
+    get menuServices(): Record<BasketsTableName, RpcMenuService[] | undefined> | undefined;
+    get tables(): Record<BasketsTableName, Table>;
+    get visualLinks(): {
+        algoType: undefined;
+        basket: undefined;
+        basketTrading: undefined;
+        basketTradingConstituent: undefined;
+        basketTradingConstituentJoin: undefined;
+        priceStrategyType: undefined;
+        basketConstituent: {
+            fromColumn: string;
+            toColumn: string;
+            toTable: string;
+        }[];
+    };
+    private createTradingBasket;
+    private createNewBasket;
+    private sendToMarket;
+    private takeOffMarket;
+    private addConstituent;
+}
+export declare const basketModule: BasketModule;

package/types/src/basket/basket-schemas.d.ts

@@ -0,0 +1,9 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type BasketsTableName = "algoType" | "basket" | "basketConstituent" | "basketTrading" | "basketTradingConstituent" | "basketTradingConstituentJoin" | "priceStrategyType";
+export declare const schemas: Readonly<Record<BasketsTableName, Readonly<TableSchema>>>;
+export type BasketVuuTable = {
+    module: "BASKET";
+    table: BasketsTableName;
+};
+export declare const isBasketTable: (table: VuuTable) => table is BasketVuuTable;

package/types/src/basket/index.d.ts

@@ -0,0 +1,2 @@
+export { type BasketsTableName, schemas as basketSchemas, isBasketTable, } from "./basket-schemas";
+export { basketModule } from "./BasketModule";

package/types/src/basket/reference-data/constituents.d.ts

@@ -0,0 +1,3 @@
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+declare const _default: VuuRowDataItemType[][];
+export default _default;

package/types/src/basket/reference-data/ftse100.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[][];
+export default _default;

package/types/src/basket/reference-data/hsi.d.ts

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

package/types/src/basket/reference-data/nasdaq100.d.ts

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

package/types/src/basket/reference-data/prices.d.ts

@@ -0,0 +1,24 @@
+export type ask = number;
+export type askSize = number;
+export type bid = number;
+export type bidSize = number;
+export type close = number;
+export type last = number;
+export type open = number;
+export type phase = "C";
+export type ric = string;
+export type scenario = "close";
+export type PricesDataRow = [
+    ask,
+    askSize,
+    bid,
+    bidSize,
+    close,
+    last,
+    open,
+    phase,
+    ric,
+    scenario
+];
+declare const pricesTable: import("../..").Table;
+export default pricesTable;

package/types/src/basket/reference-data/sp500.d.ts

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

package/types/src/core/module/ModuleContainer.d.ts

@@ -0,0 +1,11 @@
+import { VuuModule } from "./VuuModule";
+declare class ModuleContainer {
+    #private;
+    private constructor();
+    static get instance(): ModuleContainer;
+    register(module: VuuModule<any>): void;
+    get(name: string): VuuModule<string>;
+    get moduleNames(): MapIterator<string>;
+}
+declare const _default: ModuleContainer;
+export default _default;

package/types/src/core/module/VuuModule.d.ts

@@ -0,0 +1,81 @@
+import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, CopyOption, SessionDataSourceOverrides, SessionType, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
+import { Table } from "../../Table";
+import { TickingArrayDataSource } from "../../TickingArrayDataSource";
+export interface IVuuModule<T extends string = string> {
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
+        session?: SessionDataSourceOverrides;
+    }) => DataSourceBase<DataSourceRowWithBigint>;
+}
+export type SessionTableMap = Record<string, Table>;
+export type ServiceHandler = (rpcRequest: VuuRpcServiceRequest) => Promise<RpcResultSuccess | RpcResultError>;
+export type MenuServiceHandler = (rpcRequest: VuuRpcMenuRequest) => Promise<VuuRpcMenuResponse>;
+export type RpcService = {
+    rpcName: string;
+    service: ServiceHandler;
+};
+export type RpcMenuService = {
+    rpcName: string;
+    service: MenuServiceHandler;
+};
+export type VuuModuleOptions = {
+    /** Column written by session services (deleteRow, endEditSession) to report row-level status.
+     *  Defaults to `"vuuMsg"` which matches the column added by `sessionTableSchema`. */
+    sessionTableMessageColumn?: string;
+};
+type Subscription = {
+    viewportId: string;
+    dataSource: DataSourceBase<DataSourceRowWithBigint>;
+    sessionTableName?: string;
+    sourceTableName?: string;
+};
+export declare abstract class VuuModule<T extends string = string> implements IVuuModule<T> {
+    #private;
+    constructor(name: string, { sessionTableMessageColumn }?: VuuModuleOptions);
+    protected abstract menus?: Record<T, VuuMenu | undefined> | undefined;
+    protected abstract schemas: Record<T, Readonly<TableSchema>>;
+    protected abstract tables: Record<T, Table>;
+    protected abstract menuServices?: Record<T, RpcMenuService[] | undefined> | undefined;
+    protected abstract services?: Record<T, RpcService[] | undefined> | undefined;
+    protected abstract visualLinks?: Record<T, VuuLink[] | undefined>;
+    getTableSchema(tableName: string): Record<T, Readonly<TableSchema>>[T];
+    getTableList(): string[];
+    protected handlePostSubscribeActivities: ({ clientViewportId, tableSchema, }: DataSourceSubscribedMessage) => void;
+    protected unregisterViewport: (viewportId: string) => void;
+    get name(): string;
+    getSubscriptionByViewport(viewportId: string): Subscription;
+    getSubscribedDataSource(vpId: string): DataSourceBase<DataSourceRowWithBigint>;
+    getLinks: (subscriptionMap: Map<string, Subscription[]>, vuuLinks: VuuLink[]) => LinkDescriptorWithLabel[];
+    visualLinkService: (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | void>;
+    getVisualLinks: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
+        session?: SessionDataSourceOverrides;
+    }) => DataSourceBase<DataSourceRowWithBigint>;
+    getServices(tableName: T): RpcService[];
+    getMenuServices(tableName: T): RpcMenuService[];
+    protected get sessionTableMap(): SessionTableMap;
+    protected getSessionTable(sessionTableName: string): Table;
+    protected getSessionTable(sessionTableName: string, throwIfNotFound: true): Table;
+    protected getSessionTable(sessionTableName: string, throwIfNotFound: false): Table | undefined;
+    protected deleteRow: ServiceHandler;
+    private deleteSelectedRows;
+    private undoRowChange;
+    private getColumnDescriptors;
+    private editCell;
+    private beginEditSessionMenuHandler;
+    /**
+     * Creates a standalone session table.
+     * The `copyOption` determines which rows are copied into the session table.
+     * Returns the session table reference so the caller can subscribe to it.
+     */
+    private createSessionTableService;
+    private beginEditSession;
+    private addRow;
+    private endEditSession;
+    private applyBulkEdits;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: EditSessionMode | CopyOption, dataSource: TickingArrayDataSource, sessionType?: SessionType): Table;
+    protected createSessionTableWithAllRows({ data, schema }: Table, _sessionTableName: string): Table;
+    protected createEmptySessionTable({ schema }: Table, sessionTableName: string, sessionType?: SessionType): Table;
+    protected createSessionTableFromSelectedRows({ data, map, schema }: Table, sessionTableName: string, dataSource: TickingArrayDataSource): Table;
+}
+export {};

package/types/src/core/table/TableContainer.d.ts

@@ -0,0 +1,16 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { Table } from "../../Table";
+import { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "@vuu-ui/vuu-utils";
+import { UpdateGenerator } from "../../rowUpdates";
+declare class TableContainer {
+    #private;
+    private constructor();
+    static get instance(): TableContainer;
+    createTable: (schema: TableSchema, data: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
+    createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
+    addTable(table: Table): void;
+    getTable<T = Table>(tableName: string): NonNullable<T>;
+}
+declare const _default: TableContainer;
+export default _default;

package/types/src/data-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function random(min: number, max: number): number;
+export declare function randomPercentage(value: number): number;
+export type PriceGenerator = (min: number, max: number) => number;
+export declare const nextRandomDouble: PriceGenerator;
+export declare const initBidAsk: (priceMaxDelta: number, nextRandomDouble: PriceGenerator) => number[];
+export declare const generateNextBidAsk: (bid: number, ask: number, spreadMultipler: number, priceMaxDelta: number, nextRandomDouble: PriceGenerator) => number[];
+export declare const withNanoMs: (ts: number, nanos?: number) => bigint;

package/types/src/default-column-definitions.d.ts

@@ -0,0 +1,2 @@
+import { SchemaColumn } from "@vuu-ui/vuu-data-types";
+export declare const VUU_DEFAULT_COLUMNS: SchemaColumn[];

package/types/src/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./ArrayProxy";
+export * from "./core/module/VuuModule";
+export { default as tableContainer } from "./core/table/TableContainer";
+export * from "./local-datasource-provider/LocalDatasourceProvider";
+export * from "./makeSuggestions";
+export * from "./schemas";
+export * from "./simul";
+export * from "./basket";
+export { buildDataColumnMap, buildDataColumnMapFromSchema, Table, type TableEvents, } from "./Table";
+export * from "./test";
+export * from "./TickingArrayDataSource";
+export * from "./vuu-row-generator";

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

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+export declare const LocalDataSourceProvider: ({ children, }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;

package/types/src/makeSuggestions.d.ts

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

package/types/src/rowUpdates.d.ts

@@ -0,0 +1,15 @@
+import { VuuRange, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { 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/types/src/schemas.d.ts

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

package/types/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/types/src/simul/SimulModule.d.ts

@@ -0,0 +1,24 @@
+import { VuuLink, VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { MenuServiceHandler, RpcMenuService, RpcService, ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import { 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/types/src/simul/index.d.ts

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

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

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

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

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

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

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

package/types/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/types/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/types/src/simul/reference-data/instruments-extended.d.ts

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

package/types/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/types/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/types/src/simul/reference-data/isin-generator/fixtures/alphabet.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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