@kinotic-ai/core 1.0.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1159 @@
+/**
+* ConnectHeaders to use during connection to the kinoitc server
+* These headers will be sent as part of the STOMP CONNECT frame
+* This is typically used for authentication information, but any data can be sent
+*/
+declare class ConnectHeaders {
+	[key: string]: string;
+}
+declare class ServerInfo {
+	host: string;
+	port?: number | null;
+	useSSL?: boolean | null;
+}
+/**
+* ConnectionInfo provides the information needed to connect to the kinoitc server
+*/
+declare class ConnectionInfo extends ServerInfo {
+	/**
+	* The headers to send during the connection to the kinoitc server.
+	* If a function is provided, it will be called to get the headers each time the connection is established.
+	* This is useful for providing dynamic headers, such as a JWT token that expires.
+	*/
+	connectHeaders?: ConnectHeaders | (() => Promise<ConnectHeaders>);
+	/**
+	* The maximum number of connection attempts to make during the {@link IEventBus} initial connection request.
+	* If the limit is reached the {@link IEventBus} will return an error to the caller of {@link IEventBus#connect}
+	* Set to 0, undefined, or null to try forever
+	*/
+	maxConnectionAttempts?: number | null;
+	/**
+	* If true, the session will not be kept alive after the connection is established and then disrupted.
+	* If false, the session will be kept alive after the connection is established and then disrupted, for a period of time.
+	*/
+	disableStickySession?: boolean | null;
+}
+/**
+* Instances of this interface have a unique id (identity) and are therefore "Identifiable"
+* Created by navid on 2/3/20
+*/
+interface Identifiable<T> {
+	id: T | null;
+}
+/**
+* Created by Navíd Mitchell 🤪on 6/16/23.
+*/
+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[];
+}
+/**
+* Created by Navid Mitchell on 6/2/20
+*/
+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[]);
+}
+/**
+* Contains information about the connection that was established
+*/
+declare class ConnectedInfo {
+	sessionId: string;
+	replyToId: string;
+	participant: Participant;
+}
+/**
+* A page is a sublist of a list of objects.
+* @author Navid Mitchell
+*/
+interface Page<T> {
+	/**
+	* @return the total number of elements or null or undefined if not known.
+	*/
+	readonly totalElements: number | null | undefined;
+	/**
+	* The cursor to be used for subsequent retrieval of data.
+	* @return an opaque string representation of the cursor, or null if this is the last page, or undefined if cursor paging is not being used.
+	*/
+	readonly cursor: string | null | undefined;
+	/**
+	* @return the page content as {@link Array} or null or undefined if no data is available.
+	*/
+	readonly content: T[] | null | undefined;
+}
+/**
+* Enumeration for sort directions.
+*
+* Adapted from the Spring Data Commons Package
+*
+* @author Oliver Gierke
+* @author Navid Mitchell
+*/
+declare enum Direction {
+	ASC = "ASC",
+	DESC = "DESC"
+}
+/**
+* Enumeration for null handling hints that can be used in {@link Order} expressions.
+*
+* Adapted from the Spring Data Commons Package
+*
+* @author Thomas Darimont
+* @author Navid Mitchell
+* @since 1.8
+*/
+declare enum NullHandling {
+	/**
+	* Lets the data store decide what to do with nulls.
+	*/
+	NATIVE = "NATIVE",
+	/**
+	* A hint to the used data store to order entries with null values before non-null entries.
+	*/
+	NULLS_FIRST = "NULLS_FIRST",
+	/**
+	* A hint to the used data store to order entries with null values after non-null entries.
+	*/
+	NULLS_LAST = "NULLS_LAST"
+}
+declare class Order {
+	property: string;
+	direction: Direction;
+	nullHandling: NullHandling;
+	constructor(property: string, direction: Direction | null);
+	/**
+	* Returns whether sorting for this property shall be ascending.
+	*/
+	isAscending(): boolean;
+	/**
+	* Returns whether sorting for this property shall be descending.
+	*/
+	isDescending(): boolean;
+}
+/**
+* Sort option for queries. You have to provide at least a list of properties to sort for that must not include
+* {@literal null} or empty strings. The direction defaults to {@link Sort#DEFAULT_DIRECTION}.
+*
+* Adapted from the Spring Data Commons Package
+*
+* @author Oliver Gierke
+* @author Thomas Darimont
+* @author Mark Paluch
+* @author Navid Mitchell
+*/
+declare class Sort {
+	orders: Order[];
+}
+/**
+* Abstract interface for pagination information.
+*
+* Adapted from the Spring Data Commons Package
+*
+* @author Oliver Gierke
+* @author Navid Mitchell
+*/
+declare abstract class Pageable {
+	/**
+	* Returns the sorting parameters (optional).
+	*/
+	sort?: Sort | null | undefined;
+	/**
+	* Returns the number of items to be returned.
+	*/
+	pageSize: number;
+	/**
+	* Creates a {@link Pageable} that uses Offset based pagination.
+	* @param pageNumber zero based page index.
+	* @param pageSize the size of the page to be returned.
+	* @param sort the sorting parameters (optional).
+	*/
+	static create(pageNumber: number, pageSize: number, sort?: Sort | null): OffsetPageable;
+	/**
+	* Creates a {@link Pageable} that uses Cursor based pagination.
+	* @param cursor the cursor to be used for subsequent retrieval of data, or null if this is the first page.
+	* @param pageSize the size of the page to be returned.
+	* @param sort the sorting parameters (optional).
+	*/
+	static createWithCursor(cursor: string | null, pageSize: number, sort?: Sort | null): CursorPageable;
+}
+/**
+* Implementation of {@link Pageable} that uses Offset based pagination.
+*/
+declare class OffsetPageable extends Pageable {
+	/**
+	* Returns the page to be returned.
+	*/
+	pageNumber: number;
+	/**
+	* Creates a {@link Pageable} that uses Offset based pagination.
+	* @param pageNumber zero based page index.
+	* @param pageSize the size of the page to be returned.
+	* @param sort the sorting parameters (optional).
+	*/
+	constructor(pageNumber: number, pageSize: number, sort?: Sort | null);
+}
+/**
+* Implementation of {@link Pageable} that uses Cursor based pagination.
+*/
+declare class CursorPageable extends Pageable {
+	/**
+	* The cursor to be used for subsequent retrieval of data, or null if this is the first page.
+	*/
+	cursor: string | null;
+	/**
+	* Creates a {@link Pageable} that uses Cursor based pagination.
+	* @param cursor the cursor to be used for subsequent retrieval of data, or null if this is the first page.
+	* @param pageSize the size of the page to be returned.
+	* @param sort the sorting parameters (optional).
+	*/
+	constructor(cursor: string | null, pageSize: number, sort?: Sort | null);
+}
+/**
+* {@link IDataSource} provides an abstract way to retrieve data from various sources
+*/
+interface IDataSource<T> {
+	/**
+	* Returns a {@link Page} of entities meeting the paging restriction provided in the {@code Pageable} object.
+	*
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	findAll(pageable: Pageable): Promise<IterablePage<T>>;
+	/**
+	* Returns a {@link Page} of entities matching the search text and paging restriction provided in the {@code Pageable} object.
+	*
+	* @param searchText the text to search for entities for
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	search(searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+}
+interface IEditableDataSource<T extends Identifiable<string>> extends IDataSource<T> {
+	/**
+	* Creates a new entity if one does not already exist for the given id
+	* @param entity to create if one does not already exist
+	* @return a {@link Promise} containing the new entity or an error if an exception occurred
+	*/
+	create(entity: T): Promise<T>;
+	/**
+	* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
+	* entity instance completely.
+	*
+	* @param entity must not be {@literal null}.
+	* @return a {@link Promise} emitting the saved entity.
+	* @throws Error in case the given {@literal entity} is {@literal null}.
+	*/
+	save(entity: T): Promise<T>;
+	/**
+	* Retrieves an entity by its id.
+	*
+	* @param id must not be {@literal null}.
+	* @return a {@link Promise} emitting the entity with the given id or {@link Promise#empty()} if none found.
+	* @throws IllegalArgumentException in case the given {@literal identity} is {@literal null}.
+	*/
+	findById(id: string): Promise<T>;
+	/**
+	* Deletes the entity with the given id.
+	*
+	* @param id must not be {@literal null}.
+	* @return a {@link Promise} signaling when operation has completed.
+	* @throws IllegalArgumentException in case the given {@literal identity} is {@literal null}.
+	*/
+	deleteById(id: string): Promise<void>;
+	/**
+	* Returns a {@link Page} of entities not in the ids list and meeting the paging restriction provided in the {@code Pageable} object.
+	*
+	* @param ids not to be returned in the Page
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	findByIdNotIn(ids: string[], pageable: Pageable): Promise<Page<Identifiable<string>>>;
+}
+declare class DataSourceUtils {
+	static instanceOfEditableDataSource(datasource: IDataSource<any> | IEditableDataSource<any>): datasource is IEditableDataSource<any>;
+}
+/**
+* A {@link ICrudServiceProxy} is a proxy for a remote CRUD service
+*/
+interface ICrudServiceProxy<T extends Identifiable<string>> extends IEditableDataSource<T> {
+	/**
+	* Creates a new entity if one does not already exist for the given id
+	* @param entity to create if one does not already exist
+	* @return a {@link Promise} containing the new entity or an error if an exception occurred
+	*/
+	create(entity: T): Promise<T>;
+	/**
+	* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
+	* entity instance completely.
+	*
+	* @param entity must not be {@literal null}.
+	* @return a {@link Promise} emitting the saved entity.
+	* @throws Error in case the given {@literal entity} is {@literal null}.
+	*/
+	save(entity: T): Promise<T>;
+	/**
+	* Retrieves an entity by its id.
+	*
+	* @param id must not be {@literal null}.
+	* @return a {@link Promise} emitting the entity with the given id or {@link Promise#empty()} if none found.
+	* @throws IllegalArgumentException in case the given {@literal identity} is {@literal null}.
+	*/
+	findById(id: string): Promise<T>;
+	/**s
+	* Returns the number of entities available.
+	*
+	* @return a {@link Promise} emitting the number of entities.
+	*/
+	count(): Promise<number>;
+	/**
+	* Deletes the entity with the given id.
+	*
+	* @param id must not be {@literal null}.
+	* @return a {@link Promise} signaling when operation has completed.
+	* @throws IllegalArgumentException in case the given {@literal identity} is {@literal null}.
+	*/
+	deleteById(id: string): Promise<void>;
+	/**
+	* Returns a {@link Page} of entities meeting the paging restriction provided in the {@code Pageable} object.
+	*
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	findAll(pageable: Pageable): Promise<IterablePage<T>>;
+	/**
+	* Returns a {@link Page} of entities not in the ids list and meeting the paging restriction provided in the {@code Pageable} object.
+	*
+	* @param ids not to be returned in the Page
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	findByIdNotIn(ids: string[], pageable: Pageable): Promise<Page<Identifiable<string>>>;
+	/**
+	* Returns a {@link Page} of entities matching the search text and paging restriction provided in the {@code Pageable} object.
+	*
+	* @param searchText the text to search for entities for
+	* @param pageable the page settings to be used
+	* @return a {@link Promise} emitting the page of entities
+	*/
+	search(searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+}
+/**
+* Produces {@link ICrudServiceProxy} Proxies for a known remote CRUD service
+*/
+interface ICrudServiceProxyFactory {
+	/**
+	* Produces a {@link ICrudServiceProxy} for the given serviceIdentifier
+	* @param serviceIdentifier the service identifier to produce a proxy for
+	*/
+	crudServiceProxy<T extends Identifiable<string>>(serviceIdentifier: string): ICrudServiceProxy<T>;
+}
+import { Optional } from "typescript-optional";
+import { Observable } from "rxjs";
+/**
+* Base error class for all Kinoitc errors
+*/
+declare class KinoticError extends Error {
+	constructor(message: string);
+}
+/**
+* Part of the low level portion of kinoitc 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.
+*/
+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 kinoitc representing a connection to a kinoitc 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.
+*/
+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<KinoticError>;
+	/**
+	* 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 kinoitc 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 Kinoitc 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;
+	/**
+	* Starts a local event bus server to listen for incoming connections
+	* NOTE: Not all implementations will support this
+	* @param serverInfo to listen on
+	*/
+	listen(serverInfo: ServerInfo): Promise<void>;
+	/**
+	* 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
+*/
+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"
+}
+/**
+* Interface for the service context, extendable by users for type-safe context data.
+*
+* @author Navid Mitchell 🤝Grok
+* @since 3/25/2025
+*/
+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
+*/
+interface ContextInterceptor<T extends ServiceContext> {
+	intercept(event: IEvent, context: T): Promise<T> | T;
+}
+/**
+* `CRI` is a Kinoitc Resource Identifier used by Kinoitc to route requests appropriately.
+*
+* The `CRI` is a URI where the parts are named differently for clarity as to their purpose within Kinoitc.
+*
+* 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
+*/
+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`
+*/
+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`
+*/
+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`
+*/
+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`
+*/
+declare function createCRI(scheme: string, scope: string | null, resourceName: string, path: string | null, version: string | null): CRI;
+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;
+}
+import { Observable as Observable2 } from "rxjs";
+/**
+* Provides an interface to allow the {@link IServiceProxy} creator the ability to have fine grain control of the outgoing {@link IEvent}
+*/
+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.
+*/
+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): Observable2<any>;
+}
+/**
+* Provides the functionality to register services as well as create proxies for those services
+*
+* Created by Navid Mitchell on 2019-02-08.
+*/
+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;
+}
+/**
+* Default implementation of {@link ICrudServiceProxyFactory}
+*/
+declare class CrudServiceProxyFactory implements ICrudServiceProxyFactory {
+	private serviceRegistry;
+	constructor(serviceRegistry: IServiceRegistry);
+	crudServiceProxy<T extends Identifiable<string>>(serviceIdentifier: string): ICrudServiceProxy<T>;
+}
+/**
+* An implementation of a {@link IEventFactory} which uses JSON content
+*/
+declare class JsonEventFactory implements IEventFactory {
+	create(cri: string, args: any[] | null | undefined): IEvent;
+}
+/**
+* An implementation of a {@link IEventFactory} which uses text content
+*/
+declare class TextEventFactory implements IEventFactory {
+	create(cri: string, args: any[] | null | undefined): IEvent;
+}
+/**
+* The default implementation of {@link IServiceRegistry}
+*/
+declare class ServiceRegistry implements IServiceRegistry {
+	private _eventBus;
+	private supervisors;
+	private contextInterceptor;
+	private debugLogger;
+	constructor(eventBus: IEventBus);
+	set eventBus(eventBus: IEventBus);
+	get 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;
+}
+interface IKinotic {
+	serviceRegistry: IServiceRegistry;
+	crudServiceProxyFactory: CrudServiceProxyFactory;
+	eventBus: IEventBus;
+	/**
+	* Requests a connection to the given Stomp url
+	* @param connectionInfo provides the information needed to connect to the kinoitc 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
+	*/
+	disconnect(force?: boolean): Promise<void>;
+	/**
+	* 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;
+	/**
+	* Returns a {@link ICrudServiceProxy} for the given service identifier
+	* @param serviceIdentifier the identifier of the service to be accessed
+	*/
+	crudServiceProxy<T extends Identifiable<string>>(serviceIdentifier: string): ICrudServiceProxy<T>;
+}
+/**
+* Provides a simplified way to connect to Kinotic and access services.
+* All methods use a single connection to the Kinotic Services
+*/
+declare class KinoticSingleton implements IKinotic {
+	/**
+	* The {@link IEventBus} that is used to communicate with the Kinotic server
+	*/
+	private _eventBus;
+	/**
+	* The {@link ServiceRegistry} that is used to manage the services that are available
+	*/
+	readonly serviceRegistry: ServiceRegistry;
+	/**
+	* The {@link CrudServiceProxyFactory} that is used to create {@link ICrudServiceProxy} instances
+	*/
+	readonly crudServiceProxyFactory: CrudServiceProxyFactory;
+	constructor();
+	get eventBus(): IEventBus;
+	set eventBus(eventBus: IEventBus);
+	/**
+	* Requests a connection to the given Stomp url
+	* @param connectionInfo provides the information needed to connect to the kinoitc 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
+	*/
+	disconnect(force?: boolean): Promise<void>;
+	/**
+	* 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;
+	/**
+	* Returns a {@link ICrudServiceProxy} for the given service identifier
+	* @param serviceIdentifier the identifier of the service to be accessed
+	*/
+	crudServiceProxy<T extends Identifiable<string>>(serviceIdentifier: string): ICrudServiceProxy<T>;
+}
+/**
+* The default {@link IKinotic} instance that can be used to access Kinotic services
+*/
+declare const Kinotic: IKinotic;
+declare const CONTEXT_METADATA_KEY: unique symbol;
+declare function Scope(target: any, propertyKey: string, descriptor?: PropertyDescriptor): void;
+declare function Version(version: string): (target: Function) => void;
+declare function Context(): (target: any, propertyKey: string, parameterIndex: number) => void;
+declare function Publish(namespace: string, name?: string): (target: Function) => any;
+declare enum LogLevel {
+	TRACE = "TRACE",
+	DEBUG = "DEBUG",
+	INFO = "INFO",
+	WARN = "WARN",
+	ERROR = "ERROR",
+	FATAL = "FATAL",
+	OFF = "OFF"
+}
+declare class LoggerLevelsDescriptor {
+	configuredLevel?: LogLevel;
+}
+declare class GroupLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+	members: string[];
+}
+declare class SingleLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+	effectiveLevel?: LogLevel;
+}
+/**
+* Description of loggers
+*/
+declare class LoggersDescriptor {
+	levels: LogLevel[];
+	loggerLevels: Map<string, SingleLoggerLevelsDescriptor>;
+	groups: Map<string, GroupLoggerLevelsDescriptor>;
+}
+/**
+* Provides the ability to manage loggers
+*/
+interface ILogManager {
+	/**
+	* @param nodeId the kinoitc node to get the LoggersDescriptor from
+	* @return a {@link LoggersDescriptor} containing all the loggers and their levels
+	*/
+	loggers(nodeId: string): Promise<LoggersDescriptor>;
+	/**
+	* @param nodeId the kinoitc node to get the LoggerLevelsDescriptor from
+	* @param name the name of the logger to get
+	* @return a {@link LoggerLevelsDescriptor} containing the logger and its levels
+	*/
+	loggerLevels(nodeId: string, name: string): Promise<LoggerLevelsDescriptor>;
+	/**
+	* Configures the log level for the logger with the given name
+	* @param nodeId the kinoitc node to set the log level on
+	* @param name the name of the logger to set
+	* @param level the {@link LogLevel} to set for the logger with the given name
+	*/
+	configureLogLevel(nodeId: string, name: string, level: LogLevel): Promise<void>;
+}
+declare class LogManager implements ILogManager {
+	private readonly serviceProxy;
+	constructor();
+	loggers(nodeId: string): Promise<LoggersDescriptor>;
+	loggerLevels(nodeId: string, name: string): Promise<LoggerLevelsDescriptor>;
+	configureLogLevel(nodeId: string, name: string, level: LogLevel): Promise<void>;
+}
+declare const logManager: ILogManager;
+declare class AuthenticationError extends KinoticError {
+	constructor(message: string);
+}
+declare class AuthorizationError extends KinoticError {
+	constructor(message: string);
+}
+/**
+* Some common constants used for the {@link Participant} and {@link Participant#getMetadata()}
+* Created by navid on 2/3/20
+*/
+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;
+}
+/**
+* Default implementation of the `CRI` interface.
+*
+* @author Navid Mitchell
+* @since 3/25/25
+*/
+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;
+}
+import { Observable as Observable3 } from "rxjs";
+import { Optional as Optional2 } from "typescript-optional";
+/**
+* Default IEvent implementation
+*/
+declare class Event implements IEvent {
+	cri: string;
+	headers: Map<string, string>;
+	data: Optional2<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}
+*/
+declare class EventBus implements IEventBus {
+	fatalErrors: Observable3<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): Observable3<IEvent>;
+	listen(_serverInfo: ServerInfo): Promise<void>;
+	observe(cri: string): Observable3<IEvent>;
+	private cleanup;
+	/**
+	* Creates the proper error to return if this.stompConnectionManager?.rxStomp is not available on a send request
+	*/
+	private createSendUnavailableError;
+	/**
+	* This is an 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;
+}
+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
+*/
+declare class StreamData<
+	I,
+	T
+> implements Identifiable<I> {
+	streamOperation: StreamOperation;
+	id: I;
+	value: T;
+	constructor(streamOperation: StreamOperation, id: I, value: T);
+	isSet(): boolean;
+}
+/**
+* Defines a page that is also an async iterator.
+* This allows for easy iteration over all pages of a result set.
+*/
+interface IterablePage<T> extends Page<T>, AsyncIterableIterator<IterablePage<T>> {
+	/**
+	* @return true if this is the last page, false otherwise.
+	*/
+	isLastPage(): boolean;
+	/**
+	* @return true if this page has content, false otherwise.
+	*/
+	hasContent(): boolean;
+}
+declare abstract class AbstractIterablePage<T> implements IterablePage<T> {
+	private readonly pageable;
+	private currentPage;
+	private firstPage;
+	protected constructor(pageable: Pageable, page: Page<T>);
+	next(): Promise<IteratorResult<IterablePage<T>>>;
+	[Symbol.asyncIterator](): AsyncIterableIterator<IterablePage<T>>;
+	hasContent(): boolean;
+	isLastPage(): boolean;
+	private isOffsetPageable;
+	get totalElements(): number | null | undefined;
+	get cursor(): string | null | undefined;
+	get content(): T[] | null | undefined;
+}
+declare class CrudServiceProxy<T extends Identifiable<string>> implements ICrudServiceProxy<T> {
+	protected serviceProxy: IServiceProxy;
+	constructor(serviceProxy: IServiceProxy);
+	count(): Promise<number>;
+	create(entity: T): Promise<T>;
+	deleteById(id: string): Promise<void>;
+	findAll(pageable: Pageable): Promise<IterablePage<T>>;
+	findAllSinglePage(pageable: Pageable): Promise<Page<T>>;
+	findById(id: string): Promise<T>;
+	save(entity: T): Promise<T>;
+	findByIdNotIn(ids: string[], page: Pageable): Promise<Page<Identifiable<string>>>;
+	search(searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+	searchSinglePage(searchText: string, pageable: Pageable): Promise<Page<T>>;
+}
+declare class FunctionalIterablePage<T> extends AbstractIterablePage<T> {
+	private readonly pageFunction;
+	constructor(pageable: Pageable, page: Page<T>, pageFunction: (pageable: Pageable) => Promise<Page<T>>);
+	protected findNext(pageable: Pageable): Promise<Page<T>>;
+}
+export { logManager, createCRI, Version, TextEventFactory, StreamOperation, StreamData, Sort, SingleLoggerLevelsDescriptor, ServiceRegistry, ServiceContext, ServerInfo, Scope, Publish, ParticipantConstants, Participant, Pageable, Page, Order, OffsetPageable, NullHandling, LoggersDescriptor, LoggerLevelsDescriptor, LogManager, LogLevel, KinoticSingleton, KinoticError, Kinotic, JsonEventFactory, IterablePage, Identifiable, IServiceRegistry, IServiceProxy, IParticipant, ILogManager, IEventFactory, IEventBus, IEvent, IEditableDataSource, IDataSource, ICrudServiceProxyFactory, ICrudServiceProxy, GroupLoggerLevelsDescriptor, FunctionalIterablePage, EventConstants, EventBus, Event, Direction, DefaultCRI, DataSourceUtils, CursorPageable, CrudServiceProxyFactory, CrudServiceProxy, ContextInterceptor, Context, ConnectionInfo, ConnectedInfo, ConnectHeaders, CRI, CONTEXT_METADATA_KEY, AuthorizationError, AuthenticationError, AbstractIterablePage };