@oneuptime/common 7.0.2976 → 7.0.2986

package/Server/Types/Workflow/Components/Conditions/IfElse.ts

@@ -5,7 +5,9 @@ import ReturnResult from "Common/Types/IsolatedVM/ReturnResult";
 import { JSONObject, JSONValue } from "Common/Types/JSON";
 import ComponentMetadata, { Port } from "Common/Types/Workflow/Component";
 import ComponentID from "Common/Types/Workflow/ComponentID";
-import Components from "Common/Types/Workflow/Components/Condition";
+import Components, {
+  ConditionOperator,
+} from "Common/Types/Workflow/Components/Condition";
 
 export default class IfElse extends ComponentCode {
   public constructor() {
@@ -87,7 +89,7 @@ export default class IfElse extends ComponentCode {
         return arg;
       };
 
-      const code: string = `
+      let code: string = `
                     const input1 = ${
                       serialize(args["input-1"] as string) || ""
                     };
@@ -96,9 +98,19 @@ export default class IfElse extends ComponentCode {
                       serialize(args["input-2"] as string) || ""
                     };
                     
-                    return input1 ${
-                      (args["operator"] as string) || "=="
-                    } input2`;
+                    `;
+
+      if (args["operator"] === ConditionOperator.Contains) {
+        code += `return input1.includes(input2);`;
+      } else if (args["operator"] === ConditionOperator.DoesNotContain) {
+        code += `return !input1.includes(input2);`;
+      } else if (args["operator"] === ConditionOperator.StartsWith) {
+        code += `return input1.startsWith(input2);`;
+      } else if (args["operator"] === ConditionOperator.EndsWith) {
+        code += `return input1.endsWith(input2);`;
+      } else {
+        code += `return input1 ${(args["operator"] as string) || "=="} input2;`;
+      }
 
       const returnResult: ReturnResult = await VMUtil.runCodeInSandbox({
         code,

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -538,7 +538,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     const selectStatement: Statement = new Statement();
 
     const aggregationMethod: string =
-      aggregateBy.aggregateBy.toLocaleLowerCase();
+      aggregateBy.aggregationType.toLocaleLowerCase();
     const aggregationInterval: string = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,

package/Tests/Types/Database/CompareBase.test.ts

@@ -1,23 +1,23 @@
-import CompareBase from "../../../Types/Database/CompareBase";
+import CompareBase, { CompareType } from "../../../Types/Database/CompareBase";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import { describe, expect, it } from "@jest/globals";
 
 describe("CompareBase", () => {
   describe("toString", () => {
     it("should return string representation of value", () => {
-      const compareBase: CompareBase = new CompareBase(10);
+      const compareBase: CompareBase<CompareType> = new CompareBase(10);
       expect(compareBase.toString()).toBe("10");
     });
   });
 
   describe("toNumber", () => {
     it("should return value as number if it is a number", () => {
-      const compareBase: CompareBase = new CompareBase(10);
+      const compareBase: CompareBase<CompareType> = new CompareBase(10);
       expect(compareBase.toNumber()).toBe(10);
     });
 
     it("should throw BadDataException if value is not a number", () => {
-      const compareBase: CompareBase = new CompareBase(new Date());
+      const compareBase: CompareBase<CompareType> = new CompareBase(new Date());
       expect(() => {
         return compareBase.toNumber();
       }).toThrow(BadDataException);
@@ -27,12 +27,12 @@ describe("CompareBase", () => {
   describe("toDate", () => {
     it("should return value as date object if it is a date object", () => {
       const date: Date = new Date();
-      const compareBase: CompareBase = new CompareBase(date);
+      const compareBase: CompareBase<CompareType> = new CompareBase(date);
       expect(compareBase.toDate()).toBe(date);
     });
 
     it("should throw BadDataException if value is not a date object", () => {
-      const compareBase: CompareBase = new CompareBase(10);
+      const compareBase: CompareBase<CompareType> = new CompareBase(10);
       expect(() => {
         return compareBase.toDate();
       }).toThrow(BadDataException);

package/Tests/Types/Database/Date.test.ts

@@ -73,7 +73,7 @@ describe("DatabaseDate", () => {
 
     it("should be a type of InBetween", () => {
       const inputDate: string = "2023-10-24T12:00:00Z";
-      const result: InBetween =
+      const result: InBetween<string> =
         DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(inputDate);
       expect(result).toBeInstanceOf(InBetween);
     });

package/Tests/Types/Database/EqualToOrNull.test.ts

@@ -6,29 +6,35 @@ import { describe, expect, it } from "@jest/globals";
 describe("EqualToOrNull", () => {
   it("should create an EqualToOrNull object with a valid value", () => {
     const value: string = "oneuptime";
-    const equalObj: EqualToOrNull = new EqualToOrNull(value);
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull<string>(value);
     expect(equalObj.value).toBe(value);
   });
 
   it("should get the value property of an EqualToOrNull object", () => {
     const value: string = "oneuptime";
-    const equalObj: EqualToOrNull = new EqualToOrNull(value);
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull<string>(value);
     expect(equalObj.value).toBe(value);
   });
 
   it("should set the value property of an EqualToOrNull object", () => {
-    const equalObj: EqualToOrNull = new EqualToOrNull("oldValue");
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull<string>(
+      "oldValue",
+    );
     equalObj.value = "newValue";
     expect(equalObj.value).toBe("newValue");
   });
 
   it("should return the correct string representation using toString method", () => {
-    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull<string>(
+      "oneuptime",
+    );
     expect(equalObj.toString()).toBe("oneuptime");
   });
 
   it("should generate the correct JSON representation using toJSON method", () => {
-    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull<string>(
+      "oneuptime",
+    );
     const expectedJSON: JSONObject = {
       _type: "EqualToOrNull",
       value: "oneuptime",
@@ -41,7 +47,7 @@ describe("EqualToOrNull", () => {
       _type: "EqualToOrNull",
       value: "oneuptime",
     };
-    const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+    const equalObj: EqualToOrNull<string> = EqualToOrNull.fromJSON(jsonInput);
     expect(equalObj.value).toBe("oneuptime");
   });
 
@@ -56,7 +62,7 @@ describe("EqualToOrNull", () => {
   });
 
   it("should be a type of EqualToOrNull", () => {
-    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    const equalObj: EqualToOrNull<string> = new EqualToOrNull("oneuptime");
     expect(equalObj).toBeInstanceOf(EqualToOrNull);
   });
 
@@ -65,7 +71,7 @@ describe("EqualToOrNull", () => {
       _type: "EqualToOrNull",
       value: null,
     };
-    const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+    const equalObj: EqualToOrNull<string> = EqualToOrNull.fromJSON(jsonInput);
     expect(equalObj.value).toBeNull();
   });
 });

package/Tests/Types/Database/InBetween.test.ts

@@ -7,7 +7,7 @@ describe("InBetween", () => {
   it("should create an InBetween object with valid start and end values", () => {
     const startValue: number = 10;
     const endValue: number = 20;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     expect(betweenObj.startValue).toBe(10);
     expect(betweenObj.endValue).toBe(20);
   });
@@ -15,7 +15,7 @@ describe("InBetween", () => {
   it("should generate the correct JSON representation using toJSON method", () => {
     const startValue: number = 10;
     const endValue: number = 20;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     const expectedJSON: JSONObject = {
       _type: "InBetween",
       startValue: 10,
@@ -30,7 +30,7 @@ describe("InBetween", () => {
       startValue: 10,
       endValue: 20,
     };
-    const betweenObj: InBetween = InBetween.fromJSON(jsonInput);
+    const betweenObj: InBetween<number> = InBetween.fromJSON(jsonInput);
     expect(betweenObj.startValue).toBe(10);
     expect(betweenObj.endValue).toBe(20);
   });
@@ -49,33 +49,33 @@ describe("InBetween", () => {
   it("should return a string with start and end values matching", () => {
     const startValue: number = 15;
     const endValue: number = 15;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     expect(betweenObj.toString()).toBe("15");
   });
 
   it("should return a string with start and end values different", () => {
     const startValue: number = 10;
     const endValue: number = 20;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     expect(betweenObj.toString()).toBe("10 - 20");
   });
 
   it("should return the start value as a string", () => {
     const startValue: number = 10;
     const endValue: number = 20;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     expect(betweenObj.toStartValueString()).toBe("10");
   });
 
   it("should return the end value as a string", () => {
     const startValue: number = 10;
     const endValue: number = 20;
-    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const betweenObj: InBetween<number> = new InBetween(startValue, endValue);
     expect(betweenObj.toEndValueString()).toBe("20");
   });
 
   it("should be a type of InBetween", () => {
-    const inBetweenObj: InBetween = new InBetween(10, 15);
+    const inBetweenObj: InBetween<number> = new InBetween(10, 15);
     expect(inBetweenObj).toBeInstanceOf(InBetween);
   });
 });

package/Tests/Types/Database/NotEqual.test.ts

@@ -5,14 +5,14 @@ describe("NotEqual", () => {
   describe("constructor", () => {
     it("should set the value property", () => {
       const value: string = "test";
-      const notEqual: NotEqual = new NotEqual(value);
+      const notEqual: NotEqual<string> = new NotEqual(value);
       expect(notEqual.value).toBe(value);
     });
   });
   describe("toString", () => {
     it("should return the string value", () => {
       const value: string = "test";
-      const notEqual: NotEqual = new NotEqual(value);
+      const notEqual: NotEqual<string> = new NotEqual(value);
       expect(notEqual.toString()).toBe(value);
     });
   });

package/Types/BaseDatabase/AggregateBy.ts

@@ -5,7 +5,7 @@ import Sort from "./Sort";
 
 export default interface AggregateBy<TBaseModel extends GenericObject> {
   aggregateColumnName: keyof TBaseModel;
-  aggregateBy: AggregationType;
+  aggregationType: AggregationType;
   // aggregationInterval?: AggregationInterval;
   aggregationTimestampColumnName: keyof TBaseModel;
   startTimestamp: Date;

package/Types/BaseDatabase/EqualToOrNull.ts

@@ -1,35 +1,31 @@
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
-import SerializableObject from "../SerializableObject";
 
-export default class EqualToOrNull extends SerializableObject {
-  private _value!: string;
-  public get value(): string {
-    return this._value;
-  }
-  public set value(v: string) {
-    this._value = v;
-  }
-
-  public constructor(value: string) {
-    super();
+export default class EqualToOrNull<
+  T extends CompareType,
+> extends CompareBase<T> {
+  public constructor(value: T) {
+    super(value);
     this.value = value;
   }
 
   public override toString(): string {
-    return this.value;
+    return this.value.toString();
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.EqualToOrNull,
-      value: (this as EqualToOrNull).toString(),
+      value: (this as EqualToOrNull<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): EqualToOrNull {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): EqualToOrNull<T> {
     if (json["_type"] === ObjectType.EqualToOrNull) {
-      return new EqualToOrNull(json["value"] as string);
+      return new EqualToOrNull(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/GreaterThan.ts

@@ -1,22 +1,24 @@
-import CompareBase from "../Database/CompareBase";
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
-export default class GreaterThan extends CompareBase {
-  public constructor(value: number | Date) {
+export default class GreaterThan<T extends CompareType> extends CompareBase<T> {
+  public constructor(value: T) {
     super(value);
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.GreaterThan,
-      value: (this as GreaterThan).toString(),
+      value: (this as GreaterThan<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): GreaterThan {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): GreaterThan<T> {
     if (json["_type"] === ObjectType.GreaterThan) {
-      return new GreaterThan(json["value"] as number | Date);
+      return new GreaterThan(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/GreaterThanOrEqual.ts

@@ -1,22 +1,26 @@
-import CompareBase from "../Database/CompareBase";
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
-export default class GreaterThanOrEqual extends CompareBase {
-  public constructor(value: number | Date) {
+export default class GreaterThanOrEqual<
+  T extends CompareType,
+> extends CompareBase<T> {
+  public constructor(value: T) {
     super(value);
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.GreaterThanOrEqual,
-      value: (this as GreaterThanOrEqual).toString(),
+      value: (this as GreaterThanOrEqual<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): GreaterThanOrEqual {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): GreaterThanOrEqual<T> {
     if (json["_type"] === ObjectType.GreaterThanOrEqual) {
-      return new GreaterThanOrEqual(json["value"] as number | Date);
+      return new GreaterThanOrEqual<T>(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/InBetween.ts

@@ -1,29 +1,28 @@
 import OneUptimeDate from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
-import SerializableObject from "../SerializableObject";
+import QueryOperator from "./QueryOperator";
 
-export default class InBetween extends SerializableObject {
-  private _startValue!: number | Date | string;
-  public get startValue(): number | Date | string {
+export default class InBetween<
+  T extends number | Date | string,
+> extends QueryOperator<T> {
+  private _startValue!: T;
+  public get startValue(): T {
     return this._startValue;
   }
-  public set startValue(v: number | Date | string) {
+  public set startValue(v: T) {
     this._startValue = v;
   }
 
-  private _endValue!: number | Date | string;
-  public get endValue(): number | Date | string {
+  private _endValue!: T;
+  public get endValue(): T {
     return this._endValue;
   }
-  public set endValue(v: number | Date | string) {
+  public set endValue(v: T) {
     this._endValue = v;
   }
 
-  public constructor(
-    startValue: number | Date | string,
-    endValue: number | Date | string,
-  ) {
+  public constructor(startValue: T, endValue: T) {
     super();
     this.startValue = startValue;
     this.endValue = endValue;
@@ -32,32 +31,31 @@ export default class InBetween extends SerializableObject {
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.InBetween,
-      startValue: (this as InBetween).startValue,
-      endValue: (this as InBetween).endValue,
+      startValue: (this as InBetween<T>).startValue,
+      endValue: (this as InBetween<T>).endValue,
     };
   }
 
-  public static override fromJSON(json: JSONObject): InBetween {
+  public static override fromJSON<T extends number | Date | string>(
+    json: JSONObject,
+  ): InBetween<T> {
     if (json["_type"] === ObjectType.InBetween) {
-      return new InBetween(
-        json["startValue"] as number | Date | string,
-        json["endValue"] as number | Date | string,
-      );
+      return new InBetween(json["startValue"] as T, json["endValue"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
   }
 
   public override toString(): string {
-    let startValue: number | Date | string = this.startValue;
-    let endValue: number | Date | string = this.endValue;
+    let startValue: T = this.startValue;
+    let endValue: T = this.endValue;
 
     if (startValue instanceof Date) {
-      startValue = OneUptimeDate.asDateForDatabaseQuery(startValue);
+      startValue = OneUptimeDate.asDateForDatabaseQuery(startValue) as T;
     }
 
     if (endValue instanceof Date) {
-      endValue = OneUptimeDate.asDateForDatabaseQuery(endValue);
+      endValue = OneUptimeDate.asDateForDatabaseQuery(endValue) as T;
     }
 
     if (startValue.toString() === endValue.toString()) {

package/Types/BaseDatabase/Includes.ts

@@ -2,11 +2,11 @@ import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 import JSONFunctions from "../JSONFunctions";
 import ObjectID from "../ObjectID";
-import SerializableObject from "../SerializableObject";
+import QueryOperator from "./QueryOperator";
 
 export type IncludesType = Array<string> | Array<ObjectID> | Array<number>;
 
-export default class Includes extends SerializableObject {
+export default class Includes extends QueryOperator<IncludesType> {
   private _values: IncludesType = [];
 
   public get values(): IncludesType {

package/Types/BaseDatabase/IsNull.ts

@@ -1,8 +1,9 @@
 import BadDataException from "../Exception/BadDataException";
+import GenericObject from "../GenericObject";
 import { JSONObject, ObjectType } from "../JSON";
-import SerializableObject from "../SerializableObject";
+import QueryOperator from "./QueryOperator";
 
-export default class IsNull extends SerializableObject {
+export default class IsNull extends QueryOperator<GenericObject> {
   public constructor() {
     super();
   }

package/Types/BaseDatabase/LessThan.ts

@@ -1,22 +1,24 @@
-import CompareBase from "../Database/CompareBase";
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
-export default class LessThan extends CompareBase {
-  public constructor(value: number | Date) {
+export default class LessThan<T extends CompareType> extends CompareBase<T> {
+  public constructor(value: T) {
     super(value);
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.LessThan,
-      value: (this as LessThan).toString(),
+      value: (this as LessThan<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): LessThan {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): LessThan<T> {
     if (json["_type"] === ObjectType.LessThan) {
-      return new LessThan(json["value"] as number | Date);
+      return new LessThan(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/LessThanOrEqual.ts

@@ -1,22 +1,26 @@
-import CompareBase from "../Database/CompareBase";
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
-export default class LessThanOrEqual extends CompareBase {
-  public constructor(value: number | Date) {
+export default class LessThanOrEqual<
+  T extends CompareType,
+> extends CompareBase<T> {
+  public constructor(value: T) {
     super(value);
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.LessThanOrEqual,
-      value: (this as LessThanOrEqual).toString(),
+      value: (this as LessThanOrEqual<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): LessThanOrEqual {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): LessThanOrEqual<T> {
     if (json["_type"] === ObjectType.LessThanOrEqual) {
-      return new LessThanOrEqual(json["value"] as number | Date);
+      return new LessThanOrEqual<T>(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/NotEqual.ts

@@ -1,35 +1,28 @@
+import CompareBase, { CompareType } from "../Database/CompareBase";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
-import SerializableObject from "../SerializableObject";
 
-export default class NotEqual extends SerializableObject {
-  private _value!: string;
-  public get value(): string {
-    return this._value;
-  }
-  public set value(v: string) {
-    this._value = v;
-  }
-
-  public constructor(value: string) {
-    super();
-    this.value = value;
+export default class NotEqual<T extends CompareType> extends CompareBase<T> {
+  public constructor(value: T) {
+    super(value);
   }
 
   public override toString(): string {
-    return this.value;
+    return this.value.toString();
   }
 
   public override toJSON(): JSONObject {
     return {
       _type: ObjectType.NotEqual,
-      value: (this as NotEqual).toString(),
+      value: (this as NotEqual<T>).toString(),
     };
   }
 
-  public static override fromJSON(json: JSONObject): NotEqual {
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): NotEqual<T> {
     if (json["_type"] === ObjectType.NotEqual) {
-      return new NotEqual(json["value"] as string);
+      return new NotEqual(json["value"] as T);
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));

package/Types/BaseDatabase/NotNull.ts

@@ -1,8 +1,9 @@
 import BadDataException from "../Exception/BadDataException";
+import GenericObject from "../GenericObject";
 import { JSONObject, ObjectType } from "../JSON";
-import SerializableObject from "../SerializableObject";
+import QueryOperator from "./QueryOperator";
 
-export default class NotNull extends SerializableObject {
+export default class NotNull extends QueryOperator<GenericObject> {
   public constructor() {
     super();
   }

package/Types/BaseDatabase/Query.ts

@@ -1,12 +1,23 @@
 import GenericObject from "../GenericObject";
-import { JSONObject, JSONValue } from "../JSON";
+import QueryOperator from "./QueryOperator";
 
-export type QueryPropertyOptions = JSONValue | JSONObject;
-
-export declare type QueryOptions<Entity> = {
-  [P in keyof Entity]?: QueryPropertyOptions;
+export declare type FindWhereProperty<Property extends GenericObject> =
+  | Property
+  | FindWhere<Property>
+  | QueryOperator<Property>
+  | undefined;
+/**
+ * :
+ * Used for find operations.
+ */
+export declare type FindWhere<Entity> = {
+  [P in keyof Entity]?: FindWhereProperty<NonNullable<Entity[P]>>;
 };
 
-type Query<TBaseModel extends GenericObject> = QueryOptions<TBaseModel>;
+declare type Query<TBaseModel extends GenericObject> = FindWhere<TBaseModel>;
+
+export declare type OrQuery<TBaseModel extends GenericObject> = Array<
+  Query<TBaseModel>
+>;
 
 export default Query;