@eagleoutice/flowr 2.6.3 → 2.7.0

package/abstract-interpretation/data-frame/semantics.js

@@ -70,7 +70,7 @@ function getConstraintType(operation) {
     return DataFrameSemanticsMapper[operation].type;
 }
 function applyCreateSemantics(value, { colnames, rows }) {
-    const colnamesValue = colnames?.every(assert_1.isNotUndefined) ? colnames : lattice_1.Top;
+    const colnamesValue = setRange(colnames);
     const colsValue = colnames !== undefined ? [colnames.length, colnames.length] : positive_interval_domain_1.PosIntervalTop;
     const rowsValue = Array.isArray(rows) ? rows : typeof rows === 'number' ? [rows, rows] : positive_interval_domain_1.PosIntervalTop;
     return new dataframe_domain_1.DataFrameDomain({
@@ -85,7 +85,7 @@ function applyReadSemantics(value, { colnames, rows }) {
 function applyAccessColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.join(columns),
+            colnames: value.colnames.union(setRange(columns)),
             cols: value.cols,
             rows: value.rows
         });
@@ -93,7 +93,7 @@ function applyAccessColsSemantics(value, { columns }) {
     else if (columns?.every(col => typeof col === 'number')) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames,
-            cols: columns?.reduce((current, col) => current.max([col, col]), value.cols),
+            cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
@@ -113,21 +113,21 @@ function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
         const cols = columns.length;
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.join(columns),
+            colnames: value.colnames.union(setRange(columns)),
             cols: value.cols.add([0, cols]).max([cols, cols]),
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.top(),
+            colnames: value.colnames.widenUp(),
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: value.colnames.top(),
-        cols: value.cols.extendUp(),
+        colnames: value.colnames.widenUp(),
+        cols: value.cols.widenUp(),
         rows: value.rows
     });
 }
@@ -142,28 +142,28 @@ function applyAssignRowsSemantics(value, { rows }) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: value.rows.extendUp()
+        rows: value.rows.widenUp()
     });
 }
 function applySetColNamesSemantics(value, { colnames }, options) {
     if (options?.partial) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+            colnames: value.colnames.widenDown().union(setRange(colnames)),
             cols: value.cols,
             rows: value.rows
         });
     }
     const allColNames = colnames?.every(assert_1.isNotUndefined) && value.cols.value !== lattice_1.Bottom && colnames.length >= value.cols.value[1];
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: allColNames ? value.colnames.create(colnames) : value.colnames.top(),
+        colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.widenDown().union(setRange(colnames)).widenUp(),
         cols: value.cols,
         rows: value.rows
     });
 }
 function applyAddColsSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
     });
 }
@@ -173,26 +173,26 @@ function applyAddRowsSemantics(value, { rows }) {
             ...value,
             colnames: value.colnames.top(),
             cols: rows !== undefined ? value.cols.add([1, 1]) : value.cols.top(),
-            rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+            rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+        rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
     });
 }
 function applyRemoveColsSemantics(value, { colnames }, options) {
     if (options?.maybe) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-            cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.extendDown(),
+            colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
+            cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-        cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.extendDown(),
+        colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
+        cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
     });
 }
@@ -201,18 +201,18 @@ function applyRemoveRowsSemantics(value, { rows }, options) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames,
             cols: value.cols,
-            rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.extendDown()
+            rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.widenDown()
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.extendDown()
+        rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyConcatColsSemantics(value, { other }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: value.colnames.join(other.colnames),
+        colnames: value.colnames.union(other.colnames),
         cols: value.cols.add(other.cols),
         rows: value.rows
     });
@@ -243,13 +243,13 @@ function applySubsetColsSemantics(value, { colnames }, options) {
     else if (options?.renamedCols) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames.top(),
-            cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+            cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.meet(colnames) : value.colnames,
-        cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+        colnames: colnames !== undefined ? value.colnames.intersect(setRange(colnames)) : value.colnames.widenDown(),
+        cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
     });
 }
@@ -264,27 +264,27 @@ function applySubsetRowsSemantics(value, { rows }, options) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.extendDown()
+        rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyFilterRowsSemantics(value, { condition }) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.extendDown()
+        rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.widenDown()
     });
 }
 function applyMutateColsSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
     });
 }
 function applyGroupBySemantics(value, { by }, options) {
     if (options?.mutatedCols) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: by.every(assert_1.isNotUndefined) ? value.colnames.join(by) : value.colnames.top(),
+            colnames: value.colnames.union(setRange(by)),
             cols: value.cols.add([0, by.length]),
             rows: value.rows
         });
@@ -294,8 +294,8 @@ function applyGroupBySemantics(value, { by }, options) {
 }
 function applySummarizeSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.join(setRange([])).union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.widenUp(),
         rows: value.rows.min([1, +Infinity]).max([0, 1])
     });
 }
@@ -318,35 +318,36 @@ function applyJoinSemantics(value, { other, by }, options) {
             return new positive_interval_domain_1.PosIntervalDomain([lower.value[0], interval1.value[1] * interval2.value[1]]);
         }
     };
-    const commonCols = value.colnames.meet(other.colnames);
-    let duplicateCols; // whether columns may be renamed due to occurrence in both data frames
+    let duplicateCols; // columns that may be renamed due to occurring in both data frames
     let productRows; // whether the resulting rows may be a Cartesian product of the rows of the data frames
     if (options?.natural) {
-        duplicateCols = false;
-        productRows = commonCols.isValue() && commonCols.value.size === 0;
+        const commonCols = value.colnames.intersect(other.colnames).upper();
+        duplicateCols = [];
+        productRows = commonCols !== lattice_1.Bottom && commonCols !== lattice_1.Top && commonCols.size === 0;
     }
     else if (by === undefined) {
-        duplicateCols = true;
+        duplicateCols = undefined;
         productRows = true;
     }
     else if (by.length === 0) {
-        duplicateCols = commonCols.isTop() || (commonCols.isValue() && commonCols.value.size > 0);
+        const commonCols = value.colnames.intersect(other.colnames).upper();
+        duplicateCols = commonCols !== lattice_1.Bottom ? commonCols !== lattice_1.Top ? [...commonCols] : undefined : [];
         productRows = true;
     }
     else if (by.every(assert_1.isNotUndefined)) {
-        const remainingCols = commonCols.subtract(by);
-        duplicateCols = remainingCols.isTop() || (remainingCols.isValue() && remainingCols.value.size > 0);
+        const remainingCols = value.colnames.intersect(other.colnames).subtract(setRange(by)).upper();
+        duplicateCols = remainingCols !== lattice_1.Bottom ? remainingCols !== lattice_1.Top ? [...remainingCols] : undefined : [];
         productRows = false;
     }
     else {
-        duplicateCols = true;
+        duplicateCols = undefined;
         productRows = false;
     }
     const joinType = options?.join ?? 'inner';
     let rows;
     switch (joinType) {
         case 'inner':
-            rows = value.rows.min(other.rows).extendDown();
+            rows = value.rows.min(other.rows).widenDown();
             break;
         case 'left':
             rows = value.rows;
@@ -362,7 +363,7 @@ function applyJoinSemantics(value, { other, by }, options) {
     }
     return new dataframe_domain_1.DataFrameDomain({
         ...value,
-        colnames: duplicateCols ? value.colnames.top() : value.colnames.join(other.colnames),
+        colnames: duplicateCols === undefined ? value.colnames.top() : duplicateCols.length > 0 ? value.colnames.union(other.colnames).subtract(setRange(duplicateCols)).widenUp() : value.colnames.union(other.colnames),
         cols: by !== undefined ? value.cols.add(other.cols).subtract([by.length, by.length]) : mergeInterval(value.cols, other.cols),
         rows: productRows ? productInterval(rows, value.rows, other.rows) : rows
     });
@@ -377,4 +378,8 @@ function applyUnknownSemantics(value,
 _args) {
     return value.top();
 }
+function setRange(colnames) {
+    const names = colnames?.filter(assert_1.isNotUndefined) ?? [];
+    return { min: names, range: names.length === colnames?.length ? [] : lattice_1.Top };
+}
 //# sourceMappingURL=semantics.js.map

package/abstract-interpretation/data-frame/shape-inference.d.ts

@@ -1,11 +1,11 @@
 import { type ControlFlowInformation } from '../../control-flow/control-flow-graph';
 import type { DataflowGraph } from '../../dataflow/graph/graph';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type AbstractInterpretationInfo } from './absint-info';
 import { type DataFrameDomain, DataFrameStateDomain } from './dataframe-domain';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Infers the shape of data frames by performing abstract interpretation using the control flow graph of a program.
  * This directly attaches the inferred data frames shapes to the AST (see {@link AbstractInterpretationInfo}).

package/abstract-interpretation/domains/abstract-domain.d.ts

@@ -5,6 +5,7 @@ import { type Lattice, Top } from './lattice';
 export declare const DEFAULT_INFERENCE_LIMIT = 50;
 /**
  * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * All operations of value abstract domains should not modify the domain in-place but return new values using {@link create}.
  * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
  * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
  * @template Top      - Type of the Top element of the abstract domain representing all possible elements

package/abstract-interpretation/domains/abstract-domain.js

@@ -11,6 +11,7 @@ const lattice_1 = require("./lattice");
 exports.DEFAULT_INFERENCE_LIMIT = 50;
 /**
  * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * All operations of value abstract domains should not modify the domain in-place but return new values using {@link create}.
  * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
  * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
  * @template Top      - Type of the Top element of the abstract domain representing all possible elements
@@ -73,10 +74,10 @@ function domainElementToString(value) {
         return value.toString();
     }
     else if (value === lattice_1.Top) {
-        return '⊤';
+        return lattice_1.TopSymbol;
     }
     else if (value === lattice_1.Bottom) {
-        return '⊥';
+        return lattice_1.BottomSymbol;
     }
     return JSON.stringify(value);
 }

package/abstract-interpretation/domains/bounded-set-domain.js

@@ -125,7 +125,7 @@ class BoundedSetDomain extends abstract_domain_1.AbstractDomain {
     }
     toString() {
         if (this.value === lattice_1.Top) {
-            return '⊤';
+            return lattice_1.TopSymbol;
         }
         const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
         return `{${string}}`;

package/abstract-interpretation/domains/interval-domain.d.ts

@@ -55,11 +55,11 @@ export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> e
     /**
      * Extends the lower bound of the current abstract value down to -∞.
      */
-    extendDown(): this;
+    widenDown(): this;
     /**
      * Extends the upper bound of the current abstract value up to +∞.
      */
-    extendUp(): this;
+    widenUp(): this;
     toJson(): unknown;
     toString(): string;
     isTop(): this is IntervalDomain<IntervalTop>;

package/abstract-interpretation/domains/interval-domain.js

@@ -75,9 +75,6 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
         if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
             return this.bottom();
         }
-        else if (Math.max(this.value[0], otherValue[0]) > Math.min(this.value[1], otherValue[1])) {
-            return this.bottom();
-        }
         else {
             return this.create([Math.max(this.value[0], otherValue[0]), Math.min(this.value[1], otherValue[1])]);
         }
@@ -222,7 +219,7 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
     /**
      * Extends the lower bound of the current abstract value down to -∞.
      */
-    extendDown() {
+    widenDown() {
         if (this.value === lattice_1.Bottom) {
             return this.bottom();
         }
@@ -233,7 +230,7 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
     /**
      * Extends the upper bound of the current abstract value up to +∞.
      */
-    extendUp() {
+    widenUp() {
         if (this.value === lattice_1.Bottom) {
             return this.bottom();
         }
@@ -249,7 +246,7 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
     }
     toString() {
         if (this.value === lattice_1.Bottom) {
-            return '⊥';
+            return lattice_1.BottomSymbol;
         }
         return `[${isFinite(this.value[0]) ? this.value[0] : '-∞'}, ${isFinite(this.value[1]) ? this.value[1] : '+∞'}]`;
     }

package/abstract-interpretation/domains/lattice.d.ts

@@ -2,10 +2,12 @@
  * The Top symbol to represent the Top element of complete lattices (e.g. of abstract domains).
  */
 export declare const Top: unique symbol;
+export declare const TopSymbol = "\u22A4";
 /**
  * The Bottom symbol to represent the Bottom element of complete lattices (e.g. of abstract domains).
  */
 export declare const Bottom: unique symbol;
+export declare const BottomSymbol = "\u22A5";
 /**
  * A complete lattice with a partially ordered set, join operator (LUB), meet operator (GLB), top element, and bottom element (e.g. for abstract domains).
  * @template Value - Type of a lattice element representing a value (may exclude `Top` and `Bot`)

package/abstract-interpretation/domains/lattice.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bottom = exports.Top = void 0;
+exports.BottomSymbol = exports.Bottom = exports.TopSymbol = exports.Top = void 0;
 /**
  * The Top symbol to represent the Top element of complete lattices (e.g. of abstract domains).
  */
 exports.Top = Symbol('top');
+exports.TopSymbol = '⊤';
 /**
  * The Bottom symbol to represent the Bottom element of complete lattices (e.g. of abstract domains).
  */
 exports.Bottom = Symbol('bottom');
+exports.BottomSymbol = '⊥';
 //# sourceMappingURL=lattice.js.map

package/abstract-interpretation/domains/positive-interval-domain.d.ts

@@ -30,7 +30,7 @@ export declare class PosIntervalDomain<Value extends PosIntervalLift = PosInterv
     /**
      * Extends the lower bound of the current abstract value down to 0.
      */
-    extendDown(): this;
+    widenDown(): this;
     isTop(): this is PosIntervalDomain<PosIntervalTop>;
 }
 export {};

package/abstract-interpretation/domains/positive-interval-domain.js

@@ -84,7 +84,7 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
     /**
      * Extends the lower bound of the current abstract value down to 0.
      */
-    extendDown() {
+    widenDown() {
         if (this.value === lattice_1.Bottom) {
             return this.bottom();
         }

package/abstract-interpretation/domains/satisfiable-domain.d.ts

@@ -10,7 +10,7 @@ export interface SatisfiableDomain<T> {
     satisfies(value: T): Ternary;
 }
 /**
- * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ * Represents the different types of numerical comparators for satisfiability checks for an abstract domain.
  */
 export declare enum NumericalComparator {
     Equal = 0,
@@ -20,7 +20,7 @@ export declare enum NumericalComparator {
     GreaterOrEqual = 4
 }
 /**
- * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ * Represents the different types of set comparators for satisfiability checks for an abstract domain.
  */
 export declare enum SetComparator {
     Equal = 0,

package/abstract-interpretation/domains/satisfiable-domain.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetComparator = exports.NumericalComparator = void 0;
 /**
- * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ * Represents the different types of numerical comparators for satisfiability checks for an abstract domain.
  */
 var NumericalComparator;
 (function (NumericalComparator) {
@@ -13,7 +13,7 @@ var NumericalComparator;
     NumericalComparator[NumericalComparator["GreaterOrEqual"] = 4] = "GreaterOrEqual";
 })(NumericalComparator || (exports.NumericalComparator = NumericalComparator = {}));
 /**
- * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ * Represents the different types of set comparators for satisfiability checks for an abstract domain.
  */
 var SetComparator;
 (function (SetComparator) {

package/abstract-interpretation/domains/set-range-domain.d.ts

@@ -0,0 +1,98 @@
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+import type { SatisfiableDomain } from './satisfiable-domain';
+import { SetComparator } from './satisfiable-domain';
+/** The Top element of the set range domain with an empty set as minimum set and {@link Top} as range set */
+export declare const SetRangeTop: {
+    readonly min: Set<never>;
+    readonly range: typeof Top;
+};
+/** The type of the actual values of the set range domain as tuple with a minimum set and range set of additional possible values (i.e. `[{"id","name"}, ∅]`, or `[{"id"}, {"score"}]`) */
+type SetRangeValue<T> = {
+    readonly min: ReadonlySet<T>;
+    readonly range: ReadonlySet<T> | typeof Top;
+};
+/** The type of the Top element of the set range domain as tuple with the empty set as minimum set and {@link Top} as range set (i.e. `[∅, Top]`) */
+type SetRangeTop = typeof SetRangeTop;
+/** The type of the Bottom element of the set range domain as {@link Bottom} */
+type SetRangeBottom = typeof Bottom;
+/** The type of the abstract values of the set range domain that are Top, Bottom, or actual values */
+type SetRangeLift<T> = SetRangeValue<T> | SetRangeTop | SetRangeBottom;
+/** The type of the actual values of the set range domain as array tuple with a minimum array and range array for better readability (e.g. `[["id","name"], []]`, or `[["id"], ["score"]]`) */
+export type ArrayRangeValue<T> = {
+    readonly min: T[];
+    readonly range: T[] | typeof Top;
+};
+/** The type for the maximum number of elements in the minimum set and maximum set of the set range domain before over-approximation */
+export type SetRangeLimit = {
+    readonly min: number;
+    readonly range: number;
+};
+/**
+ * The set range abstract domain as range of possible value sets with a minimum set of values and a range of possible additional values
+ * (similar to an interval like structure with a lower bound and a difference to the upper bound).
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the range `[∅, Top]` where the minimum set is the empty set and the range is {@link Top}.
+ * @template T     - Type of the values in the sets in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class SetRangeDomain<T, Value extends SetRangeLift<T> = SetRangeLift<T>> extends AbstractDomain<ReadonlySet<T>, SetRangeValue<T>, SetRangeTop, SetRangeBottom, Value> implements SatisfiableDomain<ReadonlySet<T>> {
+    readonly limit: SetRangeLimit;
+    private readonly setType;
+    /**
+     * @param limit -  A limit for the maximum number of elements to store in the minimum set and maximum set before over-approximation
+     * @param newSet - An optional set constructor for the domain elements if the type `T` is not storable in a HashSet
+     */
+    constructor(value: Value | ArrayRangeValue<T>, limit?: SetRangeLimit | number, setType?: typeof Set<T>);
+    create(value: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * The minimum set (lower bound) of the set range representing all values that must exist (subset of {@link upper}).
+     */
+    lower(): SetRangeValue<T>['min'] | typeof Bottom;
+    /**
+     * The maximum set (upper bound) of the set range representing all values that can possibly exist (union of {@link lower} and range).
+     */
+    upper(): SetRangeValue<T>['range'] | typeof Bottom;
+    static top<T>(limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T, SetRangeTop>;
+    static bottom<T>(limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T, SetRangeBottom>;
+    static abstract<T>(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top, limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T>;
+    top(): this & SetRangeDomain<T, SetRangeTop>;
+    bottom(): this & SetRangeDomain<T, SetRangeBottom>;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    join(other: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    meet(other: this): this;
+    meet(other: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Creates the union of this abstract value and another abstract value by creating the union of the minimum and maximum set, respectively.
+     */
+    union(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Creates the intersection of this abstract value and another abstract value by creating the intersection of the minimum and maximum set, respectively.
+     */
+    intersect(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ReadonlySet<T>> | typeof Top;
+    abstract(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top): this;
+    satisfies(set: ReadonlySet<T> | T[], comparator?: SetComparator): Ternary;
+    /**
+     * Extends the minimum set of the current abstract value down to the empty set.
+     */
+    widenDown(): this;
+    /**
+     * Extends the maximum set of the current abstract value up to {@link Top}.
+     */
+    widenUp(): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is SetRangeDomain<T, SetRangeTop>;
+    isBottom(): this is SetRangeDomain<T, SetRangeBottom>;
+    isValue(): this is SetRangeDomain<T, SetRangeValue<T>>;
+}
+export {};