data-finder-ts 0.1.0 → 0.1.3

package/dist/datafinder/typed-attributes.cjs

@@ -0,0 +1,751 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/datafinder/typed-attributes.ts
+var typed_attributes_exports = {};
+__export(typed_attributes_exports, {
+  BooleanAttribute: () => BooleanAttribute,
+  DateAttribute: () => DateAttribute,
+  DateTimeAttribute: () => DateTimeAttribute,
+  DecimalAttribute: () => DecimalAttribute,
+  DoubleAttribute: () => DoubleAttribute,
+  FloatAttribute: () => FloatAttribute,
+  IntegerAttribute: () => IntegerAttribute,
+  NumericAttribute: () => NumericAttribute,
+  StringAttribute: () => StringAttribute
+});
+module.exports = __toCommonJS(typed_attributes_exports);
+
+// src/model/relational.ts
+var RelationalOperationElement = class {
+};
+var Operation = class extends RelationalOperationElement {
+  andOp(other) {
+    return new LogicalOperation(this, "AND" /* AND */, other);
+  }
+};
+var ConstantOperation = class extends RelationalOperationElement {
+};
+var IntegerConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var FloatConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var StringConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DateConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DateTimeConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DecimalConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var BooleanConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var UnaryOperation = class extends Operation {
+  constructor(element) {
+    super();
+    this.element = element;
+  }
+  element;
+};
+var BinaryOperation = class extends Operation {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  left;
+  right;
+};
+var IsNullOperation = class extends UnaryOperation {
+};
+var IsNotNullOperation = class extends UnaryOperation {
+};
+var ComparisonOperation = class extends BinaryOperation {
+  constructor(left, operator, right) {
+    super(left, right);
+    this.operator = operator;
+  }
+  operator;
+};
+var LogicalOperation = class extends BinaryOperation {
+  constructor(left, operator, right) {
+    super(left, right);
+    this.operator = operator;
+  }
+  operator;
+};
+var WindowSpecification = class {
+  constructor(partitionBy = [], orderBy = []) {
+    this.partitionBy = partitionBy;
+    this.orderBy = orderBy;
+  }
+  partitionBy;
+  orderBy;
+};
+var AggregateOperation = class _AggregateOperation extends UnaryOperation {
+  constructor(element, operator, displayName, window) {
+    super(element);
+    this.operator = operator;
+    this.displayName = displayName;
+    this.window = window;
+  }
+  operator;
+  displayName;
+  window;
+  over(partitionBy, orderBy) {
+    return new _AggregateOperation(
+      this.element,
+      this.operator,
+      this.displayName,
+      new WindowSpecification(partitionBy ?? [], orderBy ?? [])
+    );
+  }
+};
+var WindowFunctionOperation = class _WindowFunctionOperation extends UnaryOperation {
+  constructor(element, func, displayName, secondArg, extraArgs = [], window) {
+    super(element);
+    this.func = func;
+    this.displayName = displayName;
+    this.secondArg = secondArg;
+    this.extraArgs = extraArgs;
+    this.window = window;
+  }
+  func;
+  displayName;
+  secondArg;
+  extraArgs;
+  window;
+  over(partitionBy, orderBy) {
+    return new _WindowFunctionOperation(
+      this.element,
+      this.func,
+      this.displayName,
+      this.secondArg,
+      [...this.extraArgs],
+      new WindowSpecification(partitionBy ?? [], orderBy ?? [])
+    );
+  }
+};
+var ScalarFunctionOperation = class extends UnaryOperation {
+  constructor(element, func, displayName, secondArg, extraArgs = []) {
+    super(element);
+    this.func = func;
+    this.displayName = displayName;
+    this.secondArg = secondArg;
+    this.extraArgs = extraArgs;
+  }
+  func;
+  displayName;
+  secondArg;
+  extraArgs;
+};
+var DateExtractOperation = class extends UnaryOperation {
+  constructor(element, part, displayName) {
+    super(element);
+    this.part = part;
+    this.displayName = displayName;
+  }
+  part;
+  displayName;
+};
+var DateArithmeticOperation = class extends UnaryOperation {
+  constructor(element, n, unit, isAdd = true, displayName) {
+    super(element);
+    this.n = n;
+    this.unit = unit;
+    this.isAdd = isAdd;
+    this.displayName = displayName;
+  }
+  n;
+  unit;
+  isAdd;
+  displayName;
+};
+var DateDiffOperation = class extends UnaryOperation {
+  constructor(element, other, unit, displayName) {
+    super(element);
+    this.other = other;
+    this.unit = unit;
+    this.displayName = displayName;
+  }
+  other;
+  unit;
+  displayName;
+};
+var Column = class extends RelationalOperationElement {
+  constructor(name, type, owner, primaryKey = false) {
+    super();
+    this.name = name;
+    this.type = type;
+    this.owner = owner;
+    this.primaryKey = primaryKey;
+  }
+  name;
+  type;
+  owner;
+  primaryKey;
+  table;
+};
+var ColumnWithJoin = class extends RelationalOperationElement {
+  constructor(column, parent) {
+    super();
+    this.column = column;
+    this.parent = parent;
+  }
+  column;
+  parent;
+};
+var SortOperation = class {
+  constructor(column, direction) {
+    this.column = column;
+    this.direction = direction;
+  }
+  column;
+  direction;
+};
+
+// src/datafinder/attribute.ts
+var Attribute = class {
+  _displayName;
+  _column;
+  _owner;
+  _parent;
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    this._displayName = displayName;
+    this._column = new Column(columnName, columnDbType, owner);
+    this._owner = owner;
+    this._parent = parent;
+  }
+  column() {
+    return this._column;
+  }
+  owner() {
+    return this._owner;
+  }
+  parent() {
+    return this._parent;
+  }
+  displayName() {
+    return this._displayName;
+  }
+  cwj() {
+    return new ColumnWithJoin(this._column, this._parent);
+  }
+  count() {
+    return new AggregateOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "COUNT" /* COUNT */,
+      this._displayName + " Count"
+    );
+  }
+  ascending() {
+    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "ASC" /* ASC */);
+  }
+  descending() {
+    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "DESC" /* DESC */);
+  }
+  isNull() {
+    return new IsNullOperation(new ColumnWithJoin(this._column, this._parent));
+  }
+  isNotNull() {
+    return new IsNotNullOperation(new ColumnWithJoin(this._column, this._parent));
+  }
+  _windowSpec(partitionBy, orderBy) {
+    const pb = partitionBy === void 0 ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+    const ob = orderBy === void 0 ? [] : Array.isArray(orderBy) ? orderBy : [orderBy];
+    return new WindowSpecification(pb, ob);
+  }
+  rank(opts = {}) {
+    const { method = "min", pct = false, partitionBy, orderBy } = opts;
+    let func;
+    let name;
+    if (pct) {
+      if (method === "max") {
+        func = "CUME_DIST" /* CUME_DIST */;
+        name = "Cume Dist";
+      } else {
+        func = "PERCENT_RANK" /* PERCENT_RANK */;
+        name = "Percent Rank";
+      }
+    } else if (method === "first") {
+      func = "ROW_NUMBER" /* ROW_NUMBER */;
+      name = "Row Number";
+    } else if (method === "dense") {
+      func = "DENSE_RANK" /* DENSE_RANK */;
+      name = "Dense Rank";
+    } else {
+      func = "RANK" /* RANK */;
+      name = "Rank";
+    }
+    return new WindowFunctionOperation(null, func, name, void 0, [], this._windowSpec(partitionBy, orderBy));
+  }
+  qcut(buckets, opts = {}) {
+    return new WindowFunctionOperation(
+      null,
+      "NTILE" /* NTILE */,
+      "Quantile",
+      buckets,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  shift(periods = 1, opts = {}) {
+    const extraArgs = opts.fillValue !== void 0 ? [opts.fillValue] : [];
+    const func = periods >= 0 ? "LAG" /* LAG */ : "LEAD" /* LEAD */;
+    const label = periods >= 0 ? "Lag" : "Lead";
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      func,
+      label + " " + this._displayName,
+      Math.abs(periods),
+      extraArgs,
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  first(opts = {}) {
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "FIRST_VALUE" /* FIRST_VALUE */,
+      "First " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  last(opts = {}) {
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "LAST_VALUE" /* LAST_VALUE */,
+      "Last " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+};
+
+// src/datafinder/typed-attributes.ts
+var StringAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  upper() {
+    return new ScalarFunctionOperation(this.cwj(), "UPPER" /* UPPER */, "Upper " + this.displayName());
+  }
+  lower() {
+    return new ScalarFunctionOperation(this.cwj(), "LOWER" /* LOWER */, "Lower " + this.displayName());
+  }
+  strip() {
+    return new ScalarFunctionOperation(this.cwj(), "TRIM" /* TRIM */, "Strip " + this.displayName());
+  }
+  lstrip() {
+    return new ScalarFunctionOperation(this.cwj(), "LTRIM" /* LTRIM */, "LStrip " + this.displayName());
+  }
+  rstrip() {
+    return new ScalarFunctionOperation(this.cwj(), "RTRIM" /* RTRIM */, "RStrip " + this.displayName());
+  }
+  length() {
+    return new ScalarFunctionOperation(this.cwj(), "LENGTH" /* LENGTH */, "Length " + this.displayName());
+  }
+  reverse() {
+    return new ScalarFunctionOperation(this.cwj(), "REVERSE" /* REVERSE */, "Reverse " + this.displayName());
+  }
+  left(n) {
+    return new ScalarFunctionOperation(this.cwj(), "LEFT" /* LEFT */, "Left " + this.displayName(), n);
+  }
+  right(n) {
+    return new ScalarFunctionOperation(this.cwj(), "RIGHT" /* RIGHT */, "Right " + this.displayName(), n);
+  }
+  repeat(n) {
+    return new ScalarFunctionOperation(this.cwj(), "REPEAT" /* REPEAT */, "Repeat " + this.displayName(), n);
+  }
+  replace(fromStr, toStr) {
+    return new ScalarFunctionOperation(this.cwj(), "REPLACE" /* REPLACE */, "Replace " + this.displayName(), void 0, [fromStr, toStr]);
+  }
+  substring(start, length) {
+    const args = length !== void 0 ? [start + 1, length] : [start + 1];
+    return new ScalarFunctionOperation(this.cwj(), "SUBSTRING" /* SUBSTRING */, "Substring " + this.displayName(), void 0, args);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new StringConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new StringConstantOperation(value));
+  }
+  contains(value) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${value}%`));
+  }
+  startsWith(prefix) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`${prefix}%`));
+  }
+  endsWith(suffix) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${suffix}`));
+  }
+  notContains(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_LIKE" /* NOT_LIKE */, new StringConstantOperation(`%${value}%`));
+  }
+};
+var NumericAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  sum() {
+    return new AggregateOperation(this.cwj(), "SUM" /* SUM */, this.displayName() + " Sum");
+  }
+  min() {
+    return new AggregateOperation(this.cwj(), "MIN" /* MIN */, this.displayName() + " Min");
+  }
+  max() {
+    return new AggregateOperation(this.cwj(), "MAX" /* MAX */, this.displayName() + " Max");
+  }
+  average() {
+    return new AggregateOperation(this.cwj(), "AVERAGE" /* AVERAGE */, this.displayName() + " Average");
+  }
+  abs() {
+    return new ScalarFunctionOperation(this.cwj(), "ABS" /* ABS */, "Abs " + this.displayName());
+  }
+  ceil() {
+    return new ScalarFunctionOperation(this.cwj(), "CEILING" /* CEILING */, "Ceil " + this.displayName());
+  }
+  floor() {
+    return new ScalarFunctionOperation(this.cwj(), "FLOOR" /* FLOOR */, "Floor " + this.displayName());
+  }
+  sqrt() {
+    return new ScalarFunctionOperation(this.cwj(), "SQRT" /* SQRT */, "Sqrt " + this.displayName());
+  }
+  mod(n) {
+    return new ScalarFunctionOperation(this.cwj(), "MOD" /* MOD */, "Mod " + this.displayName(), n);
+  }
+  power(n) {
+    return new ScalarFunctionOperation(this.cwj(), "POWER" /* POWER */, "Power " + this.displayName(), n);
+  }
+  round(d) {
+    return new ScalarFunctionOperation(this.cwj(), "ROUND" /* ROUND */, "Round " + this.displayName(), d);
+  }
+};
+var DoubleAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new FloatConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new FloatConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new FloatConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new FloatConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new FloatConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new FloatConstantOperation(value));
+  }
+};
+var FloatAttribute = DoubleAttribute;
+var DecimalAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DecimalConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DecimalConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DecimalConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DecimalConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DecimalConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DecimalConstantOperation(value));
+  }
+};
+var IntegerAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new IntegerConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new IntegerConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new IntegerConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new IntegerConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new IntegerConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new IntegerConstantOperation(value));
+  }
+};
+var BooleanAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(value));
+  }
+  isTrue() {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(true));
+  }
+  isFalse() {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(false));
+  }
+};
+function parseDate(value) {
+  if (value instanceof Date) return value;
+  const d = new Date(value);
+  if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);
+  return d;
+}
+var DateAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateConstantOperation(parseDate(value)));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateConstantOperation(parseDate(value)));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateConstantOperation(parseDate(value)));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateConstantOperation(parseDate(value)));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
+  }
+  year() {
+    return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
+  }
+  month() {
+    return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
+  }
+  day() {
+    return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
+  }
+  quarter() {
+    return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
+  }
+  week() {
+    return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
+  }
+  dayOfWeek() {
+    return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
+  }
+  addDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
+  }
+  addMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
+  }
+  addYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
+  }
+  subtractDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
+  }
+  subtractMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
+  }
+  subtractYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
+  }
+  diffDays(other) {
+    return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
+  }
+  diffMonths(other) {
+    return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
+  }
+  diffYears(other) {
+    return new DateDiffOperation(this.cwj(), other, "YEAR" /* YEAR */, "Diff Years " + this.displayName());
+  }
+};
+var DateTimeAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  year() {
+    return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
+  }
+  month() {
+    return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
+  }
+  day() {
+    return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
+  }
+  hour() {
+    return new DateExtractOperation(this.cwj(), "HOUR" /* HOUR */, "Hour " + this.displayName());
+  }
+  minute() {
+    return new DateExtractOperation(this.cwj(), "MINUTE" /* MINUTE */, "Minute " + this.displayName());
+  }
+  second() {
+    return new DateExtractOperation(this.cwj(), "SECOND" /* SECOND */, "Second " + this.displayName());
+  }
+  quarter() {
+    return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
+  }
+  week() {
+    return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
+  }
+  dayOfWeek() {
+    return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
+  }
+  addDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
+  }
+  addMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
+  }
+  addYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
+  }
+  addHours(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, true, "Add Hours " + this.displayName());
+  }
+  addMinutes(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, true, "Add Minutes " + this.displayName());
+  }
+  addSeconds(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, true, "Add Seconds " + this.displayName());
+  }
+  subtractDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
+  }
+  subtractMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
+  }
+  subtractYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
+  }
+  subtractHours(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, false, "Subtract Hours " + this.displayName());
+  }
+  subtractMinutes(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, false, "Subtract Minutes " + this.displayName());
+  }
+  subtractSeconds(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, false, "Subtract Seconds " + this.displayName());
+  }
+  diffDays(other) {
+    return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
+  }
+  diffMonths(other) {
+    return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
+  }
+  diffYears(other) {
+    return new DateDiffOperation(this.cwj(), other, "YEAR" /* YEAR */, "Diff Years " + this.displayName());
+  }
+  diffHours(other) {
+    return new DateDiffOperation(this.cwj(), other, "HOUR" /* HOUR */, "Diff Hours " + this.displayName());
+  }
+  diffMinutes(other) {
+    return new DateDiffOperation(this.cwj(), other, "MINUTE" /* MINUTE */, "Diff Minutes " + this.displayName());
+  }
+  diffSeconds(other) {
+    return new DateDiffOperation(this.cwj(), other, "SECOND" /* SECOND */, "Diff Seconds " + this.displayName());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanAttribute,
+  DateAttribute,
+  DateTimeAttribute,
+  DecimalAttribute,
+  DoubleAttribute,
+  FloatAttribute,
+  IntegerAttribute,
+  NumericAttribute,
+  StringAttribute
+});
+//# sourceMappingURL=typed-attributes.cjs.map