@cognite/reveal-components 1.0.0

package/dist/foundation/commands/BaseFilterCommand.d.ts

@@ -0,0 +1,43 @@
+import { Color } from 'three';
+import { IconName } from '../utilities/types';
+import { BaseCommand } from './BaseCommand';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare abstract class BaseFilterCommand extends RenderTargetCommand {
+    protected _children: BaseFilterItemCommand[] | undefined;
+    get children(): BaseFilterItemCommand[] | undefined;
+    get hasChildren(): boolean;
+    get icon(): IconName;
+    protected getChildren(): Generator<BaseCommand>;
+    initializeChildrenIfNeeded(): void;
+    protected abstract createChildren(): BaseFilterItemCommand[];
+    /**
+     * Checks if all the children of the current instance are checked.
+     * Override this method to optimize the logic.
+     * @returns A boolean value indicating whether all the children are checked.
+     */
+    get isAllChecked(): boolean;
+    /**
+     * Checks if some the children of the current instance are checked.
+     * Override this method to optimize the logic.
+     * @returns A boolean value indicating whether some the children are checked.
+     */
+    get isSomeChecked(): boolean;
+    /**
+     * Toggles the checked state of all child filter items.
+     * Override this method to optimize the logic.
+     * If there are no child items, this method does nothing.
+     * @returns A boolean value indicating whether anything is changed
+     */
+    protected toggleAllCheckedCore(): boolean;
+    getSelectedLabel(): string;
+    toggleAllChecked(): boolean;
+    static getAllString(): string;
+    private static getNoneString;
+    private static getSelectedString;
+}
+export declare abstract class BaseFilterItemCommand extends RenderTargetCommand {
+    invokeCore(): boolean;
+    get color(): Color | undefined;
+    protected abstract setCheckedCore(value: boolean): boolean;
+    setChecked(value: boolean): void;
+}

package/dist/foundation/commands/BaseFilterCommand.js

@@ -0,0 +1,60 @@
+import { translate as e } from "../utilities/translation/translateUtils.js";
+import { RenderTargetCommand as t } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseFilterCommand.ts
+var n = class n extends t {
+	_children = void 0;
+	get children() {
+		return this._children;
+	}
+	get hasChildren() {
+		return this._children !== void 0 && this._children.length > 0;
+	}
+	get icon() {
+		return "Filter";
+	}
+	*getChildren() {
+		if (this._children !== void 0) for (let e of this._children) yield e;
+	}
+	initializeChildrenIfNeeded() {
+		this._children === void 0 && (this._children = this.createChildren(), this.attachChildren());
+	}
+	get isAllChecked() {
+		return this._children === void 0 || this._children.length === 0 ? !1 : this._children.every((e) => e.isChecked);
+	}
+	get isSomeChecked() {
+		return this._children === void 0 || this._children.length === 0 ? !1 : this._children.some((e) => e.isChecked);
+	}
+	toggleAllCheckedCore() {
+		if (this._children === void 0 || this._children.length === 0) return !1;
+		let e = this.isAllChecked;
+		for (let t of this._children) t.setChecked(!e);
+		return !0;
+	}
+	getSelectedLabel() {
+		if (this._children === void 0) return n.getNoneString();
+		let e = this._children.filter((e) => e.isChecked), t = e.length;
+		return t === 0 ? n.getNoneString() : t === this._children.length ? n.getAllString() : t === 1 ? e[0].label : t.toString() + " " + n.getSelectedString();
+	}
+	toggleAllChecked() {
+		return this.toggleAllCheckedCore() ? (this._renderTarget?.updateAllCommands(), !0) : !1;
+	}
+	static getAllString() {
+		return e({ key: "ALL" });
+	}
+	static getNoneString() {
+		return e({ key: "NONE" });
+	}
+	static getSelectedString() {
+		return e({ key: "SELECTED" });
+	}
+}, r = class extends t {
+	invokeCore() {
+		return this.setCheckedCore(!this.isChecked);
+	}
+	get color() {}
+	setChecked(e) {
+		this.setCheckedCore(e) && this._renderTarget?.updateAllCommands();
+	}
+};
+//#endregion
+export { n as BaseFilterCommand, r as BaseFilterItemCommand };

package/dist/foundation/commands/BaseInputCommand.d.ts

@@ -0,0 +1,14 @@
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare abstract class BaseInputCommand extends RenderTargetCommand {
+    private _content;
+    private _onCancel?;
+    getCancelButtonLabel(): TranslationInput | undefined;
+    abstract getPostButtonLabel(): TranslationInput | undefined;
+    abstract getPlaceholder(): TranslationInput | undefined;
+    get onCancel(): (() => void) | undefined;
+    set onCancel(onCancel: () => void);
+    get content(): string;
+    set content(content: string);
+    get isPostButtonEnabled(): boolean;
+}

package/dist/foundation/commands/BaseInputCommand.js

@@ -0,0 +1,24 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseInputCommand.ts
+var t = class extends e {
+	_content = "";
+	_onCancel;
+	getCancelButtonLabel() {}
+	get onCancel() {
+		return this._onCancel;
+	}
+	set onCancel(e) {
+		this._onCancel = e;
+	}
+	get content() {
+		return this._content;
+	}
+	set content(e) {
+		this._content = e, this.update();
+	}
+	get isPostButtonEnabled() {
+		return this._content.length > 0;
+	}
+};
+//#endregion
+export { t as BaseInputCommand };

package/dist/foundation/commands/BaseOptionCommand.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from './BaseCommand';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare enum OptionType {
+    Dropdown = 0,
+    Segmented = 1
+}
+/**
+ * Base class for all option like commands. Override createOptions to add options
+ * or use add method to add them in.
+ */
+export declare abstract class BaseOptionCommand extends RenderTargetCommand {
+    readonly optionType: OptionType;
+    private _children;
+    get children(): BaseCommand[] | undefined;
+    get hasChildren(): boolean;
+    constructor(optionType?: OptionType);
+    protected getChildren(): Generator<BaseCommand>;
+    protected createChildren(): BaseCommand[];
+    get selectedChild(): BaseCommand | undefined;
+    get checkedCount(): number;
+    protected add(child: BaseCommand): void;
+}

package/dist/foundation/commands/BaseOptionCommand.js

@@ -0,0 +1,37 @@
+import { count as e } from "../utilities/extensions/arrayUtils.js";
+import { RenderTargetCommand as t } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseOptionCommand.ts
+var n = /* @__PURE__ */ function(e) {
+	return e[e.Dropdown = 0] = "Dropdown", e[e.Segmented = 1] = "Segmented", e;
+}({}), r = class extends t {
+	optionType;
+	_children = void 0;
+	get children() {
+		return this._children === void 0 && (this._children = this.createChildren()), this._children;
+	}
+	get hasChildren() {
+		return this._children !== void 0 && this._children.length > 0;
+	}
+	constructor(e = 0) {
+		super(), this.optionType = e;
+	}
+	*getChildren() {
+		if (this._children !== void 0) for (let e of this._children) yield e;
+	}
+	createChildren() {
+		return [];
+	}
+	get selectedChild() {
+		let e = this.children;
+		if (e !== void 0) return e.find((e) => e.isChecked);
+	}
+	get checkedCount() {
+		return this.children === void 0 ? 0 : e(this.children, (e) => e.isChecked);
+	}
+	add(e) {
+		let t = this.children;
+		t !== void 0 && t.push(e);
+	}
+};
+//#endregion
+export { r as BaseOptionCommand, n as OptionType };

package/dist/foundation/commands/BaseSettingsCommand.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from './BaseCommand';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare abstract class BaseSettingsCommand extends RenderTargetCommand {
+    private readonly _children;
+    get children(): BaseCommand[];
+    get hasChildren(): boolean;
+    protected getChildren(): Generator<BaseCommand>;
+    add<T extends BaseCommand>(command: T): T | void;
+    clear(): void;
+}

package/dist/foundation/commands/BaseSettingsCommand.js

@@ -0,0 +1,27 @@
+import { clear as e } from "../utilities/extensions/arrayUtils.js";
+import { RenderTargetCommand as t } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseSettingsCommand.ts
+var n = class extends t {
+	_children = [];
+	get children() {
+		return this._children;
+	}
+	get hasChildren() {
+		return this._children.length > 0;
+	}
+	*getChildren() {
+		for (let e of this._children) yield e;
+	}
+	add(e) {
+		if (this._children.find((t) => t.equals(e)) !== void 0) {
+			console.error("Duplicated command given: " + e.name);
+			return;
+		}
+		return this._children.push(e), e;
+	}
+	clear() {
+		e(this._children);
+	}
+};
+//#endregion
+export { n as BaseSettingsCommand };

package/dist/foundation/commands/BaseSliderCommand.d.ts

@@ -0,0 +1,13 @@
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare abstract class BaseSliderCommand extends RenderTargetCommand {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+    protected constructor(min: number, max: number, step: number);
+    get marks(): Record<number, {
+        label: string;
+    }> | undefined;
+    abstract get value(): number;
+    abstract set value(value: number);
+    getValueLabel(): string;
+}

package/dist/foundation/commands/BaseSliderCommand.js

@@ -0,0 +1,16 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseSliderCommand.ts
+var t = class extends e {
+	min;
+	max;
+	step;
+	constructor(e, t, n) {
+		super(), this.min = e, this.max = t, this.step = n;
+	}
+	get marks() {}
+	getValueLabel() {
+		return this.value.toString();
+	}
+};
+//#endregion
+export { t as BaseSliderCommand };

package/dist/foundation/commands/BaseTool.d.ts

@@ -0,0 +1,63 @@
+import { Ray, Vector3 } from 'three';
+import { AnyIntersection } from '@cognite/reveal';
+import { Signal } from '@cognite/signal-utils';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { DomainObjectIntersection } from '../domainObjectsHelpers/DomainObjectIntersection';
+import { PopupStyle } from '../domainObjectsHelpers/PopupStyle';
+import { UndoManager } from '../undo/UndoManager';
+import { BaseCommand } from './BaseCommand';
+import { Toolbar } from './factory/ToolbarFactory';
+import { RenderTargetCommand } from './RenderTargetCommand';
+/**
+ * Base class for interactions in the 3D viewer
+ * Provides common functionality and virtual methods to be overridden by derived classes.
+ */
+export declare abstract class BaseTool extends RenderTargetCommand {
+    private readonly _undoManager;
+    get isChecked(): boolean;
+    protected invokeCore(): boolean;
+    get undoManager(): UndoManager | undefined;
+    get defaultCursor(): string;
+    getAnchoredDialogContent(): Signal<AnchoredDialogContent | undefined>;
+    getToolbarStyle(): PopupStyle;
+    onActivate(): void;
+    onDeactivate(): void;
+    clearDragging(): void;
+    onHover(_event: PointerEvent): void;
+    onHoverByDebounce(_event: PointerEvent): void;
+    onClick(_event: PointerEvent): Promise<void>;
+    onDoubleClick(_event: PointerEvent): Promise<void>;
+    onLeftPointerDown(_event: PointerEvent): Promise<void>;
+    onLeftPointerDrag(_event: PointerEvent): Promise<void>;
+    onLeftPointerUp(_event: PointerEvent): Promise<void>;
+    onRightPointerDown(_event: PointerEvent): Promise<void>;
+    onRightPointerDrag(_event: PointerEvent): Promise<void>;
+    onRightPointerUp(_event: PointerEvent): Promise<void>;
+    onWheel(_event: WheelEvent, _delta: number): Promise<void>;
+    onFocusChanged(_haveFocus: boolean): void;
+    onKey(_event: KeyboardEvent, _down: boolean): void;
+    onDeleteKey(): void;
+    onEscapeKey(): boolean;
+    onUndo(): void;
+    getIntersection(event: PointerEvent | WheelEvent, domainObjectPredicate?: (domainObject: DomainObject) => boolean): Promise<AnyIntersection | undefined>;
+    protected getSpecificIntersection(event: PointerEvent, domainObjectPredicate?: (domainObject: DomainObject) => boolean): DomainObjectIntersection | undefined;
+    getToolbar(): Toolbar | undefined;
+    private getRaycaster;
+    protected getRay(event: PointerEvent | WheelEvent, convertToCdf?: boolean): Ray;
+    private getNormalizedPixelCoordinates;
+    setDefaultCursor(): void;
+    setCursor(cursor: string): void;
+}
+/**
+ * AnchorDialog
+ */
+export type CustomListener = {
+    eventName: string;
+    callback: (event: Event) => void;
+};
+export type AnchoredDialogContent = {
+    position: Vector3;
+    onCloseCallback: () => void;
+    contentCommands: BaseCommand[];
+    customListeners?: CustomListener[];
+};

package/dist/foundation/commands/BaseTool.js

@@ -0,0 +1,109 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+import { ThreeView as t } from "../views/ThreeView.js";
+import { PopupStyle as n } from "../domainObjectsHelpers/PopupStyle.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as r } from "../renderTarget/convertCoordinates.js";
+import { CommandChanges as i } from "../domainObjectsHelpers/CommandChanges.js";
+import { getClosestDomainObjectIntersection as a } from "../domainObjectsHelpers/getClosestDomainObjectIntersection.js";
+import { UndoManager as o } from "../undo/UndoManager.js";
+import { getToolbar as s } from "./factory/ToolbarFactory.js";
+import { signal as c } from "@cognite/signal-utils";
+import { Raycaster as l } from "three";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseTool.ts
+var u = class extends e {
+	_undoManager = new o();
+	get isChecked() {
+		return this.activeTool === this;
+	}
+	invokeCore() {
+		return this.isChecked ? this.renderTarget.activateDefaultTool() : this.renderTarget.commandsController.setActiveTool(this), !0;
+	}
+	get undoManager() {
+		return this._undoManager;
+	}
+	get defaultCursor() {
+		return "default";
+	}
+	getAnchoredDialogContent() {
+		return c();
+	}
+	getToolbarStyle() {
+		return new n({
+			bottom: 8,
+			left: 16
+		});
+	}
+	onActivate() {
+		this.update(i.active), this.setDefaultCursor(), this.clearDragging();
+	}
+	onDeactivate() {
+		this.update(i.deactive), this.clearDragging();
+	}
+	clearDragging() {}
+	onHover(e) {}
+	onHoverByDebounce(e) {}
+	async onClick(e) {
+		await Promise.resolve();
+	}
+	async onDoubleClick(e) {
+		await Promise.resolve();
+	}
+	async onLeftPointerDown(e) {
+		await Promise.resolve();
+	}
+	async onLeftPointerDrag(e) {
+		await Promise.resolve();
+	}
+	async onLeftPointerUp(e) {
+		await Promise.resolve();
+	}
+	async onRightPointerDown(e) {
+		await Promise.resolve();
+	}
+	async onRightPointerDrag(e) {
+		await Promise.resolve();
+	}
+	async onRightPointerUp(e) {
+		await Promise.resolve();
+	}
+	async onWheel(e, t) {
+		await Promise.resolve();
+	}
+	onFocusChanged(e) {}
+	onKey(e, t) {}
+	onDeleteKey() {}
+	onEscapeKey() {
+		return !1;
+	}
+	onUndo() {}
+	async getIntersection(e, n) {
+		let r = this.renderTarget.viewer, i = r.getPixelCoordinatesFromEvent(e);
+		return n === void 0 ? await r.getAnyIntersectionFromPixel(i) : await r.getAnyIntersectionFromPixel(i, { predicate: (e) => n === void 0 || e instanceof t && n(e.domainObject) });
+	}
+	getSpecificIntersection(e, t) {
+		let { renderTarget: n, root: r } = this, i = n.viewer.getPixelCoordinatesFromEvent(e);
+		return a(n, r.getDescendants(), i, t);
+	}
+	getToolbar() {
+		return s(this);
+	}
+	getRaycaster(e) {
+		let { renderTarget: t } = this, n = this.getNormalizedPixelCoordinates(e), r = new l();
+		return r.setFromCamera(n, t.camera), r;
+	}
+	getRay(e, t = !1) {
+		let n = this.getRaycaster(e).ray;
+		return t && n.applyMatrix4(r), n;
+	}
+	getNormalizedPixelCoordinates(e) {
+		let { renderTarget: t } = this, { viewer: n } = t, r = n.getPixelCoordinatesFromEvent(e);
+		return n.getNormalizedPixelCoordinates(r);
+	}
+	setDefaultCursor() {
+		this.renderTarget.cursor = this.defaultCursor;
+	}
+	setCursor(e) {
+		this.renderTarget.cursor = e;
+	}
+};
+//#endregion
+export { u as BaseTool };

package/dist/foundation/commands/CustomBaseInputCommand.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export type FieldContent = {
+    type: 'text' | 'commentWithButtons' | 'comment';
+    content: string;
+} | {
+    type: 'customInput';
+    content: ReactNode;
+} | {
+    type: 'submitButtons';
+    content: undefined;
+};
+export declare abstract class CustomBaseInputCommand extends RenderTargetCommand {
+    protected _placeholders?: TranslationInput[];
+    protected _contents: FieldContent[];
+    protected _okButtonLabel?: TranslationInput;
+    protected _onFinish?: () => void;
+    protected _onCancel?: () => void;
+    getCancelButtonLabel(): TranslationInput | undefined;
+    abstract getPostButtonLabel(): TranslationInput | undefined;
+    abstract getPlaceholderByIndex(index: number): TranslationInput | undefined;
+    abstract getAllPlaceholders(): TranslationInput[] | undefined;
+    get contents(): FieldContent[];
+    get onFinish(): (() => void) | undefined;
+    set onFinish(onFinish: () => void);
+    set onCancel(onCancel: () => void);
+    get onCancel(): (() => void) | undefined;
+    invokeWithContent(contents: FieldContent[]): boolean;
+}

package/dist/foundation/commands/CustomBaseInputCommand.js

@@ -0,0 +1,41 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/CustomBaseInputCommand.ts
+var t = class extends e {
+	_placeholders;
+	_contents = [];
+	_okButtonLabel;
+	_onFinish;
+	_onCancel;
+	getCancelButtonLabel() {}
+	get contents() {
+		return this._contents;
+	}
+	get onFinish() {
+		return this._onFinish;
+	}
+	set onFinish(e) {
+		this._onFinish = e;
+	}
+	set onCancel(e) {
+		this._onCancel = e;
+	}
+	get onCancel() {
+		return this._onCancel;
+	}
+	invokeWithContent(e) {
+		this._contents = e;
+		let t = this.invoke();
+		return this._contents = n(this._contents), t;
+	}
+};
+function n(e) {
+	return e.map((e) => e.type === "text" || e.type === "comment" || e.type === "commentWithButtons" ? {
+		type: e.type,
+		content: ""
+	} : e.type === "customInput" || e.type === "submitButtons" ? {
+		type: e.type,
+		content: void 0
+	} : e);
+}
+//#endregion
+export { t as CustomBaseInputCommand };

package/dist/foundation/commands/DividerCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare class DividerCommand extends RenderTargetCommand {
+    get isVisible(): boolean;
+    equals(other: BaseCommand): boolean;
+    protected invokeCore(): boolean;
+}

package/dist/foundation/commands/DividerCommand.js

@@ -0,0 +1,15 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/DividerCommand.ts
+var t = class extends e {
+	get isVisible() {
+		return !0;
+	}
+	equals(e) {
+		return this === e;
+	}
+	invokeCore() {
+		throw Error("invoke should never be called on a divider.");
+	}
+};
+//#endregion
+export { t as DividerCommand };

package/dist/foundation/commands/DomainObjectCommand.d.ts

@@ -0,0 +1,7 @@
+import { DomainObject } from '../domainObjects/DomainObject';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare abstract class DomainObjectCommand<Type extends DomainObject> extends RenderTargetCommand {
+    protected readonly _domainObject: Type;
+    constructor(domainObject: Type);
+    get hasData(): boolean;
+}

package/dist/foundation/commands/DomainObjectCommand.js

@@ -0,0 +1,13 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/DomainObjectCommand.ts
+var t = class extends e {
+	_domainObject;
+	constructor(e) {
+		super(), this._domainObject = e;
+	}
+	get hasData() {
+		return !0;
+	}
+};
+//#endregion
+export { t as DomainObjectCommand };

package/dist/foundation/commands/FractionSliderCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseSliderCommand } from './BaseSliderCommand';
+export declare abstract class FractionSliderCommand extends BaseSliderCommand {
+    constructor();
+    getValueLabel(): string;
+}

package/dist/foundation/commands/FractionSliderCommand.js

@@ -0,0 +1,12 @@
+import { BaseSliderCommand as e } from "./BaseSliderCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/FractionSliderCommand.ts
+var t = 0, n = 1, r = .02, i = class extends e {
+	constructor() {
+		super(t, n, r);
+	}
+	getValueLabel() {
+		return Math.round(100 * this.value) + "%";
+	}
+};
+//#endregion
+export { i as FractionSliderCommand };

package/dist/foundation/commands/GeneralBannerCommand.d.ts

@@ -0,0 +1,15 @@
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { BannerStatus, BaseBannerCommand } from './BaseBannerCommand';
+export type GeneralBannerContent = {
+    text: string;
+    status?: 'critical' | 'success' | 'warning' | 'neutral';
+};
+export declare class GeneralBannerCommand extends BaseBannerCommand {
+    protected readonly _bannerStatus: BannerStatus;
+    protected readonly _bannerText: string;
+    constructor(bannerContent: GeneralBannerContent);
+    private mapStringToBannerStatus;
+    get content(): TranslationInput;
+    get status(): BannerStatus;
+    get isVisible(): boolean;
+}

package/dist/foundation/commands/GeneralBannerCommand.js

@@ -0,0 +1,29 @@
+import { BannerStatus as e, BaseBannerCommand as t } from "./BaseBannerCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/GeneralBannerCommand.ts
+var n = class extends t {
+	_bannerStatus;
+	_bannerText;
+	constructor(e) {
+		super(), this._bannerStatus = this.mapStringToBannerStatus(e.status), this._bannerText = e.text;
+	}
+	mapStringToBannerStatus(t) {
+		switch (t) {
+			case "critical": return e.Critical;
+			case "success": return e.Success;
+			case "warning": return e.Warning;
+			case "neutral": return e.Neutral;
+			default: return e.Neutral;
+		}
+	}
+	get content() {
+		return { untranslated: this._bannerText };
+	}
+	get status() {
+		return this._bannerStatus;
+	}
+	get isVisible() {
+		return !0;
+	}
+};
+//#endregion
+export { n as GeneralBannerCommand };

package/dist/foundation/commands/GroupCommand.d.ts

@@ -0,0 +1,30 @@
+import { Signal } from '@cognite/signal-utils';
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { BaseCommand } from './BaseCommand';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export type GroupCommandConfiguration = {
+    title?: TranslationInput;
+    isAccordion?: boolean;
+};
+/**
+ * Represents a group of commands.
+ * This is used to group commands together and display them as a single unit.
+ * Can be used as either a collapsible accordion (with title) or a simple row (without title).
+ */
+export declare class GroupCommand extends RenderTargetCommand {
+    private readonly _title?;
+    private readonly _isAccordion;
+    private readonly _commands;
+    readonly isOpen: Signal<boolean>;
+    constructor({ title, isAccordion }: GroupCommandConfiguration);
+    add<T extends BaseCommand>(command: T): T | void;
+    get isVisible(): boolean;
+    equals(other: BaseCommand): boolean;
+    protected invokeCore(): boolean;
+    protected getChildren(): Generator<BaseCommand>;
+    get title(): TranslationInput | undefined;
+    get isAccordion(): boolean;
+    get tooltip(): TranslationInput | undefined;
+    get commands(): BaseCommand[];
+    get hasCommands(): boolean;
+}