@genesislcap/foundation-comms 14.167.1 → 14.167.3-alpha-b40d1e5.0

package/dist/foundation-comms.d.ts

@@ -2,6 +2,7 @@
 
 import { AppIntent } from '@finos/fdc3';
 import { BehaviorSubject } from 'rxjs';
+import { default as Bowser_2 } from 'bowser';
 import { Channel } from '@finos/fdc3';
 import { Context } from '@finos/fdc3';
 import { ContextHandler } from '@finos/fdc3';
@@ -11,11 +12,14 @@ import { Intents } from '@finos/fdc3';
 import { InterfaceSymbol } from '@microsoft/fast-foundation';
 import { JSONSchema7 } from 'json-schema';
 import { JSONSerializer } from '@genesislcap/foundation-utils';
+import { Listener } from '@genesislcap/foundation-utils';
 import { Logger } from '@genesislcap/foundation-logger';
 import { Observable } from 'rxjs';
-import { Observer } from 'rxjs';
+import { Observer } from '@genesislcap/foundation-utils';
+import { Observer as Observer_2 } from 'rxjs';
 import { Subscription as SocketSubscription } from 'rxjs';
 import { Subject } from 'rxjs';
+import { UUID } from '@genesislcap/foundation-utils';
 
 /**
  * Auth is the main interface for authenticating with a Genesis Server endpoint.
@@ -148,6 +152,24 @@ export declare type BasicCredentialsInput = {
     password: string;
 };
 
+/**
+ * @public
+ */
+export declare type CommitEvent = CustomEvent<CommitEventDetail>;
+
+/**
+ * @public
+ */
+export declare type CommitEventDetail = {
+    eventName: string;
+    message: Message;
+};
+
+/**
+ * @public
+ */
+export declare const CommitEventType = "connect-commit-event";
+
 /**
  * Parameters for a COMMIT message
  * @public
@@ -245,6 +267,13 @@ export declare interface Connect {
      * @returns A promise that resolves with the additional rows of data.
      */
     getMoreRows(sourceRef: string): Promise<Message>;
+    /**
+     * Requests additional columns for the specified source reference.
+     * @public
+     * @param sourceRef - The source reference to request more columns for.
+     * @returns A promise that resolves with the additional columns.
+     */
+    getMoreColumns(sourceRef: string): Promise<Message>;
     /**
      * Logs off from the specified data source.
      * @public
@@ -318,6 +347,85 @@ export declare interface ConnectConfig {
  */
 export declare const ConnectConfig: InterfaceSymbol<ConnectConfig>;
 
+/**
+ * `ConnectEvents` provide hooks to respond to specific connect events.
+ *
+ * @public
+ */
+export declare interface ConnectEvents {
+    /**
+     * Add a stream listener.
+     * @param listener - A listener callback function.
+     * @param complete - A complete listener callback function.
+     */
+    addStreamListener(listener: Listener<StreamEvent>, complete: Listener<StreamCompleteEvent>): () => void;
+    /**
+     * Add a commit listener.
+     * @param listener - A listener callback function.
+     */
+    addCommitListener(listener: Listener<CommitEvent>): () => void;
+    /**
+     * Add a metadata listener.
+     * @param listener - A listener callback function.
+     */
+    addMetadataListener(listener: Listener<MetadataEvent>): () => void;
+}
+
+/**
+ * ConnectEvents DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export declare const ConnectEvents: InterfaceSymbol<ConnectEvents>;
+
+/**
+ * `ConnectEventsEmitter` provide event emitting hooks to Connect.
+ *
+ * @public
+ */
+export declare interface ConnectEventsEmitter extends ConnectEvents {
+    /**
+     * Called by Connect.
+     * @param resourceName - The name of the resource.
+     * @param message - The message.
+     * @param stream - The actual stream itself.
+     * @param functions - Any functions provided.
+     */
+    onStreamEvent(resourceName: string, message: Message<MessageDetails.DataserverRequest>, stream: SocketObservable<any>, functions: StreamEventFunctions): void;
+    /**
+     * Called by Connect.
+     * @param stream - The actual stream itself.
+     */
+    onStreamCompleteEvent(stream: SocketObservable<any>): void;
+    /**
+     * Called by Connect.
+     * @param eventName - The name of the event.
+     * @param message - The message.
+     */
+    onCommitEvent(eventName: string, message: Message): void;
+    /**
+     * Called by Connect.
+     * @param resourceName - The name of the resource.
+     * @param message - The message.
+     * @param error - Optional error.
+     */
+    onMetadataEvent(resourceName: string, message: Message<MessageDetails.MetaRequest>, error?: any): void;
+}
+
+/**
+ * ConnectEventsEmitter DI key.
+ *
+ * @privateRemarks
+ * ConnectEventsEmitter is used by Connect.
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export declare const ConnectEventsEmitter: InterfaceSymbol<ConnectEventsEmitter>;
+
 /**
  * The connection status of the Genesis client.
  * @public
@@ -349,6 +457,7 @@ export declare class ConnectMock implements Connect {
     snapshot(resourceName: string, params?: any): Promise<Message>;
     stream(resourceName: string, onMessage: Function, onError: Function, params?: any): SocketObservable<Message>;
     getMoreRows(sourceRef: string): Promise<Message<any>>;
+    getMoreColumns(sourceRef: string): Promise<Message<any>>;
     dataLogoff(sourceRef: string): Promise<Message<any>>;
     getJSONSchema(resourceName: string): Promise<any>;
 }
@@ -641,6 +750,8 @@ export declare class CurrentUser implements User {
     profiles: UserProfile[];
     username: string;
     constructor(options: UserOptions);
+    set(options: UserOptions): void;
+    unset(): void;
     hasAdminProfile(): boolean;
     hasPermission(permission: string | string[]): boolean;
     hasProfile(profile: string | string[]): boolean;
@@ -801,6 +912,13 @@ export declare interface Datasource {
      * @returns A promise that resolves when the item has been updated.
      */
     updateItem?(itemId: string, data: any): Promise<void>;
+    /**
+     * Destroy the datasource.
+     * @privateRemarks
+     * I suspect we may need to call this from datasource disconnectedCallbacks etc to ensure we fully clean up.
+     * @public
+     */
+    destroy(): void;
 }
 
 /**
@@ -852,6 +970,7 @@ export declare class DatasourceMock implements Datasource {
     stream: SocketObservable<FilteredDataServerResult | RequestServerResult>;
     init(options: DatasourceOptions, fetchMeta: boolean): Promise<boolean>;
     deinit(): void;
+    destroy(): void;
     validResourceName(resourceName: string): boolean;
     getMetadata?(resourceName: string): Promise<FieldMetadata[]>;
     snapshot(params?: any): void;
@@ -1009,12 +1128,13 @@ export declare class DefaultConnect implements Connect {
     socket: Socket;
     private messageBuilder;
     private metaCache;
+    private events;
     private config;
     isWorking: boolean;
     get isConnected(): boolean;
     get isConnectedSubject(): BehaviorSubject<boolean>;
     get isConnected$(): Observable<boolean>;
-    constructor(socket: Socket, messageBuilder: MessageBuilder, metaCache: MetaCache, config?: ConnectConfig);
+    constructor(socket: Socket, messageBuilder: MessageBuilder, metaCache: MetaCache, events: ConnectEventsEmitter, config?: ConnectConfig);
     httpMode(): boolean;
     setValidSession(valid: boolean): void;
     send<T>(message: Message<any>, needsHandling?: boolean): Promise<any>;
@@ -1023,6 +1143,7 @@ export declare class DefaultConnect implements Connect {
     snapshot(resourceName: string, params?: any): Promise<Message>;
     stream(resourceName: string, onMessage: Function, onError: Function, params?: any): SocketObservable<Message>;
     getMoreRows(sourceRef: string): Promise<Message>;
+    getMoreColumns(sourceRef: string): Promise<Message>;
     dataLogoff(streamSourceRef: string): Promise<Message>;
     getMetadata(resourceName: string, useCache?: boolean): Promise<Metadata>;
     getJSONSchema(resourceName: string, useCache?: boolean): Promise<SchemaResponse>;
@@ -1037,6 +1158,35 @@ export declare class DefaultConnect implements Connect {
  */
 export declare const defaultConnectConfig: ConnectConfig;
 
+/**
+ * Default ConnectEvents implementation.
+ * @public
+ */
+export declare class DefaultConnectEvents implements ConnectEventsEmitter {
+    /** @internal */
+    protected streamListeners: Observer<StreamEvent>;
+    /** @internal */
+    protected streamCompleteListeners: Observer<StreamCompleteEvent>;
+    /** {@inheritDoc ConnectEvents.addStreamListener} */
+    addStreamListener(listener: Listener<StreamEvent>, complete: Listener<StreamCompleteEvent>): () => void;
+    /** {@inheritDoc ConnectEventsEmitter.onStreamEvent} */
+    onStreamEvent(resourceName: string, message: Message<MessageDetails.DataserverRequest>, stream: SocketObservable<any>, functions: StreamEventFunctions): void;
+    /** {@inheritDoc ConnectEventsEmitter.onStreamCompleteEvent} */
+    onStreamCompleteEvent(stream: SocketObservable<any>): void;
+    /** @internal */
+    protected commitListeners: Observer<CommitEvent>;
+    /** {@inheritDoc ConnectEvents.addCommitListener} */
+    addCommitListener(listener: Listener<CommitEvent>): () => void;
+    /** {@inheritDoc ConnectEventsEmitter.onStreamEvent} */
+    onCommitEvent(eventName: string, message: Message): void;
+    /** @internal */
+    protected metadataListeners: Observer<MetadataEvent>;
+    /** {@inheritDoc ConnectEvents.addMetadataListener} */
+    addMetadataListener(listener: Listener<MetadataEvent>): () => void;
+    /** {@inheritDoc ConnectEventsEmitter.onMetadataEvent} */
+    onMetadataEvent(resourceName: string, message: Message<MessageDetails.MetaRequest>, error?: any): void;
+}
+
 /**
  * The default implementation for the CredentialManager interface.
  * @public
@@ -1105,6 +1255,8 @@ export declare class DefaultDatasource implements Datasource {
     validResourceName(resourceName: string): boolean;
     init(options: DatasourceOptions, fetchMeta?: boolean): Promise<boolean>;
     deinit(): void;
+    /** {@inheritDoc Datasource.destroy} */
+    destroy(): void;
     get stream(): SocketObservable<FilteredDataServerResult | RequestServerResult>;
     get params(): any;
     snapshot(): Promise<Message>;
@@ -1147,6 +1299,23 @@ export declare class DefaultEntityDatasource<TDTO, TEntity> extends DefaultDatas
     protected processRowDataUpdate(rowData: RowData[], inserting?: boolean): void;
 }
 
+/**
+ * The FDC3 implementation.
+ * @internal
+ */
+export declare class DefaultFDC3 implements FDC3_2 {
+    isReady: boolean;
+    constructor();
+    private connect;
+    addIntentListeners(listeners: Map<FDC3Intents, FDC3ContextHandler>): void;
+    findIntent(intent: FDC3Intents, context?: FDC3Context): Promise<FDC3AppIntent>;
+    findIntentsByContext(context: FDC3Context): Promise<FDC3AppIntent[]>;
+    raiseIntent(context: FDC3Context, intent?: FDC3Intents): Promise<FDC3IntentResolution>;
+    joinChannel(channelId: string): Promise<void>;
+    getOrCreateChannel(channelId: string): Promise<FDC3Channel>;
+    broadcastOnChannel(channelId: string, context: FDC3Context): Promise<void>;
+}
+
 /**
  * The default implementation for the FoundationAnalytics interface.
  * @public
@@ -1221,6 +1390,7 @@ export declare class DefaultHttpConnect implements Connect {
     stream(resourceName: string, onMessage: Function, onError: Function, params?: any): SocketObservable<Message>;
     private getMessage;
     getMoreRows(sourceRef: string): Promise<Message>;
+    getMoreColumns(sourceRef: string): Promise<Message>;
     dataLogoff(streamSourceRef: string): Promise<Message>;
     getMetadata(resourceName: string, useCache?: boolean): Promise<Metadata>;
     getJSONSchema(resourceName: string): Promise<SchemaResponse>;
@@ -1322,6 +1492,38 @@ export declare class DefaultKVStorage implements KVStorage {
  */
 export declare const defaultKVStorageConfig: KVStorageConfig;
 
+/**
+ * TODO: Abstract out localStorage interaction with shell io stuff
+ */
+/**
+ * Default MessageBuilder implementation.
+ * @public
+ */
+export declare class DefaultMessageBuilder implements MessageBuilder {
+    private session;
+    private uuid;
+    /**
+     * UUID will be created in the DI with the App specific requirements.
+     * Keeping it encapsulated means messages will always conform.
+     */
+    constructor(session: Session, uuid: UUID);
+    createLoginMessage(credentials: AuthInfo): Message<MessageDetails.Login>;
+    createLogoutMessage(loginResult?: LoginResult): Message;
+    createDataLogonMessage(resourceName: string, params?: any): Message<MessageDetails.DataserverRequest>;
+    createDataLogoffMessage<T = any>(sourceRef: string): Message<T>;
+    createRequestMessage<T = any>(resourceName: string, params?: RequestParams): Message<T>;
+    createResourcesMessage<T = any>(params?: RequestParams): Message<T>;
+    createMetaRequestMessage(resourceName: string, messageType?: EventMessageType): Message<MessageDetails.MetaRequest>;
+    createCommitMessage<T = any>(eventName: string, params?: CommitParams): Message<T>;
+    createRefreshTokenMessage(): Message<MessageDetails.RefreshToken>;
+    createChangePasswordMessage(username: string, oldPassword: string, newPassword: string): Message<MessageDetails.ChangePassword>;
+    createForgotPasswordMessage(username: string, returnUrl: string, requester?: string): Message<MessageDetails.ForgotPassword>;
+    createForgotPasswordTokenMessage(username: string, resetToken: string, newPassword: string, requester?: string): Message<MessageDetails.ForgotPasswordToken>;
+    createMoreRowsMessage(sourceRef: string): Message;
+    createMoreColumnsMessage(sourceRef: string): Message;
+    createHTTPHeadersFromMessage(message: Message, contentType?: string): HeadersInit;
+}
+
 /**
  * The default implementation for the MetaCache interface.
  * @public
@@ -1337,6 +1539,144 @@ export declare class DefaultMetaCache implements MetaCache {
     setJsonSchemaFor(resourceName: string, schemaResponse: SchemaResponse): void;
 }
 
+/**
+ * Default NetworkMonitor implementation.
+ * @public
+ */
+export declare class DefaultNetworkMonitor implements NetworkMonitor {
+    /**
+     * High-level configuration.
+     * @internal
+     */
+    protected config: NetworkMonitorConfig;
+    /**
+     * @internal
+     */
+    protected socketStatus: SocketStatus;
+    /**
+     * @internal
+     */
+    protected connectEvents: ConnectEvents;
+    /**
+     * @internal
+     */
+    protected user: User;
+    /**
+     * @internal
+     */
+    protected unsubscribableObservers: any[];
+    /**
+     * @privateRemarks
+     * Originally aimed to use WeakMap for resources, but need to iterate and process these. I also had a
+     * `this.registry = new FinalizationRegistry<any>(this.registryCleanup);` in the mix to handle clean up actions.
+     *
+     * @internal
+     */
+    protected resources: Map<MonitoredResource, MonitoredResourceMetadata>;
+    /**
+     * @internal
+     */
+    protected internalId: ReturnType<typeof setInterval>;
+    /**
+     * @internal
+     */
+    protected isRunningChecks: boolean;
+    /**
+     * {@inheritDoc NetworkMonitor.status}
+     */
+    status: SystemHealthStatus;
+    /**
+     * {@inheritDoc NetworkMonitor.create}
+     */
+    create(): void;
+    /**
+     * {@inheritDoc NetworkMonitor.destroy}
+     */
+    destroy(): void;
+    /**
+     * @internal
+     */
+    protected isOnlineCheck(): Promise<boolean>;
+    /**
+     * {@inheritDoc NetworkMonitor.runAllChecks}
+     */
+    runAllChecks: (source?: unknown, force?: boolean) => Promise<void>;
+    /**
+     * {@inheritDoc NetworkMonitor.addResource}
+     */
+    addResource(resource: MonitoredResource, metadata: MonitoredResourceMetadata): void;
+    /**
+     * {@inheritDoc NetworkMonitor.removeResource}
+     */
+    removeResource(resource: MonitoredResource): void;
+    /**
+     * @internal
+     */
+    protected addListeners(): void;
+    /**
+     * @internal
+     */
+    protected removeListeners(): void;
+    /**
+     * @internal
+     */
+    protected reportSystemHealth(detail: Partial<SystemHealthStatus>): void;
+    /**
+     * @internal
+     */
+    protected reportStabilityToGenesis(detail: Partial<SystemHealthStatus>): Promise<boolean>;
+    /**
+     * @remarks
+     * Deal with false positives.
+     *
+     * @privateRemarks
+     * There's an argument here for and against normalising ResourceHealth. I think it's more useful to consumers like
+     * visual overlays if there is no conflicting information. If we're offline and using the cache, then that should be
+     * reflected here.
+     *
+     * @internal
+     */
+    protected normaliseResourceHealth(health: ResourceHealth, isOnline?: boolean): ResourceHealth;
+    /**
+     * @remarks
+     * Deal with false positives.
+     *
+     * @privateRemarks
+     * There's an argument here for and against a normalised SerializedSocketStatus. I think it's more useful to consumers
+     * like visual overlays if there is no conflicting information. If we're offline and using the cache, then that
+     * should be reflected here.
+     *
+     * @internal
+     */
+    protected normaliseSerializedSocketStatus(socketStatus: SerializedSocketStatus, isOnline?: boolean): SerializedSocketStatus;
+    /**
+     * @internal
+     */
+    protected normaliseEventDetail(detail: Partial<SystemHealthStatus>): SystemHealthStatus;
+    /**
+     * @internal
+     */
+    protected getFormattedTimestamp(milliseconds: number): string;
+    /**
+     * @internal
+     */
+    protected getNowTimestamp(): number;
+    /**
+     * @internal
+     */
+    protected getNextTimestamp(): number;
+    /**
+     * @internal
+     */
+    protected synchroniseCheckInterval(): void;
+}
+
+/**
+ * Default NetworkMonitorConfig DI implementation.
+ * @public
+ */
+export declare const defaultNetworkMonitorConfig: NetworkMonitorConfig;
+
 /**
  * The default implementation for the Session interface.
  * @public
@@ -1363,6 +1703,79 @@ export declare class DefaultSession implements Session {
     removeSessionStorageItem(key: string | UserInfoKeys): void;
 }
 
+/**
+ * Default Socket implementation.
+ * @public
+ */
+export declare class DefaultSocket implements Socket {
+    private messageBuilder;
+    private session;
+    private serializer;
+    private uuid;
+    private status;
+    private readonly defaultInterval;
+    private readonly secondsMultiplier;
+    private websocket;
+    private wsMessages;
+    private wsMessageHandlers;
+    get isConfigured(): boolean;
+    get isConnecting(): boolean;
+    get isConnected(): boolean;
+    get isConnectedSubject(): BehaviorSubject<boolean>;
+    get isDisconnected(): boolean;
+    get isDisconnectedByServer(): boolean;
+    get isReconnecting(): boolean;
+    get hasValidSession(): boolean;
+    set hasValidSession(value: boolean);
+    private heartbeatIsEnabled;
+    private heartbeatInterval;
+    private heartbeatTicker;
+    private url;
+    private connectOptions;
+    private reconnectOptions;
+    private socketSubscription;
+    constructor(messageBuilder: MessageBuilder, session: Session, serializer: JSONSerializer, uuid: UUID, status: SocketStatus);
+    private get heartbeatLoggingIsEnabled();
+    private get messageLoggingIsEnabled();
+    connect(host: string, connectOptions?: SocketConnectOptions, reconnectOptions?: SocketReconnectOptions): Promise<boolean>;
+    private prepareHeartbeat;
+    private reconnect;
+    reset(): void;
+    private cleanMessages;
+    send<T>(message: Message<T | any>, needsHandling?: boolean): Promise<Message | any>;
+    sendForStream<T>(message: Message<T | any>, onMessage: Function, onError: Function, onComplete?: Function): Observable<Message>;
+    socketMessages: () => SocketSubject<Message>;
+    private setMessageHandler;
+    private sendDataLogoff;
+    private removeMessageHandler;
+    private getMessageHandler;
+    private logMessageTypeFlow;
+}
+
+/**
+ * Default SocketStatus implementation.
+ * @public
+ */
+export declare class DefaultSocketStatus implements SocketStatus {
+    isConfigured: boolean;
+    isConnecting: boolean;
+    isConnected: boolean;
+    isReconnecting: boolean;
+    reconnectionLimitReached: boolean;
+    hasValidSession: boolean;
+    closedCode: any;
+    closedReason: any;
+    closedClean: any;
+    get isDisconnected(): boolean;
+    get isDisconnectedByServer(): boolean;
+    isConnectedSubject: BehaviorSubject<boolean>;
+    protected isConnectedChanged(): void;
+    protected isReconnectingChanged(): void;
+    protected resetClosedState(): void;
+    serialize(): SerializedSocketStatus;
+    onClose(event: CloseEvent): void;
+}
+
 /**
  * EntityDatasource DI interface.
  *
@@ -1521,7 +1934,7 @@ export declare const exponentialScheduler: SocketReconnectScheduler;
 export declare const extractFieldDefinitions: (metadata: Metadata) => MetadataDetail[];
 
 /**
- * The DI token for the FDC3Service interface.
+ * The DI token for the FDC3 interface.
  * @internal
  */
 export declare const FDC3: InterfaceSymbol<FDC3_2>;
@@ -1590,7 +2003,7 @@ declare interface FDC3_2 {
 }
 
 /**
- * The DI token for the FDC3Service interface.
+ * The DI token for the FDC3 interface.
  * @internal
  */
 declare const FDC3: InterfaceSymbol<FDC3_2>;
@@ -1733,6 +2146,17 @@ export declare enum FoundationAnalyticsEventType {
     routeChanged = "routeChanged"
 }
 
+/**
+ * Genesis connect events that can be monitored to invoke resource checking.
+ *
+ * @remarks
+ * 'steam' and 'commit' are monitored by default and will invoke resource checking. 'metadata' request failures are
+ * monitored for the purpose of surfacing such errors to the console only. For now, 'metadata' errors are unrecoverable.
+ *
+ * @public
+ */
+export declare type GenesisConnectEvents = 'stream' | 'commit';
+
 /**
  * Get Connect from the DI container.
  *
@@ -1791,6 +2215,57 @@ export declare type GetCredentialOptions = CredentialRequestOptions & {};
  */
 export declare function getDatasource(): Datasource;
 
+/**
+ * Gets NetworkMonitor from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getNetworkMonitor } from '@genesislcap/foundation-comms';
+ * ...
+ * private monitor = getNetworkMonitor();
+ * ```
+ *
+ * @public
+ */
+export declare function getNetworkMonitor(): NetworkMonitor;
+
+/**
+ * Gets Socket from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getSocket } from '@genesislcap/foundation-comms';
+ * ...
+ * private socket = getSocket();
+ * ```
+ *
+ * @public
+ */
+export declare function getSocket(): Socket;
+
+/**
+ * Gets SocketStatus from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getSocketStatus } from '@genesislcap/foundation-comms';
+ * ...
+ * private socketStatus = getSocketStatus();
+ * ```
+ *
+ * @public
+ */
+export declare function getSocketStatus(): SocketStatus;
+
 /**
  * An interface representing an HTTP client that can make GET and POST requests and return a promise with the response data.
  * @public
@@ -2184,6 +2659,15 @@ export declare interface MessageBuilder {
      * @returns The more rows message.
      */
     createMoreRowsMessage(sourceRef: string): Message;
+    /**
+     * Creates a message to request more columns.
+     *
+     * @remarks MORE_COLUMNS
+     * @public
+     * @param sourceRef - The source reference.
+     * @returns The more columns message.
+     */
+    createMoreColumnsMessage(sourceRef: string): Message;
     /**
      * Creates a request message.
      *
@@ -2431,6 +2915,14 @@ export declare type MessageError = {
     TEXT: string;
 };
 
+/**
+ * Check if the message contains an error code.
+ * @param message - The message object.
+ * @param code - The error code.
+ * @public
+ */
+export declare const messageHasErrorCode: (message: Message, code: string | number) => boolean;
+
 /**
  * Check if the provided message contains an error and throw an Error if it does
  * @public
@@ -2451,6 +2943,8 @@ export declare enum MessageType {
     HEARTBEAT_PING = "HEARTBEAT_PING",
     HEARTBEAT_PONG = "HEARTBEAT_PONG",
     MORE_ROWS = "MORE_ROWS",
+    MORE_COLUMNS = "MORE_COLUMNS",
+    MORE_COLUMNS_ACK = "MORE_COLUMNS_ACK",
     MSG_ACK = "MSG_ACK",
     MSG_NACK = "MSG_NACK",
     LOGOUT_ACK = "LOGOUT_ACK",
@@ -2530,6 +3024,158 @@ export declare type MetadataDetail = {
     UI_LABEL?: string;
 };
 
+/**
+ * @public
+ */
+export declare type MetadataEvent = CustomEvent<MetadataEventDetail>;
+
+/**
+ * @public
+ */
+export declare type MetadataEventDetail = {
+    resourceName: string;
+    message: Message<MessageDetails.MetaRequest>;
+    error?: any;
+};
+
+/**
+ * @public
+ */
+export declare const MetadataEventType = "connect-metadata-event";
+
+/**
+ * MonitoredResource.
+ * @public
+ */
+export declare type MonitoredResource = SocketObservable<any>;
+
+/**
+ * MonitoredResourceChecks.
+ * @param sourceRef - The resource source ref.
+ * @param resource - The resource reference.
+ * @public
+ */
+export declare type MonitoredResourceChecks = (sourceRef: string, resource: MonitoredResource) => Promise<MonitoredResourceChecksResult>;
+
+/**
+ * MonitoredResourceChecksResult.
+ * @public
+ */
+export declare interface MonitoredResourceChecksResult {
+    isConnected: boolean;
+    lastUpdated: number;
+    lastMessage?: Message;
+    timeout?: boolean;
+}
+
+/**
+ * MonitoredResourceDataLogon.
+ * @param metadata - The resource metadata.
+ * @public
+ */
+export declare type MonitoredResourceDataLogon = (metadata: MonitoredResourceMetadata) => void;
+
+/**
+ * MonitoredResourceMetadata.
+ * @public
+ */
+export declare interface MonitoredResourceMetadata extends Partial<MonitoredResourceChecksResult>, Partial<StreamEventDetail> {
+}
+
+/**
+ * @public
+ */
+export declare const networkLogger: Logger;
+
+/**
+ * `NetworkMonitor` monitors network and resource availability and health.
+ *
+ * @remarks
+ * UIs can listen for 'system-health-changed' events and display visual overlays to communicate status to the user.
+ *
+ * @public
+ */
+export declare interface NetworkMonitor {
+    status: SystemHealthStatus;
+    create(): void;
+    destroy(): void;
+    /**
+     * @param source - The source of the call, which may have been an event or scheduled interval.
+     * @param force - A flag to bypass abort if already in progress logic.
+     */
+    runAllChecks(source?: unknown, force?: boolean): Promise<void>;
+    /**
+     * @param resource - The resource reference.
+     * @param metadata - The resource metadata.
+     */
+    addResource(resource: MonitoredResource, metadata: MonitoredResourceMetadata): void;
+    /**
+     * @param resource - The resource reference.
+     */
+    removeResource(resource: MonitoredResource): void;
+}
+
+/**
+ * NetworkMonitor DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export declare const NetworkMonitor: InterfaceSymbol<NetworkMonitor>;
+
+/**
+ * NetworkMonitorConfig DI interface.
+ *
+ * @public
+ */
+export declare interface NetworkMonitorConfig {
+    /**
+     * Window events that invoke checks
+     */
+    windowEvents?: (keyof WindowEventHandlersEventMap)[];
+    /**
+     * Document events that invoke checks
+     */
+    documentEvents?: (keyof DocumentEventMap)[];
+    /**
+     * Genesis connect events that invoke checks
+     */
+    genesisConnectEvents?: GenesisConnectEvents[];
+    /**
+     * Periodic check internal in ms
+     */
+    checkInterval?: number;
+    /**
+     * Check timeout in ms
+     */
+    checkTimeout?: number;
+    /**
+     * Default resource checks function
+     */
+    resourceChecks?: MonitoredResourceChecks;
+    /**
+     * Default resource data logon function
+     * @remarks
+     * Used to re-attempt data logon on an unhealthy data server
+     */
+    resourceDataLogon?: MonitoredResourceDataLogon;
+    /**
+     * The element to emit events from
+     */
+    eventEmitter?: HTMLElement;
+}
+
+/**
+ * NetworkMonitorConfig DI key.
+ *
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export declare const NetworkMonitorConfig: InterfaceSymbol<NetworkMonitorConfig>;
+
 /**
  * Normalise criteria.
  *
@@ -2618,6 +3264,16 @@ export declare type RequestServerResult = {
     MESSAGE_TYPE?: string;
 };
 
+/**
+ * ResourceHealth.
+ * @public
+ */
+export declare type ResourceHealth = MonitoredResourceChecksResult & {
+    name: string;
+    sourceRef: string;
+    lastError?: any;
+};
+
 /**
  * Types of Genesis resources.
  * @public
@@ -2656,6 +3312,27 @@ export declare type SchemaResponse = {
     SOURCE_REF: string;
 };
 
+/**
+ * `SerializedSocketStatus` provides the serialize state of the web socket.
+ * @public
+ */
+export declare interface SerializedSocketStatus {
+    /**
+     * When the socket has been configured for use.
+     */
+    isConfigured: boolean;
+    isConnecting: boolean;
+    isConnected: boolean;
+    isDisconnected: boolean;
+    isDisconnectedByServer: boolean;
+    isReconnecting: boolean;
+    reconnectionLimitReached: boolean;
+    hasValidSession: boolean;
+    readonly closedCode: number;
+    readonly closedReason: string;
+    readonly closedClean: boolean;
+}
+
 /**
  * A Serializer interface for serializing and deserializing objects.
  * @public
@@ -2838,18 +3515,14 @@ export declare class SessionMock implements Session {
  * Provides methods for socket connection, sending and receiving WS messages.
  * @public
  */
-export declare interface Socket {
-    isConnected: boolean;
-    isReconnecting: boolean;
-    hasValidSession: boolean;
-    isConnectedSubject: BehaviorSubject<boolean>;
+export declare interface Socket extends Omit<SocketStatus, 'serialize' | 'onClose' | 'reconnectionLimitReached' | 'closedCode' | 'closedReason' | 'closedClean'> {
     connect(host: string, options?: SocketConnectOptions, reconnectOptions?: SocketReconnectOptions): Promise<boolean>;
     /**
      * Disconnects the socket and clears all subscriptions
      */
     reset(): void;
     send<T>(message: Message<T | any>, needsHandling?: boolean): Promise<Message | any>;
-    sendForStream<T>(message: Message<T | any>, onMessage: Function, onError: Function): Observable<Message>;
+    sendForStream<T>(message: Message<T | any>, onMessage: Function, onError: Function, onComplete?: Function): Observable<Message>;
     socketMessages(): SocketSubject<Message>;
 }
 
@@ -2875,7 +3548,7 @@ export declare type SocketConnectOptions = {
     /**
      * An observer to receive notifications of incoming messages from the server.
      */
-    connectObserver?: Observer<Message>;
+    connectObserver?: Observer_2<Message>;
     /**
      * Enable sending heartbeat messages to the server to prevent the connection from timing out.
      */
@@ -2948,7 +3621,11 @@ export declare class SocketMessageHandler {
  * @internal
  */
 export declare class SocketMock implements Socket {
+    isConfigured: boolean;
+    isDisconnected: boolean;
+    isDisconnectedByServer: boolean;
     hasValidSession: boolean;
+    isConnecting: boolean;
     isConnected: boolean;
     isConnectedSubject: BehaviorSubject<boolean>;
     isReconnecting: boolean;
@@ -2957,7 +3634,7 @@ export declare class SocketMock implements Socket {
     connect(host: string, options?: SocketConnectOptions, reconnectOptions?: SocketReconnectOptions): Promise<boolean>;
     disconnect(): void;
     send<T>(message: Message<any>): Promise<Message | any>;
-    sendForStream<T>(message: Message<any>, onMessage: Function, onError: Function): Observable<Message>;
+    sendForStream<T>(message: Message<any>, onMessage: Function, onError: Function, onComplete?: Function): Observable<Message>;
     socketMessages(): SocketSubject<Message>;
     reset(): void;
 }
@@ -2988,7 +3665,7 @@ export declare type SocketReconnectOptions = {
      * Observer to notify when reconnection occurs
      * @public
      */
-    reconnectObserver?: Observer<any>;
+    reconnectObserver?: Observer_2<any>;
     /**
      * Reconnect stream subscriptions on reconnection
      * @public
@@ -3021,6 +3698,26 @@ export declare enum SocketReconnectStrategy {
     Exponential = "exponential"
 }
 
+/**
+ * `SocketStatus` provides the state of the web socket.
+ * @public
+ */
+export declare interface SocketStatus extends SerializedSocketStatus {
+    isConnectedSubject: BehaviorSubject<boolean>;
+    serialize(): SerializedSocketStatus;
+    onClose(closeEvent: CloseEvent): void;
+}
+
+/**
+ * SocketStatus DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export declare const SocketStatus: InterfaceSymbol<SocketStatus>;
+
 /**
  * Subject that wraps a WebSocketSubject and provides a Subject interface for sending and receiving messages.
  * @public
@@ -3059,6 +3756,123 @@ export declare type SSOCredentialsInput = {
  */
 export declare type StorageType = 'local' | 'session';
 
+/**
+ * @public
+ */
+export declare type StreamCompleteEvent = CustomEvent<SocketObservable<any>>;
+
+/**
+ * @public
+ */
+export declare const StreamCompleteEventType = "connect-stream-complete-event";
+
+/**
+ * @public
+ */
+export declare type StreamEvent = CustomEvent<StreamEventDetail>;
+
+/**
+ * @public
+ */
+export declare type StreamEventDetail = {
+    functions: StreamEventFunctions;
+    message: Message<MessageDetails.DataserverRequest>;
+    resourceName: string;
+    stream: SocketObservable<any>;
+};
+
+/**
+ * @public
+ */
+export declare type StreamEventFunctions = {
+    onMessage?: Function;
+    onError?: Function;
+    resourceChecks?: MonitoredResourceChecks;
+    resourceDataLogon?: MonitoredResourceDataLogon;
+};
+
+/**
+ * @public
+ */
+export declare const StreamEventType = "connect-stream-event";
+
+/**
+ * SystemHealthChanged.
+ * @public
+ */
+export declare const SystemHealthChanged = "system-health-changed";
+
+/**
+ * SystemHealthChangedEvent.
+ * @public
+ */
+export declare type SystemHealthChangedEvent = CustomEvent<SystemHealthStatus>;
+
+/**
+ * SystemHealthStatus.
+ * @public
+ */
+export declare type SystemHealthStatus = {
+    /**
+     * Is the browser or device working online.
+     */
+    isOnline: boolean;
+    /**
+     * Browser information.
+     */
+    browserInformation?: Bowser_2.Parser.ParsedResult;
+    /**
+     * Is the user authenticated.
+     */
+    isAuthenticated: boolean;
+    /**
+     * The username if authenticated.
+     */
+    username?: string;
+    /**
+     * Is everything online and connected.
+     */
+    isHealthy: boolean;
+    /**
+     * Socket status.
+     */
+    socket: SerializedSocketStatus;
+    /**
+     * Resource health information.
+     */
+    resources: Record<string, ResourceHealth>;
+    /**
+     * Resources are all connected flag.
+     */
+    resourcesAllConnected: boolean;
+    /**
+     * Last time the information was updated.
+     */
+    lastUpdated: number;
+    /**
+     * Next time the information will be updated.
+     *
+     * @privateRemarks
+     * Overlays may use deltas for a visual countdown to next update.
+     */
+    nextUpdate: number;
+    /**
+     * First time the information was updated.
+     *
+     * @remarks
+     * Can be used by applications to understand how-long it has been since the last refresh and to drive automations.
+     */
+    firstUpdated: number;
+    /**
+     * User requested run checks.
+     */
+    runAllChecks(): void;
+    /**
+     * User requested report stability to Genesis.
+     */
+    reportStabilityToGenesis(): Promise<boolean>;
+};
+
 /**
  * Converts the field definitions to field metadata.
  * @public
@@ -3110,14 +3924,28 @@ export declare interface User extends UserOptions {
     hasAdminProfile(): boolean;
     hasPermission(permission: UserPermission | UserPermission[]): boolean;
     hasProfile(profile: UserProfile | UserProfile[]): boolean;
+    set(options: UserOptions): void;
+    unset(): void;
 }
 
+/**
+ * User DI key.
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ * @internal
+ */
+export declare const User: InterfaceSymbol<User>;
+
 /**
  * The keys used to store user information in the session storage.
  * @internal
  */
 declare type UserInfoKeys = 'authToken' | 'ssoToken' | 'refreshToken' | 'sessionId' | 'returnUrl' | 'hostUrl' | 'gridOptions';
 
+/**
+ * Made some minor adjustments here to make user more accessible in the short term.
+ * Please note that this User will be replaced with the enhanced version shortly!
+ */
 /**
  * TODO: Evolve, re-locate to foundation-data, foundation-user or similar and add JSON schema based population,
  * validation, evolution, foundation-store interop etc.