@mindignited/continuum-client 2.14.6

package/dist/src/api/security/IParticipant.d.ts

@@ -0,0 +1,30 @@
+import { Identifiable } from '../Identifiable';
+/**
+ * Created by Navíd Mitchell 🤪on 6/16/23.
+ */
+export interface IParticipant extends Identifiable<string> {
+    /**
+     * The identity of the participant
+     *
+     * @return the identity of the participant
+     */
+    id: string;
+    /**
+     * The tenant that the participant belongs to
+     *
+     * @return the tenant or null if not using multi-tenancy
+     */
+    tenantId?: string | null;
+    /**
+     * Metadata is a map of key value pairs that can be used to store additional information about a participant
+     *
+     * @return a map of key value pairs
+     */
+    metadata: Map<string, string>;
+    /**
+     * Roles are a list of strings that can be used to authorize a participant to perform certain actions
+     *
+     * @return a list of roles
+     */
+    roles: string[];
+}

package/dist/src/api/security/Participant.d.ts

@@ -0,0 +1,11 @@
+import { IParticipant } from './IParticipant';
+/**
+ * Created by Navid Mitchell on 6/2/20
+ */
+export declare class Participant implements IParticipant {
+    id: string;
+    tenantId?: string | null;
+    metadata: Map<string, string>;
+    roles: string[];
+    constructor(id: string, tenantId?: string, metadata?: Map<string, string>, roles?: string[]);
+}

package/dist/src/api/security/ParticipantConstants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Some common constants used for the {@link Participant} and {@link Participant#getMetadata()}
+ * Created by navid on 2/3/20
+ */
+export declare class ParticipantConstants {
+    static readonly PARTICIPANT_TYPE_METADATA_KEY: string;
+    static readonly PARTICIPANT_TYPE_DEVICE: string;
+    static readonly PARTICIPANT_TYPE_CLI: string;
+    static readonly PARTICIPANT_TYPE_USER: string;
+    static readonly PARTICIPANT_TYPE_NODE: string;
+    static readonly CLI_PARTICIPANT_ID: string;
+}

package/dist/src/core/api/CRI.d.ts

@@ -0,0 +1,122 @@
+/**
+ * `CRI` is a Continuum Resource Identifier used by Continuum to route requests appropriately.
+ *
+ * The `CRI` is a URI where the parts are named differently for clarity as to their purpose within Continuum.
+ *
+ * Will be in a format as follows where anything surrounded with `[]` is optional:
+ *
+ *      scheme://[scope@]resourceName[/path][#version]
+ *
+ * NOTE: If scope needs to be used to identify a sub-scope, it will follow the form `scope = scope:sub-scope`.
+ *
+ * This format can have varied meanings based upon the scheme used.
+ *
+ * @author Navid Mitchell
+ * @since 3/25/25
+ */
+export interface CRI {
+    /**
+     * The scheme for this `CRI`.
+     *
+     * @returns a string containing the scheme
+     */
+    scheme(): string;
+    /**
+     * The scope for this `CRI` or `null` if not provided.
+     *
+     * This is useful to narrow down the `CRI`. This could be something like a user id, device id, or a node id.
+     *
+     * @returns a string containing the scope if provided or `null` if not set
+     */
+    scope(): string | null;
+    /**
+     * @returns `true` if the `scope` is set
+     */
+    hasScope(): boolean;
+    /**
+     * The name of the resource represented by this `CRI`.
+     *
+     * In the case of a `srv` `CRI`, this will be the service name.
+     * In the case of a `stream` `CRI`, this will be the name of the event type that the stream expects.
+     *
+     * For the following CRI, `resourceName` would be the portion specified by `resourceName`:
+     *
+     * `scheme://[scope@]resourceName/path`
+     *
+     * @returns the string containing the name of this resource
+     */
+    resourceName(): string;
+    /**
+     * This is a version for the resource or `null` if not provided.
+     *
+     * @returns a string containing the version if provided or `null` if not set
+     */
+    version(): string | null;
+    /**
+     * @returns `true` if the `version` is set
+     */
+    hasVersion(): boolean;
+    /**
+     * The path for this `CRI`, without a leading `/`.
+     *
+     * For the following CRI, `path` would be the portion specified by `path`:
+     *
+     * `scheme://[scope@]resourceName/path`
+     *
+     * @returns the path string if provided or `null` if not set
+     */
+    path(): string | null;
+    /**
+     * @returns `true` if the `path` is set
+     */
+    hasPath(): boolean;
+    /**
+     * Base Resource is a portion of the fully qualified `CRI` containing the following:
+     *
+     * `scheme://[scope@]resourceName`
+     *
+     * @returns string containing the baseResource
+     */
+    baseResource(): string;
+    /**
+     * The fully qualified value for this `CRI`.
+     *
+     * @returns the fully qualified `CRI` as a string
+     */
+    raw(): string;
+}
+/**
+ * Creates a new `CRI` from a raw string.
+ *
+ * @param rawUrc the raw string
+ * @returns the newly created `CRI`
+ */
+export declare function createCRI(rawUrc: string): CRI;
+/**
+ * Creates a new `CRI` from scheme and resourceName.
+ *
+ * @param scheme the scheme
+ * @param resourceName the resource name
+ * @returns the newly created `CRI`
+ */
+export declare function createCRI(scheme: string, resourceName: string): CRI;
+/**
+ * Creates a new `CRI` from scheme, scope, and resourceName.
+ *
+ * @param scheme the scheme
+ * @param scope the scope
+ * @param resourceName the resource name
+ * @returns the newly created `CRI`
+ */
+export declare function createCRI(scheme: string, scope: string | null, resourceName: string): CRI;
+/**
+ * Creates a new `CRI` from all provided values.
+ *
+ * @param scheme the scheme
+ * @param scope the scope
+ * @param resourceName the resource name
+ * @param path the path
+ * @param version the version
+ * @returns the newly created `CRI`
+ */
+export declare function createCRI(scheme: string, scope: string | null, resourceName: string, path: string | null, version: string | null): CRI;

package/dist/src/core/api/ContextInterceptor.d.ts

@@ -0,0 +1,19 @@
+import { IEvent } from './IEventBus.js';
+/**
+ * Interface for the service context, extendable by users for type-safe context data.
+ *
+ * @author Navid Mitchell 🤝Grok
+ * @since 3/25/2025
+ */
+export interface ServiceContext {
+    [key: string]: any;
+}
+/**
+ * Interface for interceptors that create or modify the ServiceContext before service method invocation.
+ *
+ * @author Navid Mitchell 🤝Grok
+ * @since 3/25/2025
+ */
+export interface ContextInterceptor<T extends ServiceContext> {
+    intercept(event: IEvent, context: T): Promise<T> | T;
+}

package/dist/src/core/api/DefaultCRI.d.ts

@@ -0,0 +1,32 @@
+import { CRI } from './CRI';
+/**
+ * Default implementation of the `CRI` interface.
+ *
+ * @author Navid Mitchell
+ * @since 3/25/25
+ */
+export declare class DefaultCRI implements CRI {
+    private readonly _scheme;
+    private readonly _scope;
+    private readonly _resourceName;
+    private readonly _path;
+    private readonly _version;
+    private readonly _raw;
+    constructor(rawCRI: string);
+    constructor(scheme: string, scope: string | null, resourceName: string, path: string | null, version: string | null);
+    scheme(): string;
+    scope(): string | null;
+    hasScope(): boolean;
+    resourceName(): string;
+    version(): string | null;
+    hasVersion(): boolean;
+    path(): string | null;
+    hasPath(): boolean;
+    baseResource(): string;
+    raw(): string;
+    equals(other: any): boolean;
+    hashCode(): number;
+    toString(): string;
+    private static parseRaw;
+    private static buildRaw;
+}

package/dist/src/core/api/EventBus.d.ts

@@ -0,0 +1,55 @@
+import { ConnectionInfo, ServerInfo } from '../../api/ConnectionInfo';
+import { ConnectedInfo } from '../../api/security/ConnectedInfo';
+import { Observable } from 'rxjs';
+import { Optional } from 'typescript-optional';
+import { IEvent, IEventBus } from './IEventBus';
+/**
+ * Default IEvent implementation
+ */
+export declare class Event implements IEvent {
+    cri: string;
+    headers: Map<string, string>;
+    data: Optional<Uint8Array>;
+    constructor(cri: string, headers?: Map<string, string>, data?: Uint8Array);
+    getHeader(key: string): string | undefined;
+    hasHeader(key: string): boolean;
+    setHeader(key: string, value: string): void;
+    removeHeader(key: string): boolean;
+    setDataString(data: string): void;
+    getDataString(): string;
+}
+/**
+ * Default implementation of {@link IEventBus}
+ */
+export declare class EventBus implements IEventBus {
+    fatalErrors: Observable<Error>;
+    serverInfo: ServerInfo | null;
+    private stompConnectionManager;
+    private replyToCri;
+    private requestRepliesObservable;
+    private requestRepliesSubject;
+    private requestRepliesSubscription;
+    private errorSubject;
+    private errorSubjectSubscription;
+    constructor();
+    isConnectionActive(): boolean;
+    isConnected(): boolean;
+    connect(connectionInfo: ConnectionInfo): Promise<ConnectedInfo>;
+    disconnect(force?: boolean): Promise<void>;
+    send(event: IEvent): void;
+    request(event: IEvent): Promise<IEvent>;
+    requestStream(event: IEvent, sendControlEvents?: boolean): Observable<IEvent>;
+    observe(cri: string): Observable<IEvent>;
+    private cleanup;
+    /**
+     * Creates the proper error to return if this.stompConnectionManager?.rxStomp is not available on a send request
+     */
+    private createSendUnavailableError;
+    /**
+     * This is internal impl of observe that creates a cold observable.
+     * The public variants transform this to some type of hot observable depending on the need
+     * @param cri to observe
+     * @return the cold {@link Observable<IEvent>} for the given destination
+     */
+    private _observe;
+}

package/dist/src/core/api/IEventBus.d.ts

@@ -0,0 +1,204 @@
+import { Optional } from 'typescript-optional';
+import { Observable } from 'rxjs';
+import { ConnectedInfo } from '../../api/security/ConnectedInfo';
+import { ContinuumError } from '../../api/errors/ContinuumError';
+import { ConnectionInfo, ServerInfo } from '../../api/ConnectionInfo';
+/**
+ * Part of the low level portion of continuum representing data to be processed
+ *
+ * This is similar to a Stomp Frame but with more required information and no control plane semantics.
+ *
+ *
+ * Created by Navid Mitchell on 2019-01-04.
+ */
+export interface IEvent {
+    /**
+     * The cri that specifies where the event should be routed
+     */
+    cri: string;
+    /**
+     * Any headers defined for this event.
+     * This will usually contain all the fields above as well since they are typically wrappers around expected header values.
+     */
+    headers: Map<string, string>;
+    /**
+     * The event payload. The payload depends on the type the payload is encoded into a media format which is specified by the contentType attribute (e.g. application/json).
+     */
+    data: Optional<Uint8Array>;
+    /**
+     * @return the data property as a UTF-8 encoded string
+     */
+    getDataString(): string;
+    /**
+     * Gets the value for the header with the given key
+     * @param key to get the header value for
+     * @return the header value or undefined if there is no header for the key
+     */
+    getHeader(key: string): string | undefined;
+    /**
+     * Tests if a header for the given key exists
+     * @param key to check if exists as a header
+     * @return true if the header for the key exists false if not
+     */
+    hasHeader(key: string): boolean;
+    /**
+     * Removes the header from the headers map
+     * @param key to remove
+     * @return true if an element in the headers map object existed and has been removed, or false if the element does not exist
+     */
+    removeHeader(key: string): boolean;
+    /**
+     * Sets the data property from the given string value
+     * @param data
+     */
+    setDataString(data: string): void;
+    /**
+     * Sets the header into the headers map
+     * @param key the key to use
+     * @param value the value to use
+     */
+    setHeader(key: string, value: string): void;
+}
+/**
+ * Part of the low level portion of continuum representing a connection to a continuum server
+ * This is similar to a Stomp Client but with more required information and no control plane semantics.
+ *
+ * Created by Navid Mitchell on 2019-01-04.
+ */
+export interface IEventBus {
+    /**
+     * Any errors emitted by this observable will be fatal and the connection will be closed.
+     * You will need to resolve the problem and reconnect.
+     */
+    fatalErrors: Observable<ContinuumError>;
+    /**
+     * The {@link ServerInfo} used when connecting, if connected or null
+     */
+    serverInfo: ServerInfo | null;
+    /**
+     * Requests a connection to the given Stomp url
+     * @param connectionInfo provides the information needed to connect to the continuum server
+     * @return Promise containing the result of the initial connection attempt
+     */
+    connect(connectionInfo: ConnectionInfo): Promise<ConnectedInfo>;
+    /**
+     * Disconnects the client from the server
+     * This will clear any subscriptions and close the connection
+     * @param force if true then the connection will be closed immediately without sending a disconnect frame
+     *        When this mode is used, the actual Websocket may linger for a while
+     *        and the broker may not realize that the connection is no longer in use.
+     *
+     * @return Promise containing the result of the disconnect attempt
+     */
+    disconnect(force?: boolean): Promise<void>;
+    /**
+     * Determines if the connection is connected.
+     * This means that there is an open connection to the Continuum server
+     * @return true if the connection is active false if not
+     */
+    isConnected(): boolean;
+    /**
+     * Determines if the connection is active.
+     * This means {@link IEventBus#connect()} was called and was successful. The underlying connection may not be established yet.
+     * If this is true and {@link IEventBus#isConnected} is false messages sent will be queued
+     * @return true if the connection is active false if not
+     */
+    isConnectionActive(): boolean;
+    /**
+     * Creates a subscription for all {@link IEvent}'s for the given destination
+     * @param cri to subscribe to
+     */
+    observe(cri: string): Observable<IEvent>;
+    /**
+     * Sends an {@link IEvent} expecting a response
+     * All response correlation will be handled internally
+     * @param event to send as the request
+     * @return a Promise that will resolve when the response is received
+     */
+    request(event: IEvent): Promise<IEvent>;
+    /**
+     * Sends an {@link IEvent} expecting multiple responses
+     * All response correlation will be handled internally
+     * @param event to send as the request
+     * @param sendControlEvents if true then control events will be sent to the server when changes to the returned to Observable are requested
+     * @return an {@link Observable<IEvent} that will provide the response stream
+     * NOTE: the naming here is similar to RSocket https://www.baeldung.com/rsocket#3-requeststream
+     */
+    requestStream(event: IEvent, sendControlEvents: boolean): Observable<IEvent>;
+    /**
+     * Send a single {@link IEvent} to the connected server
+     * @param event to send
+     */
+    send(event: IEvent): void;
+}
+/**
+ * Constants used within {@link IEvent}'s to control the flow of events
+ * Header that start with __ will always be persisted between messages
+ */
+export declare enum EventConstants {
+    CONTENT_TYPE_HEADER = "content-type",
+    CONTENT_LENGTH_HEADER = "content-length",
+    REPLY_TO_HEADER = "reply-to",
+    /**
+     * This is the replyToId that will be supplied by the client, which will be used when sending replies to the client.
+     */
+    REPLY_TO_ID_HEADER = "reply-to-id",
+    /**
+     * Header provided by the sever on connection to represent the user's session id
+     */
+    SESSION_HEADER = "session",
+    /**
+     * Header provided by the server on connection to provide the {@link ConnectionInfo} as a JSON string
+     */
+    CONNECTED_INFO_HEADER = "connected-info",
+    /**
+     * Header provided by the client on connection request to represent that the server
+     * should not keep the session alive after any network disconnection.
+     */
+    DISABLE_STICKY_SESSION_HEADER = "disable-sticky-session",
+    /**
+     * Correlates a response with a given request
+     * Headers that start with __ will always be persisted between messages
+     */
+    CORRELATION_ID_HEADER = "__correlation-id",
+    /**
+     * Denotes that something caused an error. Will contain a brief message about the error
+     */
+    ERROR_HEADER = "error",
+    /**
+     * Denotes the completion of an event stream. The value typically will contain the reason for completion.
+     */
+    COMPLETE_HEADER = "complete",
+    /**
+     * Denotes the event is a control plane event. These are used for internal coordination.
+     */
+    CONTROL_HEADER = "control",
+    /**
+     * Stream is complete, no further values will be sent.
+     */
+    CONTROL_VALUE_COMPLETE = "complete",
+    CONTROL_VALUE_CANCEL = "cancel",
+    CONTROL_VALUE_SUSPEND = "suspend",
+    CONTROL_VALUE_RESUME = "resume",
+    SERVICE_DESTINATION_PREFIX = "srv://",
+    SERVICE_DESTINATION_SCHEME = "srv",
+    STREAM_DESTINATION_PREFIX = "stream://",
+    STREAM_DESTINATION_SCHEME = "stream",
+    CONTENT_JSON = "application/json",
+    CONTENT_TEXT = "text/plain",
+    /**
+     * The traceparent HTTP header field identifies the incoming request in a tracing system. It has four fields:
+     *
+     *     version
+     *     trace-id
+     *     parent-id
+     *     trace-flags
+     * @see https://www.w3.org/TR/trace-context/#traceparent-header
+     */
+    TRACEPARENT_HEADER = "traceparent",
+    /**
+     * The main purpose of the tracestate header is to provide additional vendor-specific trace identification information across different distributed tracing systems and is a companion header for the traceparent field. It also conveys information about the request’s position in multiple distributed tracing graphs.
+     * @see https://www.w3.org/TR/trace-context/#tracestate-header
+     */
+    TRACESTATE_HEADER = "tracestate"
+}

package/dist/src/core/api/IServiceRegistry.d.ts

@@ -0,0 +1,74 @@
+import { ContextInterceptor, ServiceContext } from './ContextInterceptor.js';
+import { ServiceIdentifier } from './ServiceIdentifier.js';
+import { Observable } from 'rxjs';
+import { IEvent } from './IEventBus';
+/**
+ * Provides an interface to allow the {@link IServiceProxy} creator the ability to have fine grain control of the outgoing {@link IEvent}
+ */
+export interface IEventFactory {
+    create(cri: string, args: any[] | null | undefined): IEvent;
+}
+/**
+ * {@link IServiceProxy} provides the ability to access a remote service
+ *
+ * Created by navid on 2019-04-18.
+ */
+export interface IServiceProxy {
+    /**
+     * The remote id of the service that this proxy is for
+     */
+    serviceIdentifier: string;
+    /**
+     * Provides functionality to invoke the remote service that returns a single result
+     * @param methodIdentifier of the service method to invoke
+     * @param args to pass to the service invocation
+     * @param scope string or undefined or null, if not undefined or null this is used to determine which service instance rpc requests should be routed to.
+     * @param eventFactory IEventFactory or undefined or null, if not undefined or null this is the {@link IEventFactory} to use when creating {@link IEvent}'s to send
+     * @return a {@link Promise} that will resolve to the result from the invocation
+     */
+    invoke(methodIdentifier: string, args?: any[] | null | undefined, scope?: string | null | undefined, eventFactory?: IEventFactory | null | undefined): Promise<any>;
+    /**
+     * Provides functionality to invoke the remote service that returns a stream of results
+     * @param methodIdentifier of the service method to invoke
+     * @param args to pass to the service invocation
+     * @param scope string or undefined or null, if not undefined or null this is used to determine which service instance rpc requests should be routed to.
+     * @param eventFactory IEventFactory or undefined or null, if not undefined or null this is the {@link IEventFactory} to use when creating {@link IEvent}'s to send
+     * @return a {@link Observable} that will resolve to the result from the invocation
+     */
+    invokeStream(methodIdentifier: string, args?: any[] | null | undefined, scope?: string | null | undefined, eventFactory?: IEventFactory | null | undefined): Observable<any>;
+}
+/**
+ * Provides the functionality to register services as well as create proxies for those services
+ *
+ * Created by Navid Mitchell on 2019-02-08.
+ */
+export interface IServiceRegistry {
+    /**
+     * Creates a new service proxy that can be used to access the desired service.
+     * @param serviceIdentifier the identifier of the service to be accessed
+     * @return the {@link IServiceProxy} that can be used to access the service
+     */
+    serviceProxy(serviceIdentifier: string): IServiceProxy;
+    /**
+     * Registers a new service with the service registry.
+     * This will allow the service to be accessed remotely.
+     *
+     * @param serviceIdentifier identifies the service to be registered
+     * @param service to use invoke when the service is called
+     */
+    register(serviceIdentifier: ServiceIdentifier, service: any): void;
+    /**
+     * Unregisters a service with the service registry.
+     * This will remove the service from the registry, and it will no longer be accessible remotely.
+     *
+     * @param serviceIdentifier identifies the service to be unregistered
+     */
+    unRegister(serviceIdentifier: ServiceIdentifier): void;
+    /**
+     * Registers a {@link ContextInterceptor} that will be used to modify the {@link ServiceContext} before the service method is invoked.
+     * This allows for custom context data to be added or modified before the service method is called.
+     *
+     * @param interceptor the {@link ContextInterceptor} to register
+     */
+    registerContextInterceptor<T extends ServiceContext>(interceptor: ContextInterceptor<T> | null): void;
+}

package/dist/src/core/api/ServiceIdentifier.d.ts

@@ -0,0 +1,20 @@
+import { CRI } from './CRI.js';
+export declare class ServiceIdentifier {
+    namespace: string;
+    name: string;
+    scope?: string;
+    version?: string;
+    private _cri;
+    constructor(namespace: string, name: string);
+    /**
+     * Returns the qualified name for this {@link ServiceIdentifier}
+     * This is the namespace.name
+     * @return string containing the qualified name
+     */
+    qualifiedName(): string;
+    /**
+     * The {@link CRI} that represents this {@link ServiceIdentifier}
+     * @return the cri for this {@link ServiceIdentifier}
+     */
+    cri(): CRI;
+}

package/dist/src/core/api/ServiceRegistry.d.ts

@@ -0,0 +1,29 @@
+import { ServiceIdentifier } from './ServiceIdentifier.js';
+import { IEvent, IEventBus } from './IEventBus';
+import { IEventFactory, IServiceProxy, IServiceRegistry } from './IServiceRegistry';
+import { ContextInterceptor, ServiceContext } from './ContextInterceptor';
+/**
+ * An implementation of a {@link IEventFactory} which uses JSON content
+ */
+export declare class JsonEventFactory implements IEventFactory {
+    create(cri: string, args: any[] | null | undefined): IEvent;
+}
+/**
+ * An implementation of a {@link IEventFactory} which uses text content
+ */
+export declare class TextEventFactory implements IEventFactory {
+    create(cri: string, args: any[] | null | undefined): IEvent;
+}
+/**
+ * The default implementation of {@link IServiceRegistry}
+ */
+export declare class ServiceRegistry implements IServiceRegistry {
+    private readonly eventBus;
+    private readonly supervisors;
+    private contextInterceptor;
+    constructor(eventBus: IEventBus);
+    serviceProxy(serviceIdentifier: string): IServiceProxy;
+    register(serviceIdentifier: ServiceIdentifier, service: any): void;
+    unRegister(serviceIdentifier: ServiceIdentifier): void;
+    registerContextInterceptor<T extends ServiceContext>(interceptor: ContextInterceptor<T> | null): void;
+}

package/dist/src/core/api/StompConnectionManager.d.ts

@@ -0,0 +1,38 @@
+import { ConnectionInfo } from '../../api/ConnectionInfo';
+import { ConnectedInfo } from '../../api/security/ConnectedInfo';
+import { RxStomp } from '@stomp/rx-stomp';
+/**
+ * Creates a new RxStomp client and manages it
+ * This is here to simplify the logic needed for connection management and the usage of the client.
+ */
+export declare class StompConnectionManager {
+    lastWebsocketError: Event | null;
+    /**
+     * This will return true if a {@link ConnectionInfo#maxConnectionAttempts} threshold was set and was reached
+     */
+    maxConnectionAttemptsReached: boolean;
+    rxStomp: RxStomp | null;
+    private readonly INITIAL_RECONNECT_DELAY;
+    private readonly MAX_RECONNECT_DELAY;
+    private readonly JITTER_MAX;
+    private connectionAttempts;
+    private initialConnectionSuccessful;
+    private debugLogger;
+    private replyToId;
+    readonly replyToCri: string;
+    deactivationHandler: (() => void) | null;
+    /**
+     * @return true if this {@link StompConnectionManager} is actively trying to maintain a connection to the Stomp server, false if not.
+     */
+    get active(): boolean;
+    /**
+     * return true if this {@link StompConnectionManager} is active and has a connection to the stomp server
+     */
+    get connected(): boolean;
+    activate(connectionInfo: ConnectionInfo): Promise<ConnectedInfo>;
+    deactivate(force?: boolean): Promise<void>;
+    /**
+     * Make sure clients don't all try to reconnect at the same time.
+     */
+    private connectionJitterDelay;
+}

package/dist/src/core/api/StreamData.d.ts

@@ -0,0 +1,18 @@
+import { Identifiable } from '../../index';
+export declare enum StreamOperation {
+    EXISTING = "EXISTING",
+    UPDATE = "UPDATE",
+    REMOVE = "REMOVE"
+}
+/**
+ * Holder for domain objects that will be returned as a stream of changes to a data set
+ *
+ * Created by Navid Mitchell on 6/3/20
+ */
+export declare class StreamData<I, T> implements Identifiable<I> {
+    streamOperation: StreamOperation;
+    id: I;
+    value: T;
+    constructor(streamOperation: StreamOperation, id: I, value: T);
+    isSet(): boolean;
+}