@kosdev-code/kos-ui-sdk 2.0.2

package/models/models/kos-token/index.d.ts

@@ -0,0 +1,11 @@
+export interface IKosToken {
+    token?: string;
+}
+declare class KosToken implements IKosToken {
+    private _token?;
+    constructor();
+    get token(): string | undefined;
+    set token(token: string | undefined);
+}
+export default KosToken;
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-token/index.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AACD,cAAM,QAAS,YAAW,SAAS;IACjC,OAAO,CAAC,MAAM,CAAC,CAAS;;IAQxB,IAAI,KAAK,uBAER;IAED,IAAI,KAAK,CAAC,KAAK,oBAAA,EAEd;CACF;AAED,eAAe,QAAQ,CAAC"}

package/models/models/log-block/index.d.ts

@@ -0,0 +1,6 @@
+export { LogBlockContainer } from './log-block-container-registration';
+export { LogBlock } from './log-block-registration';
+export type * from './types';
+export type { LogBlockModel } from './log-block-model';
+export type { LogBlockContainerModel } from './log-block-container-model';
+//# sourceMappingURL=index.d.ts.map

package/models/models/log-block/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/models/models/log-block/log-block-container-model.d.ts

@@ -0,0 +1,23 @@
+import { LogBlockContainerOptions } from './types';
+import { LogBlockModel } from './log-block-model';
+import { IKosModelHolder, PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+import { IKosModelContainer } from '../../../core/core/kos-container-model';
+
+export declare const MODEL_TYPE = "log-block-container-model";
+export type LogBlockContainerModel = PublicModelInterface<LogBlockContainerModelImpl>;
+export declare class LogBlockContainerModelImpl implements IKosIdentifiable, IKosModelHolder<LogBlockModel>, IKosDataModel {
+    id: string;
+    private logger;
+    private _models;
+    constructor(modelId: string, options: LogBlockContainerOptions, context: KosCreationContext);
+    getModel(id: string): LogBlockModel | undefined;
+    get models(): IKosModelContainer<LogBlockModel>;
+    get data(): LogBlockModel[];
+    addModel(model: LogBlockModel): void;
+    removeModel(id: string): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=log-block-container-model.d.ts.map

package/models/models/log-block/log-block-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-container-model.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,UAAU,8BAA8B,CAAC;AAEtD,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,CAAC;AAEnD,qBACa,0BACX,YAAW,gBAAgB,EAAE,eAAe,CAAC,aAAa,CAAC,EAAE,aAAa;IAE1E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,OAAO,CAAoC;gBAE3D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,kBAAkB;IAa7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,sCAET;IACD,IAAI,IAAI,oBAEP;IAED,QAAQ,CAAC,KAAK,EAAE,aAAa;IAI7B,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/log-block/log-block-container-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogBlockContainerOptions } from './types';
+import { LogBlockContainerModel } from './log-block-container-model';
+import { KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # LogBlockContainer
+ *
+ * The registration bean includes convenience methods for creating and working with LogBlockContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: LogBlockContainer.type, id: "logBlockContainerId"})
+ * private logBlockContainerModel: LogBlockContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogBlockContainerModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = LogBlockContainer.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a LogBlockContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogBlockContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogBlockContainerModel
+ *    // and the compiler will know that the model has the LogBlockContainerModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { LogBlockContainer } from "@kosdev-code/kos-ui-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...LogBlockContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logBlockContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const LogBlockContainer: KosModelRegistrationFactory<LogBlockContainerModel, LogBlockContainerOptions>;
+//# sourceMappingURL=log-block-container-registration.d.ts.map

package/models/models/log-block/log-block-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAM1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,iBAAiB,+EAM5B,CAAC"}

package/models/models/log-block/log-block-model.d.ts

@@ -0,0 +1,28 @@
+import { LogBlockOptions } from './types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+
+export declare const MODEL_TYPE = "log-block-model";
+export type LogBlockModel = PublicModelInterface<LogBlockModelImpl>;
+export declare class LogBlockModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    nodeId: string;
+    stream: string;
+    blockNum: number;
+    startLineNum: number;
+    endLineNum: number;
+    startTime: Date;
+    endTime: Date;
+    lineCount: number;
+    lines: string[];
+    inc: number;
+    constructor(modelId: string, options: LogBlockOptions, context: KosCreationContext);
+    syncLines(): Promise<void>;
+    updateModel(options: LogBlockOptions): void;
+    addLines(lines: string[], replace?: boolean): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=log-block-model.d.ts.map

package/models/models/log-block/log-block-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,UAAU,oBAAoB,CAAC;AAE5C,MAAM,MAAM,aAAa,GAAG,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;AAEpE,qBACa,iBAAkB,YAAW,aAAa,EAAE,gBAAgB;IACvE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,GAAG,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,kBAAkB;IAiBvB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAehC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAQ3C,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAS5C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/log-block/log-block-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogBlockOptions } from './types';
+import { LogBlockModel } from './log-block-model';
+import { KosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # LogBlock
+ *
+ * The registration bean includes convenience methods for creating and working with LogBlockModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: LogBlock.type, id: "logBlockId"})
+ * private logBlockModel: LogBlockModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogBlockModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = LogBlock.factory("logBlockId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a LogBlockModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogBlock.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogBlockModel
+ *    // and the compiler will know that the model has the LogBlockModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { LogBlock } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(LogBlock);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logBlock model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const LogBlock: KosModelRegistrationFactory<LogBlockModel, LogBlockOptions>;
+//# sourceMappingURL=log-block-registration.d.ts.map

package/models/models/log-block/log-block-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,QAAQ,6DAMnB,CAAC"}

package/models/models/log-block/types/index.d.ts

@@ -0,0 +1,38 @@
+// ---------------  LogBlock ---------------
+
+export interface LogBlockOptions {
+  nodeId: string;
+  stream: string;
+  blockNum: number;
+  startLineNum: number;
+  endLineNum: number;
+  startTime: Date;
+  endTime: Date;
+  lineCount: number;
+}
+
+// ---------------  LogBlockContainer ---------------
+export interface LogBlockContainerOptions {}
+
+export interface LogBlockType {
+  nodeId: string;
+  stream: string;
+  blockNum: number;
+  startLineNum: number;
+  endLineNum: number;
+  startTime: number;
+  endTime: number;
+  lineCount: number;
+}
+
+export interface LogLinesType {
+  nodeId: string;
+  stream: string;
+  blockNum: number;
+  startLineNum: number;
+  endLineNum: number;
+  startTime: number;
+  endTime: number;
+  lineCount: number;
+  lines: string[];
+}

package/models/models/log-stream/index.d.ts

@@ -0,0 +1,7 @@
+export { LogStreamContainer } from './log-stream-container-registration';
+export { LogStream } from './log-stream-registration';
+export type * from './types';
+export type { LogStreamModel } from './log-stream-model';
+export type { LogStreamContainerModel } from './log-stream-container-model';
+export * as LogStreamServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/log-stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/models/models/log-stream/log-stream-container-model.d.ts

@@ -0,0 +1,35 @@
+import { LogStreamContainerOptions } from './types';
+import { LogStreamModel } from './log-stream-model';
+import { LogBlockType, LogLinesType } from '../log-block';
+import { IKosModelHolder, PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+import { IKosModelContainer } from '../../../core/core/kos-container-model';
+
+export declare const MODEL_TYPE = "log-stream-container-model";
+export type LogStreamContainerModel = PublicModelInterface<LogStreamContainerModelImpl>;
+export declare class LogStreamContainerModelImpl implements IKosIdentifiable, IKosModelHolder<LogStreamModel>, IKosDataModel {
+    id: string;
+    private logger;
+    selectedStream?: LogStreamModel;
+    private _models;
+    constructor(modelId: string, options: LogStreamContainerOptions, context: KosCreationContext);
+    getModel(id: string): LogStreamModel | undefined;
+    get models(): IKosModelContainer<LogStreamModel>;
+    get data(): LogStreamModel[];
+    updateModel(_options: LogStreamContainerOptions): void;
+    addModel(model: LogStreamModel): void;
+    removeModel(id: string): void;
+    updateSelectedStream(stream?: LogStreamModel): void;
+    handleStreamAdded(data: {
+        stream: string;
+    }): void;
+    handleAddBlock(data: LogBlockType, payload: any): void;
+    handleRemoveBlock(data: LogBlockType, payload: any): void;
+    handleUpdateBlock(data: LogBlockType, payload: any): void;
+    handleLogLine(data: LogLinesType, payload: any): void;
+    init(): Promise<void>;
+    subscribeToLogStream(stream: string): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=log-stream-container-model.d.ts.map

package/models/models/log-stream/log-stream-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-container-model.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD,eAAO,MAAM,UAAU,+BAA+B,CAAC;AAEvD,MAAM,MAAM,uBAAuB,GACjC,oBAAoB,CAAC,2BAA2B,CAAC,CAAC;AAOpD,qBACa,2BACX,YAAW,gBAAgB,EAAE,eAAe,CAAC,cAAc,CAAC,EAAE,aAAa;IAE3E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,cAAc,CAAC,EAAE,cAAc,CAAC;IACtB,OAAO,CAAC,OAAO,CAAqC;gBAE5D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,kBAAkB;IAW7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,uCAET;IACD,IAAI,IAAI,qBAEP;IAED,WAAW,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI;IAItD,QAAQ,CAAC,KAAK,EAAE,cAAc;IAI9B,WAAW,CAAC,EAAE,EAAE,MAAM;IAKtB,oBAAoB,CAAC,MAAM,CAAC,EAAE,cAAc;IAQ5C,iBAAiB,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;IAgB1C,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,KAAA;IAa1C,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,KAAA;IAa7C,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,KAAA;IAa7C,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,KAAA;IAQnC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWnD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB5B"}

package/models/models/log-stream/log-stream-container-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogStreamContainerOptions } from './types';
+import { LogStreamContainerModel } from './log-stream-container-model';
+import { SingletonKosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # LogStreamContainer
+ *
+ * The registration bean includes convenience methods for creating and working with LogStreamContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: LogStreamContainer.type, id: "logStreamContainerId"})
+ * private logStreamContainerModel: LogStreamContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogStreamContainerModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = LogStreamContainer.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a LogStreamContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogStreamContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogStreamContainerModel
+ *    // and the compiler will know that the model has the LogStreamContainerModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { LogStreamContainer } from "@kosdev-code/kos-ui-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...LogStreamContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logStreamContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const LogStreamContainer: SingletonKosModelRegistrationFactory<LogStreamContainerModel, LogStreamContainerOptions>;
+//# sourceMappingURL=log-stream-container-registration.d.ts.map

package/models/models/log-stream/log-stream-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AAErE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAM5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,kBAAkB,0FAM7B,CAAC"}

package/models/models/log-stream/log-stream-model.d.ts

@@ -0,0 +1,38 @@
+import { LogStreamOptions } from './types';
+import { LogBlockType } from '../log-block';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, IKosVisitor, KosCreationContext } from '../../../core/core/kosModel';
+
+export declare const MODEL_TYPE = "log-stream-model";
+export type LogStreamModel = PublicModelInterface<LogStreamModelImpl>;
+export declare class LogStreamModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    nodeId: string;
+    private _blocks;
+    name: string;
+    currentBlockId: string;
+    isResetting: boolean;
+    constructor(modelId: string, options: LogStreamOptions, context: KosCreationContext);
+    get firstLineNum(): number;
+    get currentBlock(): import('../log-block').LogBlockModel | undefined;
+    get populated(): import('../log-block').LogBlockModel[];
+    get blocks(): import('../log-block').LogBlockModel[];
+    get totalLineCount(): number;
+    accept(visitor: IKosVisitor<IKosDataModel>): void;
+    updateBlock(blockData: LogBlockType): void;
+    addBlock(blockData: LogBlockType): void;
+    removeBlock(blockNum: number): void;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    reset(): Promise<void>;
+    init(): Promise<void>;
+    load(): Promise<void>;
+    private generatorInstance?;
+    private shouldStop;
+    start(): AsyncGenerator<string, void, void>;
+    stop(): void;
+    streamLogs(): AsyncGenerator<string, void, void>;
+}
+//# sourceMappingURL=log-stream-model.d.ts.map

package/models/models/log-stream/log-stream-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-model.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EAEX,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;AAEtE,qBACa,kBAAmB,YAAW,aAAa,EAAE,gBAAgB;IACxE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,OAAO,CAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;gBAEnB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAa7B,IAAI,YAAY,WAGf;IACD,IAAI,YAAY,qDAIf;IAED,IAAI,SAAS,2CAEZ;IACD,IAAI,MAAM,2CAET;IAED,IAAI,cAAc,WAEjB;IAED,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,aAAa,CAAC;IAI1C,WAAW,CAAC,SAAS,EAAE,YAAY;IAgCnC,QAAQ,CAAC,SAAS,EAAE,YAAY;IAwBhC,WAAW,CAAC,QAAQ,EAAE,MAAM;IAGtB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB3B,OAAO,CAAC,iBAAiB,CAAC,CAAqC;IAC/D,OAAO,CAAC,UAAU,CAAS;IAE3B,KAAK;IAML,IAAI;IAKG,UAAU,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;CAiExD"}

package/models/models/log-stream/log-stream-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogStreamModel } from './log-stream-model';
+import { LogStreamOptions } from './types';
+import { KosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # LogStream
+ *
+ * The registration bean includes convenience methods for creating and working with LogStreamModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: LogStream.type, id: "logStreamId"})
+ * private logStreamModel: LogStreamModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogStreamModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = LogStream.factory("logStreamId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a LogStreamModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogStream.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogStreamModel
+ *    // and the compiler will know that the model has the LogStreamModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { LogStream } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(LogStream);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logStream model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const LogStream: KosModelRegistrationFactory<LogStreamModel, LogStreamOptions>;
+//# sourceMappingURL=log-stream-registration.d.ts.map

package/models/models/log-stream/log-stream-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,SAAS,+DAMpB,CAAC"}

package/models/models/log-stream/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './log-stream-services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/log-stream/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/models/models/log-stream/services/log-stream-services.d.ts

@@ -0,0 +1,22 @@
+import { LogLinesType } from '../../log-block';
+import { ApiPath, KosApi } from '../../../utils/service';
+import { ClientResponse, DeepRequired, ElementType, ServiceResponse } from '../../../../core';
+
+export declare const getKosConnectionId: () => string | undefined;
+declare const SERVICE_PATH: ApiPath;
+export type LogStreamContainerClientResponse = ClientResponse<KosApi, typeof SERVICE_PATH, "get">;
+export type LogStreamContainerResponse = DeepRequired<ElementType<LogStreamContainerClientResponse>>;
+/**
+ * @category Service
+ * Retrieves the initial list of  log-stream-container data.
+ */
+export declare const getLogStreams: () => Promise<ServiceResponse<LogStreamContainerClientResponse>>;
+export declare const subscribeToLogStream: (stream: string, nodeId?: string) => Promise<void>;
+export declare const unsubscribeFromLogStream: (stream: string) => Promise<void>;
+export declare const createOverride: () => Promise<void>;
+declare const SERVICE_BLOCKS_PATH: ApiPath;
+export type LogStreamBlocksClientResponse = ClientResponse<KosApi, typeof SERVICE_BLOCKS_PATH, "get">;
+export declare const getLogStreamBlocks: (stream: string) => Promise<ServiceResponse<LogStreamBlocksClientResponse>>;
+export declare const getLogStreamBlock: (stream: string, blockId: number) => Promise<ServiceResponse<LogLinesType>>;
+export {};
+//# sourceMappingURL=log-stream-services.d.ts.map

package/models/models/log-stream/services/log-stream-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/services/log-stream-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAE1B,OAAY,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAOpD,eAAO,MAAM,kBAAkB,QAAO,MAAM,GAAG,SAQ9C,CAAC;AAIF,QAAA,MAAM,YAAY,EAAE,OAA+C,CAAC;AACpE,MAAM,MAAM,gCAAgC,GAAG,cAAc,CAC3D,MAAM,EACN,OAAO,YAAY,EACnB,KAAK,CACN,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,YAAY,CACnD,WAAW,CAAC,gCAAgC,CAAC,CAC9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAa,QACrC,gBAAgB,gCAAgC,CAAC,CAclD,CAAC;AAEF,eAAO,MAAM,oBAAoB,WACvB,MAAM,sBAEb,QAAQ,IAAI,CAcd,CAAC;AAEF,eAAO,MAAM,wBAAwB,WAC3B,MAAM,KACb,QAAQ,IAAI,CASd,CAAC;AAEF,eAAO,MAAM,cAAc,QAAa,QAAQ,IAAI,CAcnD,CAAC;AAEF,QAAA,MAAM,mBAAmB,EAAE,OACoB,CAAC;AAChD,MAAM,MAAM,6BAA6B,GAAG,cAAc,CACxD,MAAM,EACN,OAAO,mBAAmB,EAC1B,KAAK,CACN,CAAC;AAEF,eAAO,MAAM,kBAAkB,WACrB,MAAM,KACb,QAAQ,gBAAgB,6BAA6B,CAAC,CAcxD,CAAC;AAEF,eAAO,MAAM,iBAAiB,WACpB,MAAM,WACL,MAAM,KACd,QAAQ,gBAAgB,YAAY,CAAC,CAevC,CAAC"}

package/models/models/log-stream/types/index.d.ts

@@ -0,0 +1,9 @@
+// ---------------  LogStream ---------------
+
+export interface LogStreamOptions {
+  name: string;
+  nodeId: string;
+}
+
+// ---------------  LogStreamContainer ---------------
+export interface LogStreamContainerOptions {}

package/models/models/network-interface/index.d.ts

@@ -0,0 +1,7 @@
+export { NetworkInterfaceContainer } from './network-interface-container-registration';
+export { NetworkInterface } from './network-interface-registration';
+export type * from './types';
+export type { NetworkInterfaceModel } from './network-interface-model';
+export type { NetworkInterfaceContainerModel } from './network-interface-container-model';
+export * as NetworkInterfaceServices from './services';
+//# sourceMappingURL=index.d.ts.map