@eagleoutice/flowr 2.2.16 → 2.4.0

package/abstract-interpretation/data-frame/mappers/replacement-mapper.d.ts

@@ -0,0 +1,12 @@
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
+import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataFrameExpressionInfo } from '../absint-info';
+/**
+ * Maps a concrete data frame replacement function to abstract data frame operations.
+ *
+ * @param node - The R node of the replacement function
+ * @param dfg  - The data flow graph for resolving the arguments
+ * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function
+ */
+export declare function mapDataFrameReplacementFunction(node: RNode<ParentInformation>, expression: RNode<ParentInformation>, dfg: DataflowGraph): DataFrameExpressionInfo | undefined;

package/abstract-interpretation/data-frame/mappers/replacement-mapper.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapDataFrameReplacementFunction = mapDataFrameReplacementFunction;
+const config_1 = require("../../../config");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const resolve_args_1 = require("../resolve-args");
+const semantics_1 = require("../semantics");
+const access_mapper_1 = require("./access-mapper");
+const arguments_1 = require("./arguments");
+/** Mapper for mapping the supported data frame replacement functions to mapper functions */
+const DataFrameReplacementFunctionMapper = {
+    'colnames': mapDataFrameColNamesAssignment,
+    'names': mapDataFrameColNamesAssignment,
+    'rownames': mapDataFrameRowNamesAssignment,
+    'dimnames': mapDataFrameDimNamesAssignment
+};
+/**
+ * Maps a concrete data frame replacement function to abstract data frame operations.
+ *
+ * @param node - The R node of the replacement function
+ * @param dfg  - The data flow graph for resolving the arguments
+ * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function
+ */
+function mapDataFrameReplacementFunction(node, expression, dfg) {
+    const parent = hasParentReplacement(node, dfg) ? dfg.idMap?.get(node.info.parent) : undefined;
+    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias };
+    let operations;
+    if (node.type === type_1.RType.Access) {
+        if (node.access.every(arg => arg === r_function_call_1.EmptyArgument)) {
+            operations = mapDataFrameContentAssignment(node, expression, resolveInfo);
+        }
+        else if ((0, access_mapper_1.isStringBasedAccess)(node)) {
+            operations = mapDataFrameNamedColumnAssignment(node, expression, resolveInfo);
+        }
+        else {
+            operations = mapDataFrameIndexColRowAssignment(node, expression, resolveInfo);
+        }
+    }
+    else if (node.type === type_1.RType.FunctionCall && node.named && node.arguments.length === 1 && node.arguments[0] !== r_function_call_1.EmptyArgument) {
+        if (isDataFrameReplacement(node.functionName.content)) {
+            const functionName = node.functionName.content;
+            const functionMapping = DataFrameReplacementFunctionMapper[functionName];
+            operations = functionMapping(node.arguments[0], expression, resolveInfo, parent);
+        }
+        else {
+            operations = mapDataFrameUnknownAssignment(node.arguments[0], expression, resolveInfo);
+        }
+    }
+    if (operations !== undefined) {
+        return { type: 'expression', operations: operations };
+    }
+}
+function isDataFrameReplacement(functionName) {
+    // a check with `functionName in DataFrameReplacementFunctionMapper` would return true for "toString"
+    return Object.prototype.hasOwnProperty.call(DataFrameReplacementFunctionMapper, functionName);
+}
+function hasParentReplacement(node, dfg) {
+    const parentVertex = node.info.parent ? dfg.getVertex(node.info.parent) : undefined;
+    return (0, vertex_1.isFunctionCallVertex)(parentVertex) && parentVertex.origin.includes('builtin:replacement');
+}
+function mapDataFrameContentAssignment(access, expression, info) {
+    const dataFrame = access.accessed;
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+        return;
+    }
+    if ((0, arguments_1.isRNull)(expression)) {
+        return [{
+                operation: 'subsetCols',
+                operand: dataFrame.info.id,
+                colnames: [],
+                type: semantics_1.ConstraintType.OperandModification
+            }];
+    }
+    else {
+        return [{
+                operation: 'identity',
+                operand: dataFrame.info.id,
+                type: semantics_1.ConstraintType.OperandModification
+            }];
+    }
+}
+function mapDataFrameNamedColumnAssignment(access, expression, info) {
+    const dataFrame = access.accessed;
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+        return;
+    }
+    const colname = (0, resolve_args_1.resolveIdToArgValueSymbolName)(access.access[0], info);
+    if ((0, arguments_1.isRNull)(expression)) {
+        return [{
+                operation: 'removeCols',
+                operand: dataFrame.info.id,
+                colnames: colname ? [colname] : undefined,
+                type: semantics_1.ConstraintType.OperandModification,
+                options: { maybe: true }
+            }];
+    }
+    else {
+        return [{
+                operation: 'assignCols',
+                operand: dataFrame.info.id,
+                columns: colname ? [colname] : undefined
+            }];
+    }
+}
+function mapDataFrameIndexColRowAssignment(access, expression, info) {
+    const dataFrame = access.accessed;
+    const args = access.access;
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info) || args.every(arg => arg === r_function_call_1.EmptyArgument)) {
+        return;
+    }
+    const result = [];
+    const rowArg = args.length < 2 ? undefined : args[0];
+    const colArg = args.length < 2 ? args[0] : args[1];
+    if (rowArg !== undefined && rowArg !== r_function_call_1.EmptyArgument) {
+        const rowValue = (0, resolve_args_1.resolveIdToArgValue)(rowArg, info);
+        let rows = undefined;
+        if (typeof rowValue === 'number') {
+            rows = [rowValue];
+        }
+        else if (Array.isArray(rowValue) && rowValue.every(row => typeof row === 'number')) {
+            rows = rowValue;
+        }
+        result.push({
+            operation: 'assignRows',
+            operand: dataFrame.info.id,
+            rows
+        });
+    }
+    if (colArg !== undefined && colArg !== r_function_call_1.EmptyArgument) {
+        const colValue = (0, resolve_args_1.resolveIdToArgValue)(colArg, info);
+        let columns = undefined;
+        if (typeof colValue === 'string') {
+            columns = [colValue];
+        }
+        else if (typeof colValue === 'number') {
+            columns = [colValue];
+        }
+        else if (Array.isArray(colValue) && (colValue.every(col => typeof col === 'string') || colValue.every(col => typeof col === 'number'))) {
+            columns = colValue;
+        }
+        if ((0, arguments_1.isRNull)(expression)) {
+            result.push({
+                operation: 'removeCols',
+                operand: dataFrame.info.id,
+                colnames: columns?.map(col => typeof col === 'string' ? col : undefined),
+                type: semantics_1.ConstraintType.OperandModification,
+                options: { maybe: true }
+            });
+        }
+        else {
+            result.push({
+                operation: 'assignCols',
+                operand: dataFrame.info.id,
+                columns
+            });
+        }
+    }
+    return result;
+}
+function mapDataFrameColNamesAssignment(operand, expression, info, parent) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+        return;
+    }
+    const argument = info.idMap !== undefined ? (0, make_argument_1.toUnnamedArgument)(expression, info.idMap) : r_function_call_1.EmptyArgument;
+    const assignedNames = (0, resolve_args_1.resolveIdToArgStringVector)(argument, info);
+    return [{
+            operation: 'setColNames',
+            operand: operand.value?.info.id,
+            colnames: assignedNames,
+            ...(parent !== undefined ? { options: { partial: true } } : {})
+        }];
+}
+function mapDataFrameRowNamesAssignment(operand, expression, info) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+        return;
+    }
+    return [{
+            operation: 'identity',
+            operand: operand.value?.info.id,
+            type: semantics_1.ConstraintType.OperandModification
+        }];
+}
+function mapDataFrameDimNamesAssignment(operand, expression, info) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+        return;
+    }
+    return [{
+            operation: 'setColNames',
+            operand: operand.value?.info.id,
+            colnames: undefined
+        }];
+}
+function mapDataFrameUnknownAssignment(operand, expression, info) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+        return;
+    }
+    return [{
+            operation: 'unknown',
+            operand: operand.value?.info.id,
+            type: semantics_1.ConstraintType.OperandModification
+        }];
+}
+//# sourceMappingURL=replacement-mapper.js.map

package/abstract-interpretation/data-frame/resolve-args.d.ts

@@ -0,0 +1,42 @@
+import type { ResolveInfo } from '../../dataflow/eval/resolve/alias-tracking';
+import type { RArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import type { 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';
+/**
+ * Returns the argument name of a function argument
+ */
+export declare function resolveIdToArgName(id: NodeId | RArgument<ParentInformation> | undefined, info: ResolveInfo): string | undefined;
+/**
+ * Resolves the value of a function argument as string, number, boolean, or vector using {@link resolveIdToValue}
+ */
+export declare function resolveIdToArgValue(id: NodeId | RArgument<ParentInformation> | undefined, info: ResolveInfo): string | number | boolean | (string | number | boolean)[] | undefined;
+/**
+ * Resolves the value of a function argument to a string vector using {@link resolveIdToValue} and {@link unwrapRValueToString}
+ */
+export declare function resolveIdToArgStringVector(id: NodeId | RArgument<ParentInformation> | undefined, info: ResolveInfo): string[] | undefined;
+/**
+ * Returns the symbol name or string value of the value of a function argument
+ */
+export declare function resolveIdToArgValueSymbolName(id: NodeId | RArgument<ParentInformation> | undefined, info: ResolveInfo): string | undefined;
+/**
+ * Resolves the vector length of the value of a function argument using {@link resolveIdToValue}
+ */
+export declare function resolveIdToArgVectorLength(id: NodeId | RArgument<ParentInformation> | undefined, info: ResolveInfo): number | undefined;
+/**
+ * Removes a leading and trailing quote like `` ` ``, `"`, `'` from a string argument
+ */
+export declare function unquoteArgument(argument: undefined): undefined;
+export declare function unquoteArgument(argument: string): string;
+export declare function unquoteArgument(argument: string | undefined): string | undefined;
+/**
+ * Unescapes escaped quotes like `\'`, `\"` back into actual single and double quotes
+ */
+export declare function unescapeQuotes(argument: undefined): undefined;
+export declare function unescapeQuotes(argument: string): string;
+export declare function unescapeQuotes(argument: string | undefined): string | undefined;
+/**
+ * Unescapes escape sequences like `\n`, `\t`, `\'`, `\"`, `\\` back into actual newlines, tabs, quotes, and backslashes
+ */
+export declare function unescapeSpecialChars(argument: undefined): undefined;
+export declare function unescapeSpecialChars(argument: string): string;
+export declare function unescapeSpecialChars(argument: string | undefined): string | undefined;

package/abstract-interpretation/data-frame/resolve-args.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIdToArgName = resolveIdToArgName;
+exports.resolveIdToArgValue = resolveIdToArgValue;
+exports.resolveIdToArgStringVector = resolveIdToArgStringVector;
+exports.resolveIdToArgValueSymbolName = resolveIdToArgValueSymbolName;
+exports.resolveIdToArgVectorLength = resolveIdToArgVectorLength;
+exports.unquoteArgument = unquoteArgument;
+exports.unescapeQuotes = unescapeQuotes;
+exports.unescapeSpecialChars = unescapeSpecialChars;
+const alias_tracking_1 = require("../../dataflow/eval/resolve/alias-tracking");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const assert_1 = require("../../util/assert");
+const r_value_1 = require("../../util/r-value");
+const strings_1 = require("../../util/text/strings");
+/**
+ * Returns the argument name of a function argument
+ */
+function resolveIdToArgName(id, info) {
+    const node = resolveIdToArgument(id, info);
+    return unquoteArgument(node?.name?.content);
+}
+/**
+ * Resolves the value of a function argument as string, number, boolean, or vector using {@link resolveIdToValue}
+ */
+function resolveIdToArgValue(id, info) {
+    const node = resolveIdToArgument(id, info);
+    if (node?.value !== undefined) {
+        const resolvedValue = (0, alias_tracking_1.resolveIdToValue)(node.value, info);
+        const unliftedValue = (0, r_value_1.unliftRValue)(resolvedValue);
+        if (Array.isArray(unliftedValue)) {
+            return (0, r_value_1.unwrapRVector)(unliftedValue);
+        }
+        else {
+            return (0, r_value_1.unwrapRValue)(unliftedValue);
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolves the value of a function argument to a string vector using {@link resolveIdToValue} and {@link unwrapRValueToString}
+ */
+function resolveIdToArgStringVector(id, info) {
+    const node = resolveIdToArgument(id, info);
+    if (node?.value !== undefined) {
+        const resolvedValue = (0, alias_tracking_1.resolveIdToValue)(node.value, info);
+        const unliftedValue = (0, r_value_1.unliftRValue)(resolvedValue);
+        if (Array.isArray(unliftedValue)) {
+            const array = unliftedValue.map(r_value_1.unwrapRValueToString);
+            return array.every(assert_1.isNotUndefined) ? array : undefined;
+        }
+        else {
+            const result = (0, r_value_1.unwrapRValueToString)(unliftedValue);
+            return result !== undefined ? [result] : undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the symbol name or string value of the value of a function argument
+ */
+function resolveIdToArgValueSymbolName(id, info) {
+    const node = resolveIdToArgument(id, info);
+    if (node?.value?.type === type_1.RType.Symbol) {
+        return unquoteArgument(node.value.content);
+    }
+    else if (node?.value?.type === type_1.RType.String) {
+        return node.value.content.str;
+    }
+    return undefined;
+}
+/**
+ * Resolves the vector length of the value of a function argument using {@link resolveIdToValue}
+ */
+function resolveIdToArgVectorLength(id, info) {
+    const node = resolveIdToArgument(id, info);
+    if (node?.value !== undefined) {
+        const resolvedValue = (0, alias_tracking_1.resolveIdToValue)(node.value, info);
+        const unliftedValue = (0, r_value_1.unliftRValue)(resolvedValue);
+        if (Array.isArray(unliftedValue)) {
+            return unliftedValue.length;
+        }
+        else if ((0, r_value_1.unwrapRValue)(unliftedValue) !== undefined) {
+            return 1;
+        }
+    }
+    return undefined;
+}
+function resolveIdToArgument(id, { graph, idMap }) {
+    idMap ??= graph?.idMap;
+    const node = id === undefined || typeof id === 'object' ? id : idMap?.get(id);
+    if (node?.type === type_1.RType.Argument) {
+        return node;
+    }
+    return undefined;
+}
+function unquoteArgument(argument) {
+    if (argument === undefined) {
+        return undefined;
+    }
+    else if ((0, strings_1.startAndEndsWith)(argument, '`') || (0, strings_1.startAndEndsWith)(argument, '"') || (0, strings_1.startAndEndsWith)(argument, '\'')) {
+        return argument.slice(1, -1);
+    }
+    return argument;
+}
+function unescapeQuotes(argument) {
+    if (argument === undefined) {
+        return undefined;
+    }
+    return argument.replaceAll('\\\'', '\'').replaceAll('\\"', '"');
+}
+function unescapeSpecialChars(argument) {
+    if (argument === undefined) {
+        return undefined;
+    }
+    return unescapeQuotes(argument).replaceAll('\\n', '\n').replaceAll('\\t', '\t').replaceAll('\\\\', '\\');
+}
+//# sourceMappingURL=resolve-args.js.map

package/abstract-interpretation/data-frame/semantics.d.ts

@@ -0,0 +1,213 @@
+import type { DataFrameDomain } from './domain';
+/**
+ * Represents the different types of resulting constraints that are inferred by abstract data frame operations.
+ */
+export declare enum ConstraintType {
+    /** The inferred constraints must hold for the operand at the point of the operation */
+    OperandPrecondition = 0,
+    /** The inferred constraints are applied to the operand during the operation */
+    OperandModification = 1,
+    /** The inferred constraints must hold for the returned result of the operation */
+    ResultPostcondition = 2
+}
+/**
+ * Mapper for defining the abstract data frame operations and mapping them to semantics applier functions,
+ * including information about the type of the resulting constraints that are inferred by the operation.
+ */
+declare const DataFrameSemanticsMapper: {
+    readonly create: {
+        readonly apply: typeof applyCreateSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly read: {
+        readonly apply: typeof applyReadSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly accessCols: {
+        readonly apply: typeof applyAccessColsSemantics;
+        readonly type: ConstraintType.OperandPrecondition;
+    };
+    readonly accessRows: {
+        readonly apply: typeof applyAccessRowsSemantics;
+        readonly type: ConstraintType.OperandPrecondition;
+    };
+    readonly assignCols: {
+        readonly apply: typeof applyAssignColsSemantics;
+        readonly type: ConstraintType.OperandModification;
+    };
+    readonly assignRows: {
+        readonly apply: typeof applyAssignRowsSemantics;
+        readonly type: ConstraintType.OperandModification;
+    };
+    readonly setColNames: {
+        readonly apply: typeof applySetColNamesSemantics;
+        readonly type: ConstraintType.OperandModification;
+    };
+    readonly addCols: {
+        readonly apply: typeof applyAddColsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly addRows: {
+        readonly apply: typeof applyAddRowsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly removeCols: {
+        readonly apply: typeof applyRemoveColsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly removeRows: {
+        readonly apply: typeof applyRemoveRowsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly concatCols: {
+        readonly apply: typeof applyConcatColsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly concatRows: {
+        readonly apply: typeof applyConcatRowsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly subsetCols: {
+        readonly apply: typeof applySubsetColsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly subsetRows: {
+        readonly apply: typeof applySubsetRowsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly filterRows: {
+        readonly apply: typeof applyFilterRowsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly mutateCols: {
+        readonly apply: typeof applyMutateColsSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly groupBy: {
+        readonly apply: typeof applyGroupBySemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly summarize: {
+        readonly apply: typeof applySummarizeSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly join: {
+        readonly apply: typeof applyJoinSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly unknown: {
+        readonly apply: typeof applyUnknownSemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+    readonly identity: {
+        readonly apply: typeof applyIdentitySemantics;
+        readonly type: ConstraintType.ResultPostcondition;
+    };
+};
+/** All available abstract data frame operations */
+export type DataFrameOperationName = keyof typeof DataFrameSemanticsMapper;
+/** The names of all abstract data frame operations */
+export declare const DataFrameOperationNames: DataFrameOperationName[];
+/** The required arguments for an abstract data frame operation */
+export type DataFrameOperationArgs<N extends DataFrameOperationName> = Parameters<typeof DataFrameSemanticsMapper[N]['apply']>[1];
+/** The optional addition options for an abstract data frame operation */
+export type DataFrameOperationOptions<N extends DataFrameOperationName> = Parameters<typeof DataFrameSemanticsMapper[N]['apply']>[2];
+/**
+ * Applies the abstract semantics of an abstract data frame operation with respect to the data frame shape domain.
+ * This expects that all arguments have already been sanitized according to the original concrete data frame function (e.g. by replacing duplicate/invalid column names).
+ *
+ * @param operation - The name of the abstract operation to apply the semantics of
+ * @param value     - The abstract data frame shape of the operand of the abstract operation
+ * @param args      - The arguments for applying the abstract semantics of the abstract operation
+ * @param options   - The optional additional options of the abstract operation
+ * @returns The resulting new data frame shape constraints.
+ * The semantic type of the resulting constraints depends on the {@link ConstraintType} of the abstract operation.
+ */
+export declare function applyDataFrameSemantics<Name extends DataFrameOperationName>(operation: Name, value: DataFrameDomain, args: DataFrameOperationArgs<Name>, options?: DataFrameOperationOptions<Name>): DataFrameDomain;
+/**
+ * Gets the default resulting constraint type for an abstract data frame operation.
+ */
+export declare function getConstraintType(operation: DataFrameOperationName): ConstraintType;
+declare function applyCreateSemantics(value: DataFrameDomain, { colnames, rows }: {
+    colnames: (string | undefined)[] | undefined;
+    rows: number | [number, number] | undefined;
+}): DataFrameDomain;
+declare function applyReadSemantics(value: DataFrameDomain, { colnames, rows }: {
+    source: string | undefined;
+    colnames: (string | undefined)[] | undefined;
+    rows: number | [number, number] | undefined;
+}): DataFrameDomain;
+declare function applyAccessColsSemantics(value: DataFrameDomain, { columns }: {
+    columns: string[] | number[] | undefined;
+}): DataFrameDomain;
+declare function applyAccessRowsSemantics(value: DataFrameDomain, { rows }: {
+    rows: number[] | undefined;
+}): DataFrameDomain;
+declare function applyAssignColsSemantics(value: DataFrameDomain, { columns }: {
+    columns: string[] | number[] | undefined;
+}): DataFrameDomain;
+declare function applyAssignRowsSemantics(value: DataFrameDomain, { rows }: {
+    rows: number[] | undefined;
+}): DataFrameDomain;
+declare function applySetColNamesSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}, options?: {
+    partial?: boolean;
+}): DataFrameDomain;
+declare function applyAddColsSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}): DataFrameDomain;
+declare function applyAddRowsSemantics(value: DataFrameDomain, { rows }: {
+    rows: number | undefined;
+}): DataFrameDomain;
+declare function applyRemoveColsSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}, options?: {
+    maybe?: boolean;
+}): DataFrameDomain;
+declare function applyRemoveRowsSemantics(value: DataFrameDomain, { rows }: {
+    rows: number | undefined;
+}, options?: {
+    maybe?: boolean;
+}): DataFrameDomain;
+declare function applyConcatColsSemantics(value: DataFrameDomain, { other }: {
+    other: DataFrameDomain;
+}): DataFrameDomain;
+declare function applyConcatRowsSemantics(value: DataFrameDomain, { other }: {
+    other: DataFrameDomain;
+}): DataFrameDomain;
+declare function applySubsetColsSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}, options?: {
+    duplicateCols?: boolean;
+    renamedCols?: boolean;
+}): DataFrameDomain;
+declare function applySubsetRowsSemantics(value: DataFrameDomain, { rows }: {
+    rows: number | undefined;
+}, options?: {
+    duplicateRows?: boolean;
+}): DataFrameDomain;
+declare function applyFilterRowsSemantics(value: DataFrameDomain, { condition }: {
+    condition: boolean | undefined;
+}): DataFrameDomain;
+declare function applyMutateColsSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}): DataFrameDomain;
+declare function applyGroupBySemantics(value: DataFrameDomain, { by }: {
+    by: (string | undefined)[];
+}, options?: {
+    mutatedCols?: boolean;
+}): DataFrameDomain;
+declare function applySummarizeSemantics(value: DataFrameDomain, { colnames }: {
+    colnames: (string | undefined)[] | undefined;
+}): DataFrameDomain;
+declare function applyJoinSemantics(value: DataFrameDomain, { other, by }: {
+    other: DataFrameDomain;
+    by: (string | undefined)[] | undefined;
+}, options?: {
+    join?: 'inner' | 'left' | 'right' | 'full';
+    natural?: boolean;
+}): DataFrameDomain;
+declare function applyIdentitySemantics(value: DataFrameDomain, _args: {}): DataFrameDomain;
+declare function applyUnknownSemantics(_value: DataFrameDomain, _args: {}): DataFrameDomain;
+export {};