@cognite/reveal-components 1.0.0

package/dist/ui/components/RuleBasedOutputs/core/traverseExpressionToGetTimeseries.js

@@ -0,0 +1,23 @@
+import { isDefined as e } from "../../../../utilities/isDefined.js";
+import { getTimeseriesExternalIdFromNumericExpression as t } from "./getTimeseriesExternalIdFromNumericExpression.js";
+import { uniq as n } from "lodash-es";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/core/traverseExpressionToGetTimeseries.ts
+var r = (i) => {
+	let a = i?.map((n) => {
+		let i = [];
+		switch (n.type) {
+			case "or":
+			case "and":
+				i = r(n.expressions);
+				break;
+			case "not":
+				i = r([n.expression]);
+				break;
+			case "numericExpression": i = t(n);
+		}
+		return i?.filter(e) ?? [];
+	}).flat();
+	return n(a);
+};
+//#endregion
+export { r as traverseExpressionToGetTimeseries };

package/dist/ui/components/RuleBasedOutputs/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useFetchRuleInstances } from './useFetchRuleInstances';
+export { useCreateRuleInstance } from './useCreateRuleInstance';
+export { useEditRuleInstance } from './useEditRuleInstance';
+export { useDeleteRuleInstance } from './useDeleteRuleInstance';
+export { useSearchRuleInstance } from './useSearchRuleInstance';

package/dist/ui/components/RuleBasedOutputs/hooks/index.js

@@ -0,0 +1,6 @@
+import { useFetchRuleInstances as e } from "./useFetchRuleInstances.js";
+import { useCreateRuleInstance as t } from "./useCreateRuleInstance.js";
+import { useEditRuleInstance as n } from "./useEditRuleInstance.js";
+import { useDeleteRuleInstance as r } from "./useDeleteRuleInstance.js";
+import { useSearchRuleInstance as i } from "./useSearchRuleInstance.js";
+export { t as useCreateRuleInstance, r as useDeleteRuleInstance, n as useEditRuleInstance, e as useFetchRuleInstances, i as useSearchRuleInstance };

package/dist/ui/components/RuleBasedOutputs/hooks/useConvertAssetMetadatasToLowerCase.d.ts

@@ -0,0 +1,2 @@
+import { Asset } from '@cognite/sdk';
+export declare const useConvertAssetMetadatasToLowerCase: (assets: Asset[] | undefined) => Asset[];

package/dist/ui/components/RuleBasedOutputs/hooks/useConvertAssetMetadatasToLowerCase.js

@@ -0,0 +1,7 @@
+import { isDefined as e } from "../../../../utilities/isDefined.js";
+import { convertAssetMetadataKeysToLowerCase as t } from "../../../../utilities/convertAssetMetadataToLowerCase.js";
+import { useMemo as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useConvertAssetMetadatasToLowerCase.tsx
+var r = (r) => n(() => r?.filter(e).map(t) ?? [], [r]);
+//#endregion
+export { r as useConvertAssetMetadatasToLowerCase };

package/dist/ui/components/RuleBasedOutputs/hooks/useCreateRuleInstance.d.ts

@@ -0,0 +1,3 @@
+import { ExternalIdsResultList } from '../../../../data-providers/FdmSDK';
+import { RuleOutputSet } from '../types';
+export declare const useCreateRuleInstance: () => ((ruleOutputSet: RuleOutputSet) => Promise<ExternalIdsResultList<unknown>>);

package/dist/ui/components/RuleBasedOutputs/hooks/useCreateRuleInstance.js

@@ -0,0 +1,31 @@
+import { fdmViewsExist as e } from "../../../../utilities/fdmViewsExist.js";
+import { useFdmSdk as t } from "../../RevealCanvas/SDKProvider.js";
+import { RULE_BASED_OUTPUTS_VIEW as n } from "../constants.js";
+import { useCallback as r } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useCreateRuleInstance.tsx
+var i = () => {
+	let i = t();
+	return r(async (t) => await e(i, [n]) ? await i.createInstance([{
+		instanceType: "node",
+		space: n.space,
+		externalId: t.id,
+		sources: [{
+			properties: {
+				name: t.name,
+				id: t.id,
+				createdAt: t.createdAt,
+				createdBy: t.createdBy,
+				rulesWithOutputs: JSON.parse(JSON.stringify(t.rulesWithOutputs)),
+				shamefulOutputTypes: ["color"]
+			},
+			source: {
+				type: n.type,
+				space: n.space,
+				externalId: n.externalId,
+				version: n.version
+			}
+		}]
+	}]) : { items: [] }, []);
+};
+//#endregion
+export { i as useCreateRuleInstance };

package/dist/ui/components/RuleBasedOutputs/hooks/useDeleteRuleInstance.d.ts

@@ -0,0 +1,3 @@
+import { ExternalIdsResultList, FdmNode } from '../../../../data-providers/FdmSDK';
+import { RuleOutputSet } from '../types';
+export declare const useDeleteRuleInstance: () => ((ruleOutputSet: FdmNode<RuleOutputSet>) => Promise<ExternalIdsResultList<unknown>>);

package/dist/ui/components/RuleBasedOutputs/hooks/useDeleteRuleInstance.js

@@ -0,0 +1,15 @@
+import { fdmViewsExist as e } from "../../../../utilities/fdmViewsExist.js";
+import { useFdmSdk as t } from "../../RevealCanvas/SDKProvider.js";
+import { RULE_BASED_OUTPUTS_VIEW as n } from "../constants.js";
+import { useCallback as r } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useDeleteRuleInstance.tsx
+var i = () => {
+	let i = t();
+	return r(async (t) => await e(i, [n]) ? await i.deleteInstances([{
+		instanceType: "node",
+		space: n.space,
+		externalId: t.externalId
+	}]) : { items: [] }, []);
+};
+//#endregion
+export { i as useDeleteRuleInstance };

package/dist/ui/components/RuleBasedOutputs/hooks/useEditRuleInstance.d.ts

@@ -0,0 +1,3 @@
+import { ExternalIdsResultList } from '../../../../data-providers/FdmSDK';
+import { RuleOutputSet } from '../types';
+export declare const useEditRuleInstance: () => ((ruleOutputSet: RuleOutputSet) => Promise<ExternalIdsResultList<unknown>>);

package/dist/ui/components/RuleBasedOutputs/hooks/useEditRuleInstance.js

@@ -0,0 +1,31 @@
+import { fdmViewsExist as e } from "../../../../utilities/fdmViewsExist.js";
+import { useFdmSdk as t } from "../../RevealCanvas/SDKProvider.js";
+import { RULE_BASED_OUTPUTS_VIEW as n } from "../constants.js";
+import { useCallback as r } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useEditRuleInstance.tsx
+var i = () => {
+	let i = t();
+	return r(async (t) => await e(i, [n]) ? await i.editInstance([{
+		instanceType: "node",
+		space: n.space,
+		externalId: t.id,
+		sources: [{
+			properties: {
+				name: t.name,
+				id: t.id,
+				createdAt: t.createdAt,
+				createdBy: t.createdBy,
+				rulesWithOutputs: JSON.parse(JSON.stringify(t.rulesWithOutputs)),
+				shamefulOutputTypes: ["color"]
+			},
+			source: {
+				type: n.type,
+				space: n.space,
+				externalId: n.externalId,
+				version: n.version
+			}
+		}]
+	}]) : { items: [] }, [i]);
+};
+//#endregion
+export { i as useEditRuleInstance };

package/dist/ui/components/RuleBasedOutputs/hooks/useExtractTimeseriesIdsFromRuleSet.d.ts

@@ -0,0 +1,2 @@
+import { RuleOutputSet } from '../types';
+export declare const useExtractTimeseriesIdsFromRuleSet: (ruleSet: RuleOutputSet) => string[];

package/dist/ui/components/RuleBasedOutputs/hooks/useExtractTimeseriesIdsFromRuleSet.js

@@ -0,0 +1,10 @@
+import { isDefined as e } from "../../../../utilities/isDefined.js";
+import { traverseExpressionToGetTimeseries as t } from "../core/traverseExpressionToGetTimeseries.js";
+import { useMemo as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useExtractTimeseriesIdsFromRuleSet.tsx
+var r = (r) => n(() => {
+	let n = r?.rulesWithOutputs.map((e) => e.rule.expression).filter(e);
+	return t(n) ?? [];
+}, [r]);
+//#endregion
+export { r as useExtractTimeseriesIdsFromRuleSet };

package/dist/ui/components/RuleBasedOutputs/hooks/useExtractUniqueClassicAssetIdsFromMapped.d.ts

@@ -0,0 +1,3 @@
+import { InternalId } from '@cognite/sdk';
+import { ModelWithAssetMappings } from '../../../hooks/cad/modelWithAssetMappings';
+export declare const useExtractUniqueClassicAssetIdsFromMapped: (assetMappings: ModelWithAssetMappings[] | undefined) => InternalId[];

package/dist/ui/components/RuleBasedOutputs/hooks/useExtractUniqueClassicAssetIdsFromMapped.js

@@ -0,0 +1,11 @@
+import { isDefined as e } from "../../../../utilities/isDefined.js";
+import { isClassicCadAssetMapping as t } from "../../../../data-providers/cache/cad/assetMappingTypes.js";
+import { useMemo as n } from "react";
+import { uniqBy as r } from "lodash-es";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useExtractUniqueClassicAssetIdsFromMapped.tsx
+var i = (i) => n(() => {
+	let n = (i?.map((e) => e.assetMappings).flat() ?? []).filter(t).flatMap((e) => ({ id: e.assetId })).filter((t) => e(t.id));
+	return r(n, (e) => e.id);
+}, [i]);
+//#endregion
+export { i as useExtractUniqueClassicAssetIdsFromMapped };

package/dist/ui/components/RuleBasedOutputs/hooks/useFetchRuleInstances.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { RuleAndEnabled } from '../types';
+export declare const useFetchRuleInstances: () => UseQueryResult<RuleAndEnabled[], undefined>;

package/dist/ui/components/RuleBasedOutputs/hooks/useFetchRuleInstances.js

@@ -0,0 +1,34 @@
+import { fdmViewsExist as e } from "../../../../utilities/fdmViewsExist.js";
+import { useFdmSdk as t } from "../../RevealCanvas/SDKProvider.js";
+import { RULE_BASED_OUTPUTS_VIEW as n } from "../constants.js";
+import { useQuery as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useFetchRuleInstances.tsx
+var i = () => {
+	let i = t();
+	return r({
+		queryKey: [
+			"react-components",
+			"color-overlay-rules",
+			"all"
+		],
+		queryFn: async () => {
+			if (!await e(i, [n])) return [];
+			let t = `${n.externalId}/${n.version}`, r = { in: {
+				property: [
+					n.space,
+					t,
+					"shamefulOutputTypes"
+				],
+				values: ["color"]
+			} }, a = await i.filterAllInstances(r, "node", n), o = [];
+			return a.instances.forEach((e) => {
+				o.push({
+					isEnabled: !1,
+					rule: e
+				});
+			}), o;
+		}
+	});
+};
+//#endregion
+export { i as useFetchRuleInstances };

package/dist/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.context.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'react';
+import { useClassicCadAssetMappingCache } from '../../../../data-providers/cache/CacheProvider';
+import { useFdmSdk } from '../../RevealCanvas/SDKProvider';
+export type UseGetDMConnectionWithNodeFromHybridMappingsQuery = {
+    useClassicCadAssetMappingCache: typeof useClassicCadAssetMappingCache;
+    useFdmSdk: typeof useFdmSdk;
+};
+export declare const defaultUseGetDMConnectionWithNodeFromHybridMappingsQuery: UseGetDMConnectionWithNodeFromHybridMappingsQuery;
+export declare const UseGetDMConnectionWithNodeFromHybridMappingsQueryContext: Context<UseGetDMConnectionWithNodeFromHybridMappingsQuery>;

package/dist/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.context.js

@@ -0,0 +1,10 @@
+import { useFdmSdk as e } from "../../RevealCanvas/SDKProvider.js";
+import { useClassicCadAssetMappingCache as t } from "../../../../data-providers/cache/CacheProvider.js";
+import { createContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.context.ts
+var r = n({
+	useClassicCadAssetMappingCache: t,
+	useFdmSdk: e
+});
+//#endregion
+export { r as UseGetDMConnectionWithNodeFromHybridMappingsQueryContext };

package/dist/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.d.ts

@@ -0,0 +1,5 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { DmCadAssetMapping } from '../../../../data-providers/cache/cad/assetMappingTypes';
+import { FdmConnectionWithNode } from '../../../../data-providers/cache/types';
+import { CadModelOptions } from '../../../../utilities/modelIds';
+export declare function useGetDMConnectionWithNodeFromHybridMappingsQuery(nodeWithDmIdsFromHybridMappings: DmCadAssetMapping[], models: CadModelOptions[]): UseQueryResult<FdmConnectionWithNode[]>;

package/dist/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.js

@@ -0,0 +1,55 @@
+import { createFdmKey as e } from "../../../../data-providers/cache/idAndKeyTranslation.js";
+import { restrictToDmsId as t } from "../../../../utilities/restrictToDmsId.js";
+import { executeParallel as n } from "../../../../utilities/executeParallel.js";
+import { isDefined as r } from "../../../../utilities/isDefined.js";
+import { inspectNodes as i } from "../../../../data-providers/cache/requests.js";
+import { EMPTY_ARRAY as a } from "../../../../utilities/constants.js";
+import { queryKeys as o } from "../../../../utilities/queryKeys.js";
+import "../../../../data-providers/cache/index.js";
+import { UseGetDMConnectionWithNodeFromHybridMappingsQueryContext as s } from "./useGetDMConnectionWithNodeFromHybridMappingsQuery.context.js";
+import { useContext as c, useMemo as l } from "react";
+import { uniqBy as u } from "lodash-es";
+import { useQuery as d } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.ts
+function f(e, t) {
+	let { useClassicCadAssetMappingCache: f, useFdmSdk: h } = c(s), g = f(), _ = h(), v = l(() => e.map((e) => e.instanceId).filter(r), [e]);
+	return d({
+		queryKey: o.fdmConnectionWithNode(v, t),
+		queryFn: async () => {
+			if (v.length === 0 || t.length === 0) return a;
+			let e = await i(_, v);
+			if (e.items.length === 0) return a;
+			let o = await n(t.map(({ modelId: t, revisionId: n }) => async () => {
+				let r = await g.getNodesForInstanceIds(t, n, v);
+				return r.size === 0 ? a : m(e, r, t, n);
+			}), 2);
+			return u(o.filter(r).flat(), p);
+		},
+		enabled: v.length > 0 && t.length > 0,
+		staleTime: Infinity
+	});
+}
+function p(e) {
+	return `${e.connection.modelId}/${e.connection.revisionId}/${e.connection.instance.space}/${e.connection.instance.externalId}/${e.cadNode.id}`;
+}
+function m(n, r, i, a) {
+	return n.items.flatMap((n) => {
+		let o = e(n);
+		if (!r.has(o)) return [];
+		let s = r.get(o);
+		if (s === void 0) return [];
+		let c = n.inspectionResults.involvedViews ?? [];
+		return s.map((e) => ({
+			connection: {
+				instance: t(n),
+				modelId: i,
+				revisionId: a,
+				treeIndex: e.treeIndex
+			},
+			cadNode: e,
+			views: c
+		}));
+	});
+}
+//#endregion
+export { f as useGetDMConnectionWithNodeFromHybridMappingsQuery };

package/dist/ui/components/RuleBasedOutputs/hooks/useSearchRuleInstance.d.ts

@@ -0,0 +1,2 @@
+import { NodeItem, RuleOutputSet } from '../types';
+export declare const useSearchRuleInstance: () => ((externalId: string) => Promise<Array<NodeItem<RuleOutputSet>>>);

package/dist/ui/components/RuleBasedOutputs/hooks/useSearchRuleInstance.js

@@ -0,0 +1,25 @@
+import { fdmViewsExist as e } from "../../../../utilities/fdmViewsExist.js";
+import { useFdmSdk as t } from "../../RevealCanvas/SDKProvider.js";
+import { RULE_BASED_OUTPUTS_VIEW as n } from "../constants.js";
+import { useCallback as r } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/hooks/useSearchRuleInstance.tsx
+var i = () => {
+	let i = t();
+	return r(async (t) => {
+		if (!await e(i, [n])) return [];
+		let r = `${n.externalId}/${n.version}`, a = { in: {
+			property: [
+				n.space,
+				r,
+				"id"
+			],
+			values: [t]
+		} };
+		return (await i.searchInstances(n, "node", {
+			filter: a,
+			limit: 1
+		})).instances;
+	}, [i]);
+};
+//#endregion
+export { i as useSearchRuleInstance };

package/dist/ui/components/RuleBasedOutputs/index.d.ts

@@ -0,0 +1,4 @@
+export { useCreateRuleInstance, useDeleteRuleInstance, useEditRuleInstance, useFetchRuleInstances, useSearchRuleInstance, } from './hooks';
+export { RuleBasedOutputsPanel } from './RuleBasedOutputsPanel';
+export { getRuleTriggerTypes } from './core/getRuleTriggerTypes';
+export type { RuleAndEnabled, TriggerType, RuleOutputSet, TimeseriesRuleTrigger, MetadataRuleTrigger, FdmRuleTrigger, FdmKeyRuleTriggerTyping, FdmRuleTriggerTyping, FdmInstanceNodeDataKey, StringCondition, NumericCondition, DatetimeCondition, BooleanCondition, StringExpression, NumericExpression, DatetimeExpression, BooleanExpression, ExpressionOperator, Expression, ConcreteExpression, ColorRuleOutput, RuleWithOutputs, Rule, RuleOutput, ExpressionOperatorsTypes, StringConditionTypes, NumericConditionTypes, NumericUniqueConditionTypes, NumericWithinConditionType, NumericOutsideConditionType, DatetimeConditionTypes, DatetimeUniqueConditionTypes, DatetimeBetweenConditionType, BooleanConditionTypes, CriteriaTypes, } from './types';

package/dist/ui/components/RuleBasedOutputs/index.js

@@ -0,0 +1,9 @@
+import { useFetchRuleInstances as e } from "./hooks/useFetchRuleInstances.js";
+import { useCreateRuleInstance as t } from "./hooks/useCreateRuleInstance.js";
+import { useEditRuleInstance as n } from "./hooks/useEditRuleInstance.js";
+import { useDeleteRuleInstance as r } from "./hooks/useDeleteRuleInstance.js";
+import { useSearchRuleInstance as i } from "./hooks/useSearchRuleInstance.js";
+import "./hooks/index.js";
+import { RuleBasedOutputsPanel as a } from "./RuleBasedOutputsPanel.js";
+import { getRuleTriggerTypes as o } from "./core/getRuleTriggerTypes.js";
+export { a as RuleBasedOutputsPanel, o as getRuleTriggerTypes, t as useCreateRuleInstance, r as useDeleteRuleInstance, n as useEditRuleInstance, e as useFetchRuleInstances, i as useSearchRuleInstance };

package/dist/ui/components/RuleBasedOutputs/typeGuards.d.ts

@@ -0,0 +1,3 @@
+import { FdmRuleTrigger, MetadataRuleTrigger, TimeseriesRuleTrigger } from './types';
+export declare const isMetadataTrigger: (trigger: MetadataRuleTrigger | TimeseriesRuleTrigger | FdmRuleTrigger) => trigger is MetadataRuleTrigger;
+export declare const isFdmTrigger: (trigger: MetadataRuleTrigger | TimeseriesRuleTrigger | FdmRuleTrigger) => trigger is FdmRuleTrigger;

package/dist/ui/components/RuleBasedOutputs/typeGuards.js

@@ -0,0 +1,4 @@
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/typeGuards.ts
+var e = (e) => e.type === "metadata", t = (e) => e.type === "fdm";
+//#endregion
+export { t as isFdmTrigger, e as isMetadataTrigger };

package/dist/ui/components/RuleBasedOutputs/types.d.ts

@@ -0,0 +1,280 @@
+import { TreeIndexNodeCollection, NumericRange } from '@cognite/reveal';
+import { Datapoints, Asset, Timeseries } from '@cognite/sdk';
+import { FdmCadConnection } from '../../../data-providers/cache/types';
+import { FdmNode, EdgeItem, DmsUniqueIdentifier } from '../../../data-providers/FdmSDK';
+import { SlimCadNode } from '../../../data-providers/utils/cadNodeConnectionFields';
+import { FdmPropertyType, InstanceStylingGroup } from '../../../utilities/modelIds/types';
+export type TriggerType = 'timeseries' | 'metadata' | 'fdm';
+export type TimeseriesRuleTrigger = {
+    type: 'timeseries';
+    externalId: string;
+};
+export type MetadataRuleTrigger = {
+    type: 'metadata';
+    key: string;
+};
+export type FdmRuleTrigger = {
+    type: 'fdm';
+    key: FdmInstanceNodeDataKey;
+};
+export type FdmInstanceNodeDataKey = {
+    space: string;
+    externalId: string;
+    view: Source;
+    typing: FdmKeyRuleTriggerTyping;
+    property: string;
+};
+export type StringTrigger = MetadataRuleTrigger;
+export type BooleanCondition = {
+    type: 'equals' | 'notEquals';
+    parameter: boolean;
+};
+export type StringCondition = {
+    type: 'equals' | 'notEquals' | 'contains' | 'startsWith' | 'endsWith';
+    parameter: string;
+};
+export type DatetimeCondition = {
+    type: 'before' | 'notBefore' | 'onOrBefore' | 'after' | 'notAfter' | 'onOrAfter' | 'on' | 'notOn';
+    parameter: string;
+} | {
+    type: 'between';
+    lowerBound: string;
+    upperBound: string;
+} | {
+    type: 'notBetween';
+    lowerBound: string;
+    upperBound: string;
+};
+export type NumericCondition = {
+    type: 'equals' | 'notEquals' | 'lessThan' | 'greaterThan' | 'lessThanOrEquals' | 'greaterThanOrEquals';
+    parameters: number[];
+} | {
+    type: 'within';
+    lowerBoundInclusive: number;
+    upperBoundInclusive: number;
+} | {
+    type: 'outside';
+    lowerBoundExclusive: number;
+    upperBoundExclusive: number;
+};
+export type StringExpression = {
+    type: 'stringExpression';
+    trigger: StringTrigger | FdmRuleTrigger;
+    condition: StringCondition;
+};
+export type NumericExpression = {
+    type: 'numericExpression';
+    trigger: MetadataRuleTrigger | TimeseriesRuleTrigger | FdmRuleTrigger;
+    condition: NumericCondition;
+};
+export type DatetimeExpression = {
+    type: 'datetimeExpression';
+    trigger: FdmRuleTrigger;
+    condition: DatetimeCondition;
+};
+export type BooleanExpression = {
+    type: 'booleanExpression';
+    trigger: FdmRuleTrigger;
+    condition: BooleanCondition;
+};
+export type ExpressionOperator = {
+    type: 'or';
+    expressions: Expression[];
+} | {
+    type: 'and';
+    expressions: Expression[];
+} | {
+    type: 'not';
+    expression: Expression;
+};
+export type ConcreteExpression = StringExpression | NumericExpression | DatetimeExpression | BooleanExpression;
+export type Expression = ConcreteExpression | ExpressionOperator;
+export type Rule = {
+    type: 'rule';
+    id: string;
+    name: string;
+    expression: Expression | undefined;
+};
+export type BaseRuleOutput = {
+    externalId: string;
+    label?: string;
+};
+export type ColorRuleOutput = BaseRuleOutput & {
+    type: 'color';
+    fill: string;
+    outline: string;
+};
+export type CanvasRuleOutput = BaseRuleOutput & {
+    type: 'canvasAnnotation';
+    fill: string;
+    outline: string;
+    canvasAnnotationId: string;
+};
+export type EmailRuleOutput = BaseRuleOutput & {
+    type: 'email';
+    email: string;
+};
+export type NotificationRuleOutput = BaseRuleOutput & {
+    type: 'notification';
+    notification: string;
+};
+export type RuleOutput = CanvasRuleOutput | ColorRuleOutput | EmailRuleOutput | NotificationRuleOutput;
+export type RuleWithOutputs = {
+    rule: Rule;
+    outputs: RuleOutput[];
+};
+export type RuleOutputSet = {
+    id: string;
+    name: string;
+    createdAt: number;
+    createdBy: string;
+    rulesWithOutputs: RuleWithOutputs[];
+};
+export type FdmRuleOutputSet = {
+    id: string;
+    name: string;
+    createdAt: number;
+    createdBy: string;
+    rulesWithOutputs: RuleWithOutputs[];
+    shamefulOutputTypes: Array<'color' | 'canvasAnnotation'>;
+};
+export type ExpressionOperatorsTypes = 'and' | 'or' | 'not';
+export type BooleanConditionTypes = 'equals' | 'notEquals';
+export type StringConditionTypes = 'equals' | 'notEquals' | 'contains' | 'startsWith' | 'endsWith';
+export type NumericConditionTypes = 'equals' | 'notEquals' | 'lessThan' | 'greaterThan' | 'lessThanOrEquals' | 'greaterThanOrEquals' | 'within' | 'outside';
+export type NumericUniqueConditionTypes = 'equals' | 'notEquals' | 'lessThan' | 'greaterThan' | 'lessThanOrEquals' | 'greaterThanOrEquals';
+export type NumericWithinConditionType = {
+    type: 'within';
+    lowerBoundInclusive: number;
+    upperBoundInclusive: number;
+};
+export type NumericOutsideConditionType = {
+    type: 'outside';
+    lowerBoundExclusive: number;
+    upperBoundExclusive: number;
+};
+export type DatetimeConditionTypes = 'between' | 'notBetween' | DatetimeUniqueConditionTypes;
+export type DatetimeUniqueConditionTypes = 'before' | 'notBefore' | 'onOrBefore' | 'after' | 'notAfter' | 'onOrAfter' | 'on' | 'notOn';
+export type DatetimeBetweenConditionType = {
+    type: 'between' | 'notBetween';
+    lowerBound: string;
+    upperBound: string;
+};
+export type CriteriaTypes = BooleanConditionTypes | string | number | NumericWithinConditionType | NumericOutsideConditionType | DatetimeBetweenConditionType;
+export type RuleAndStyleIndex = {
+    styleIndex: TreeIndexNodeCollection;
+    ruleOutputParams: RuleOutput;
+};
+export type StylingGroupAndStyleIndex = {
+    styleIndex: TreeIndexNodeCollection;
+    assetStylingGroup: InstanceStylingGroup;
+};
+export type NodeAndRange = {
+    treeIndex: number;
+    nodeId: number;
+    subtreeRange: NumericRange;
+    assetId: number;
+};
+export type RuleAndEnabled = {
+    isEnabled: boolean;
+    rule: FdmNode<RuleOutputSet>;
+};
+export type RuleRecord = EdgeItem<Record<string, any>> | NodeItem<Record<string, any>>;
+export type InstanceType = 'node' | 'edge';
+export type Source = {
+    type: 'view';
+} & SimpleSource;
+export type SimpleSource = {
+    version: string;
+} & DmsUniqueIdentifier;
+export type ViewQueryFilter = {
+    view: Source;
+};
+export type Space = string;
+export type NodeItem<PropertyType = Record<string, unknown>> = {
+    instanceType: InstanceType;
+    version: number;
+    space: string;
+    externalId: string;
+    createdTime: number;
+    lastUpdatedTime: number;
+    deletedTime?: number;
+    properties: FdmPropertyType<PropertyType>;
+};
+export type EmptyRuleForSelection = {
+    rule: {
+        properties: EmptyRuleForSelectionProps;
+    };
+    isEnabled: boolean;
+};
+export type EmptyRuleForSelectionProps = {
+    id: string | undefined;
+    name: string;
+    isNoSelection: boolean;
+};
+export type TriggerTypeData = TriggerMetadataType | TriggerTimeseriesType | TriggerFdmType;
+export type TriggerMetadataType = {
+    type: 'metadata';
+    asset: Asset;
+};
+export type TriggerTimeseriesType = {
+    type: 'timeseries';
+    timeseries: {
+        timeseriesWithDatapoints: TimeseriesAndDatapoints[];
+        linkedAssets: Asset;
+    };
+};
+export type TriggerFdmType = {
+    type: 'fdm';
+    instanceNode: FdmInstanceNodeWithConnectionAndProperties;
+};
+export type TimeseriesAndDatapoints = Timeseries & Datapoints;
+export type FdmKeyRuleTriggerTyping = Record<string, Record<string, Record<string, {
+    name: string;
+    typing: FdmRuleTriggerTyping;
+}>>>;
+export type FdmRuleTriggerTyping = {
+    nullable?: boolean;
+    autoIncrement?: boolean;
+    defaultValue?: any;
+    description?: string;
+    name?: string;
+    immutable?: boolean;
+    container?: {
+        type?: string;
+        space?: string;
+        externalId?: string;
+    };
+    containerPropertyIdentifier?: string;
+    type: {
+        collation?: string;
+        list?: boolean;
+        type: string;
+    };
+};
+export type FdmInstanceWithProperties = NodeItem<unknown> | EdgeItem<unknown>;
+export type FdmInstanceWithPropertiesAndTyping = {
+    items: FdmInstanceWithProperties[];
+    typing: FdmTyping;
+};
+export type FdmTyping = Record<string, Record<string, Record<string, {
+    nullable?: boolean;
+    autoIncrement?: boolean;
+    defaultValue?: any;
+    description?: string;
+    name?: string;
+    immutable?: boolean;
+    type: {
+        collation?: string;
+        list?: boolean;
+        type: string;
+    };
+}>>>;
+export type FdmInstanceNodeWithConnectionAndProperties = {
+    instanceType: 'node';
+    items: FdmInstanceWithProperties[];
+    typing: FdmTyping;
+    connection: FdmCadConnection;
+    cadNode: SlimCadNode;
+    views?: Source[];
+};

package/dist/ui/components/SceneContainer/LoadedSceneContext.d.ts

@@ -0,0 +1,11 @@
+import { default as React, ReactNode } from 'react';
+import { SceneIdentifiers } from './sceneTypes';
+type LoadedSceneContextType = {
+    loadedScene: SceneIdentifiers | undefined;
+    setScene: (scene: SceneIdentifiers) => void;
+};
+export declare const LoadedSceneProvider: React.FC<{
+    children: ReactNode;
+}>;
+export declare const useLoadedScene: () => LoadedSceneContextType;
+export {};