@opentap/runner-client 2.29.0 → 2.29.1

package/dist/cjs/RunnerClient.d.ts

@@ -0,0 +1,93 @@
+import { ConnectionOptions, Consumer, NatsError, Subscription, SubscriptionOptions } from 'nats.ws';
+import { RunnerUpdateRequest } from './requestDTOs';
+import { ISession, ISessionMetricInfo, Image, MetadataUpdatedEvent, RepositoryPackageReference, Session } from './DTOs';
+import { BaseClient } from './BaseClient';
+export declare class RunnerClient extends BaseClient {
+    private runnerId;
+    default: {
+        startSession: (testPlanRepositoryReference?: RepositoryPackageReference, timeout?: number) => Promise<Session>;
+        startSessionWithOverriddenImage: (testPlanReference?: RepositoryPackageReference, imageOverride?: Image, timeout?: number) => Promise<Session>;
+        getImage: () => Promise<Image>;
+        setImage: (image: Image) => Promise<Image>;
+        getSettings: () => Promise<RepositoryPackageReference | undefined>;
+        setSettings: (repositoryPackageReference: RepositoryPackageReference) => Promise<void>;
+    };
+    constructor(baseSubject: string, options: ConnectionOptions);
+    /**
+     * Get the created image with the specified ID.
+     * @param imageId
+     * @returns {{Promise<Image>}}
+     */
+    getImage(imageId: string): Promise<Image>;
+    /**
+     * Get all created images
+     * @returns {{Promise<Image[]>}}
+     */
+    getImages(): Promise<Image[]>;
+    /**
+     * Get all sessions
+     * @returns {{Promise<Session[]>}}
+     */
+    getSessions(): Promise<Session[]>;
+    setSession(session: ISession): Promise<Session>;
+    /**
+     * Create a OpenTAP package configuration image from a list image inputs consisting of user specified packages and repositories.
+     * @param {Image[]} images List of images
+     * @param {number} timeout Optional timeout in milliseconds
+     * @returns {{Promise<Image>}}
+     */
+    resolveImage(images: Image[], timeout?: number): Promise<Image>;
+    /**
+     * Dry runs to resolve an image from a list of images. Dry run means that no packages will be downloaded.
+     * @param {Image[]} images List of images
+     * @param {number} timeout Optional timeout in milliseconds
+     * @returns {{Promise<Image>}}
+     */
+    resolveImageDryRun(images: Image[], timeout?: number): Promise<Image>;
+    /**
+     * Shut down a session
+     * @param sessionId the ID of the session to shut down
+     * @returns {{Promise<void>}}
+     */
+    shutdownSession(sessionId: string): Promise<void>;
+    /**
+     * Start a session
+     * @returns {{Promise<Session>}}
+     */
+    startSession(): Promise<Session>;
+    /**
+     * Get the session manager image.
+     * @returns {{Promise<Image>}}
+     */
+    getSessionManagerImage(): Promise<Image>;
+    /**
+     * Start a session based on an image.
+     * @param imageId
+     * @returns {{Promise<Session>}}
+     */
+    startImageSession(image: Image): Promise<Session>;
+    /**
+     * Update the `Runner` plugin to the given version
+     * @param runnerUpdateRequest
+     * @returns {{Promise<void>}}
+     */
+    updateRunner(runnerUpdateRequest: RunnerUpdateRequest): Promise<void>;
+    /**
+     * Subscribe to the MetadataUpdated event
+     * @param  {(event:MetadataUpdatedEvent|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectMetadataUpdatedEvents(handler: (event: MetadataUpdatedEvent | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to metrics published for the given SessionMetricInfo from the idle session
+     * @param  {ISessionMetricInfo} metricInfo
+     * @param  {(result:MetricValue|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectMetric(metricInfo: ISessionMetricInfo, inactiveThresholdMilliseconds: number, maxBatchSize: number, handler: (metricData: {
+        encodedMetrics: Uint8Array[];
+        timestamps: number[];
+    }) => void): Promise<Consumer>;
+}

package/dist/cjs/SessionClient.d.ts

@@ -0,0 +1,359 @@
+import { BreakPoints, CommonContext, CommonSettings, DataGridControl, IMetricsConfiguration, Image, Interaction, ListItemType, LogList, MetricsConfiguration, OnTestPlanRun, OnTestStepRun, Parameter, RepositoryPackageDefinition, RepositoryPackageReference, Resource, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog } from './DTOs';
+import { ConnectionOptions, NatsError, Subscription, SubscriptionOptions } from 'nats.ws';
+import { BaseClient } from './BaseClient';
+export declare class SessionClient extends BaseClient {
+    private subscriptions;
+    constructor(baseSubject: string, options: ConnectionOptions);
+    /**
+     * @param sessionLogsHandler Function to be called when log list or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription object
+     */
+    connectSessionLogs(sessionLogsHandler: (logList: LogList | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * @param eventHandler Function to be called when session event or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription object
+     */
+    connectSessionEvents(eventHandler: (sessionEvent: SessionEvent | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): void;
+    /**
+     * @param resultHandler Function to be called when result or error is received
+     * @param testRunHandler Function to be called when test run or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription array: Result and Test Run subscriptions
+     */
+    connectSessionResults(resultHandler: (result: Result | undefined, err: NatsError | Error | null) => void, testRunHandler: (testRun: TestRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): [Subscription, Subscription];
+    /**
+     * @param testRunHandler Function to be called when test run or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription array: Result and Test Run subscriptions
+     */
+    connectTestRunEvents(testRunHandler: (testRun: TestRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the TestPlanRun events for the given test plan run ID.
+     * @param  {string} testPlanRunId
+     * @param  {(event:OnTestPlanRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunEvents(testPlanRunId: string, handler: (event: OnTestPlanRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test plan run logs for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(logList:LogList|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunLogs(testPlanRunId: string, handler: (logList: LogList | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test plan run parameter events for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunParameterEvents(testPlanRunId: string, handler: (event: Parameter[] | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run events for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(testRun:OnTestStepRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunEvents(testPlanRunId: string, testStepRunId: string, handler: (testStepRunId: string | undefined, testRun: OnTestStepRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run parameters for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunParameterEvents(testPlanRunId: string, testStepRunId: string, handler: (event: Parameter[] | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run results for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {string} resultName
+     * @param  {(result:Result|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunResults(testPlanRunId: string, testStepRunId: string, resultName: string, handler: (result: Result | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Unsubscibe from session events
+     */
+    unsubscribeSessionEvents(): void;
+    /**
+     * Retrieve session logs
+     * @param id (optional)
+     * @param level (optional)
+     * @param excludedSource (optional)
+     * @param filterText (optional)
+     * @param offset (optional)
+     * @param limit (optional)
+     * @return Successfully retrieved OpenTAP log messages.
+     */
+    getSessionLogs(id?: string, levels?: number[], excludedSources?: string[], filterText?: string, offset?: number, limit?: number): Promise<LogList>;
+    /**
+     * Retrieve session log indexes
+     * @param id (optional)
+     * @param level (optional)
+     * @param excludedSource (optional)
+     * @param filterText (optional)
+     * @param searchText (optional)
+     * @return Logs indexes retrieved
+     */
+    sessionLogSearch(id: string | undefined, levels: number[] | null | undefined, excludedSources: string[] | null | undefined, filterText: string | null | undefined, searchText: string | null | undefined): Promise<number[]>;
+    /**
+     * Retrieve log sources
+     * @param id (optional)
+     * @return Logs indexes retrieved
+     */
+    sessionLogSources(id: string | undefined): Promise<string[]>;
+    /**
+     * Retrieve session log counts
+     * @param id (optional)
+     * @return Logs indexes retrieved
+     */
+    sessionLogCounts(id: string | undefined): Promise<{
+        [key: string]: number;
+    }>;
+    /**
+     * Retrieve log severities
+     * @return Log levels retrieved
+     */
+    logLevels(): Promise<{
+        [key: string]: string;
+    }>;
+    /**
+     * Get status, with an optional testplan execution completion timeout
+     * @param {number | null | undefined} timeout (optional)
+     * @return RunStatus retrieved
+     */
+    getStatus(timeout: number | null | undefined): Promise<RunStatus>;
+    /**
+     * Upload test plan XML
+     * @param xml Test Plan XML
+     * @return Test plan loaded. List of load errors is returned.
+     */
+    setTestPlanXML(xml: string): Promise<string[]>;
+    /**
+     * Retrieve loaded test plan XML
+     * @return Test plan retrieved
+     */
+    getTestPlanXML(): Promise<string>;
+    /**
+     * Downloads the resource from the runner and returns it as raw bytes
+     * @return Raw bytes representing the resource
+     */
+    downloadResource(resource: Resource): Promise<Uint8Array>;
+    /**
+     * Load test plan using a test plan TapPackage from a repository
+     * @param {RepositoryPackageDefinition} packageReference
+     * @return Test plan loaded. List of load errors is returned.
+     */
+    loadTestPlanFromRepository(packageReference: RepositoryPackageReference): Promise<string[]>;
+    /**
+     * Save currently loaded test plan to a repository
+     * @param {RepositoryPackageDefinition} packageReference
+     * @return Test plan uploaded.
+     */
+    saveTestPlanToRepository(packageReference: RepositoryPackageDefinition): Promise<void>;
+    /**
+     * Test plan resources opened
+     * @return Test plan resources opened.
+     */
+    resourcesOpen(): Promise<TestPlan>;
+    /**
+     * Test plan resources closed
+     * @return Test plan resources closed.
+     */
+    resourcesClose(): Promise<TestPlan>;
+    /**
+     * Retrieve test plan or test step settings
+     * @param {string} contextId
+     * @return List of settings retrieved
+     */
+    getSettings(contextId: string): Promise<Setting[]>;
+    /**
+     * Change test plan or test step settings
+     * @param {string} contextId
+     * @param {Setting[]} settings
+     * @return Settings changed
+     */
+    setSettings(contextId: string, settings: Setting[]): Promise<Setting[]>;
+    /**
+     * Retrieve test plan structure
+     * @param {string[] | null | undefined} properties
+     * @return Test plan retrieved
+     */
+    getTestPlan(properties: string[] | null | undefined): Promise<TestPlan>;
+    /**
+     * Change test plan structure
+     * @param {TestPlan} plan
+     * @return Test plan changed
+     */
+    setTestPlan(plan: TestPlan): Promise<TestPlan>;
+    /**
+     * Set the name of the test plan
+     * @param {string} testPlanName
+     * @return {Promise<void>}
+     */
+    setTestPlanName(testPlanName: string): Promise<void>;
+    /**
+     * Retrieve all validation errors present in the test plan
+     * @return Retrieved validation errors for loaded TestPlan
+     */
+    getValidationErrors(): Promise<TestStepValidationError[]>;
+    /**
+     * Retrieve or change common test step settings
+     * @param {CommonSettings} commonSettings
+     * @return Common test step settings retrieved or changed
+     */
+    commonStepSettings(commonSettings: CommonSettings): Promise<CommonSettings>;
+    /**
+     * Retrieve or invoke common test step settings context menu items
+     * @param {string} propertyName
+     * @param {TestPlan} commonContext
+     * @return Get context menu (right-click menu) for a property in the testplan or teststep
+     */
+    commonStepSettingsContextMenu(propertyName: string | null, commonContext: CommonContext): Promise<CommonContext>;
+    /**
+     * Retrieve all pending user input IDs
+     * @return Retrieved pending user inputs
+     */
+    getUserInputs(): Promise<string[]>;
+    /**
+     * Retrieve pending user input based on ID
+     * @param {string} id
+     * @return Retrieved pending user input
+     */
+    getUserInput(id: string): Promise<Interaction>;
+    /**
+     * Modify or answer pending user input based on ID
+     * @param interaction
+     * @returns {Promise<Interaction>}
+     */
+    setUserInput(interaction: Interaction): Promise<Interaction>;
+    /**
+     * Property context menu
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @return Get context menu (right-click menu) for a property in the testplan or teststep
+     */
+    getContextMenu(contextId: string, propertyName: string | null): Promise<Setting[]>;
+    /**
+     * Property context menu
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @param {Setting[]} contextMenu
+     * @return Set context menu (right-click menu) for a property in the testplan or teststep
+     */
+    setContextMenu(contextId: string, propertyName: string | null, contextMenu: Setting[]): Promise<Setting[]>;
+    /**
+     * Get data grid
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @return DataGridControl retrieved
+     */
+    getDataGrid(contextId: string, propertyName: string | null): Promise<DataGridControl>;
+    /**
+     * Set data grid
+     * @return Set data grid
+     */
+    setDataGrid(contextId: string, propertyName: string, dataGridControl: DataGridControl): Promise<DataGridControl>;
+    /**
+     * Add item type to data grid
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @param {string | null} typeName
+     * @return DataGridControl retrieved
+     */
+    addDataGridItemType(contextId: string, propertyName: string | null, typeName: string | null): Promise<DataGridControl>;
+    /**
+     * Add item to data grid
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @return DataGridControl retrieved
+     */
+    addDataGridItem(contextId: string, propertyName: string | null): Promise<DataGridControl>;
+    /**
+     * Get item types available in the data grid
+     * @param {string} contextId
+     * @param {string | null} propertyName
+     * @return List of ListItemType retrieved
+     */
+    getDataGridTypes(contextId: string, propertyName: string | null): Promise<ListItemType[]>;
+    /**
+     * Retrieve static available step type information.
+     * @return StepTypes retrieved
+     */
+    getStepTypes(): Promise<TestStepType[]>;
+    /**
+     * Pause test plan execution at next possible test step
+     */
+    setPauseNext(): Promise<void>;
+    /**
+     * Retrieve breakpoints set in test plan
+     */
+    getBreakpoints(): Promise<BreakPoints>;
+    /**
+     * Set breakpoints in test plan
+     * @param {BreakPoints} breakPointsDto
+     * @return BreakPoints retrieved
+     */
+    setBreakpoints(breakPointsDto: BreakPoints): Promise<BreakPoints>;
+    /**
+     * Jump test plan execution to step. Execution state must be 'breaking'.
+     * @param {string} stepId
+     */
+    setJumpToStep(stepId: string): Promise<void>;
+    /**
+     * Execute test plan with attaching metadata
+     * @param {Parameter[]} parameters
+     * @return RunStatus retrieved
+     */
+    runTestPlan(parameters: Parameter[]): Promise<RunStatus>;
+    /**
+     * Abort test plan execution
+     */
+    abortTestPlan(): Promise<void>;
+    /**
+     * Shuts down session
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Retrieves installed packages in this session
+     */
+    getImage(): Promise<Image>;
+    /**
+     * Retrieves session readiness
+     */
+    getReadiness(): Promise<void>;
+    /**
+     * Retrieves watchdog
+     */
+    getWatchDog(): Promise<WatchDog>;
+    /**
+     * Sets a new watchdog
+     * @param {WatchDog} watchDog
+     */
+    setWatchDog(watchDog: WatchDog): Promise<WatchDog>;
+    /**
+     * Retrieve settings types used in creating a Settings TapPackage
+     */
+    getSettingsTypes(): Promise<string[]>;
+    /**
+     * Get the metric information
+     * @returns Promise
+     */
+    getMetricsConfiguration(): Promise<MetricsConfiguration>;
+    /**
+     * Set the metric information. Used for setting up which metrics should be published for polling.
+     * @param  {IMetricsConfiguration} metricsRequest
+     * @returns Promise
+     */
+    setMetricsConfiguration(metricsRequest: IMetricsConfiguration): Promise<void>;
+}

package/dist/cjs/SystemClient.d.ts

@@ -0,0 +1,62 @@
+import { ConnectionOptions, Subscription, SubscriptionOptions } from 'nats.ws';
+import { ErrorResponse, RunnerEvent, TestPlanRunCompletedEventArgs, TestPlanRunStartEventArgs, TestStepRunCompletedEventArgs, TestStepRunStartEventArgs } from './DTOs';
+import { BaseClient } from './BaseClient';
+export interface RunnerLifetimeEvent {
+    RunnerId: string;
+    Subject: string;
+    Discriminator: string;
+}
+export declare class SystemClient extends BaseClient {
+    constructor(baseSubject: string, options: ConnectionOptions);
+    /**
+     * Subscribe to the lifetime event.
+     * @param listener
+     * @param {SubscriptionOptions} options
+     * @returns {Subscription}
+     */
+    subscribeLifetimeEventListener(listener: (error: ErrorResponse | null, message: RunnerLifetimeEvent | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the runner updated events for the given Runner ID.
+     * Wildcard can be used to receive all runner updated events.
+     * @param  {string} runnerId
+     * @param  {(error:ErrorResponse|null,message:RunnerEvent|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeRunnerUpdatedEvents(runnerId: string, listener: (error: ErrorResponse | null, message: RunnerEvent | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test step run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestStepRunStartEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestStepRunStartEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test step run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestStepRunCompletedEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestStepRunCompletedEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test plan run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestPlanRunStartEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestPlanRunStartEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test plan run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestPlanRunCompletedEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestPlanRunCompletedEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+}

package/dist/cjs/encoders.d.ts

@@ -0,0 +1,7 @@
+import { Codec } from 'nats.ws';
+export declare const numberCodec: Codec<number>;
+export declare const booleanCodec: Codec<boolean>;
+export declare const stringCodec: Codec<string>;
+export declare const jsonCodec: Codec<unknown>;
+export declare function NumberCodec(): Codec<number>;
+export declare function BooleanCodec(): Codec<boolean>;

package/dist/cjs/index.d.ts

@@ -0,0 +1,6 @@
+export { booleanCodec, jsonCodec, numberCodec, stringCodec } from './encoders';
+export { RunnerClient } from './RunnerClient';
+export { SessionClient } from './SessionClient';
+export { SystemClient, RunnerLifetimeEvent } from './SystemClient';
+export * from './DTOs';
+export * from 'nats.ws';

package/dist/cjs/package.json

@@ -1,3 +1,4 @@
 {
+    "name": "@opentap/runner-client",
     "type": "commonjs"
 }

package/dist/cjs/requestDTOs.d.ts

@@ -0,0 +1,78 @@
+import { CommonContext, ComponentSettingsBase, ComponentSettingsListItem, DataGridControl, Image, RepositoryPackageReference, Setting } from './DTOs';
+export interface DefaultSessionRequest {
+    imageOverride: Image | null;
+    testPlanReference: RepositoryPackageReference | null;
+}
+export interface SetSettingsRequest {
+    contextId: string;
+    settings: Setting[];
+}
+export interface PropertyReferenceRequest {
+    contextId: string;
+    propertyName: string | null;
+}
+export interface SetContextMenuRequest {
+    contextId: string;
+    propertyName: string | null;
+    contextMenu: Setting[];
+}
+export interface SetDataGridRequest {
+    contextId: string;
+    propertyName: string;
+    dataGridControl: DataGridControl;
+}
+export interface AddDataGridItemTypeRequest {
+    contextId: string;
+    propertyName: string | null;
+    typeName: string | null;
+}
+export interface CommonStepSettingsContextRequest {
+    commonContext: CommonContext;
+    propertyName: string | null;
+}
+export interface GetSessionLogsRequest {
+    id: string | undefined;
+    levels: number[] | undefined;
+    excludedSources: string[] | undefined;
+    filterText: string | undefined;
+    offset: number | undefined;
+    limit: number | undefined;
+}
+export interface GetSessionSearchRequest {
+    id: string | undefined;
+    levels: number[] | null | undefined;
+    excludedSources: string[] | null | undefined;
+    filterText: string | null | undefined;
+    searchText: string | null | undefined;
+}
+export interface GetComponentSettingsRequest {
+    groupName: string | undefined;
+    name: string | undefined;
+}
+export interface SetComponentSettingsRequest extends GetComponentSettingsRequest {
+    returnedSettings: ComponentSettingsBase | undefined;
+}
+export interface GetComponentSettingsListItemRequest extends GetComponentSettingsRequest {
+    index: number | undefined;
+}
+export interface SetComponentSettingsListItemRequest extends GetComponentSettingsListItemRequest {
+    item: ComponentSettingsListItem | undefined;
+}
+export interface GetComponentSettingDataGridRequest extends GetComponentSettingsListItemRequest {
+    propertyName: string | undefined;
+}
+export interface SetComponentSettingDataGridRequest extends GetComponentSettingDataGridRequest {
+    dataGridControl: DataGridControl | undefined;
+}
+export interface AddComponentSettingDataGridItemTypeRequest extends GetComponentSettingDataGridRequest {
+    typeName: string | undefined;
+}
+export interface AddComponentSettingsListItemRequest extends GetComponentSettingsRequest {
+    typeName: string | undefined;
+}
+export interface DownloadTapSettingsRequest {
+    groupName: string | undefined;
+}
+export interface RunnerUpdateRequest {
+    updateTo: string;
+}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,11 @@
+interface SubjectParts {
+    runnerId: string | undefined;
+    sessionId: string | undefined;
+}
+/**
+ * Get the runner ID and session ID from the subject as SubjectParts.
+ * @param  {string} subject
+ * @returns SubjectParts
+ */
+export declare const getSubjectParts: (subject: string) => SubjectParts;
+export {};

package/dist/mjs/package.json

@@ -1,3 +1,4 @@
 {
+    "name": "@opentap/runner-client",
     "type": "module"
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@opentap/runner-client",
-  "version": "2.29.0",
+  "version": "2.29.1",
   "description": "This is the web client for the OpenTAP Runner.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/mjs/index.js",
   "types": "./dist/mjs/index.d.ts",
   "exports": {
     "import": "./dist/mjs/index.js",
-    "require": "./dist/cjs/index.js"
+    "require": "./dist/cjs/index.js",
+    "types": "./dist/cjs/index.d.ts"
   },
   "scripts": {
     "build": "rimraf ./dist && tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json && bash ./post-build.sh",
@@ -45,7 +46,7 @@
     "typescript": "^4.8.2"
   },
   "dependencies": {
-    "nats.ws": "^1.29.0",
+    "nats.ws": "~1.29.0",
     "uuid": "^9.0.0",
     "events": "^3.3.0"
   },