tabletcommand-backend-models 5.39.6 → 7.0.0

package/definitions/models/validation-report.d.ts

@@ -1,385 +1,50 @@
-/// <reference types="mongoose" />
-import { currentDate, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, MongooseModule, ReplaceModelReturnType } from "../helpers";
-export declare function ValidationReportSchema(mongoose: MongooseModule): import("mongoose").Schema<any> & {
-    _interface: import("../helpers").MongooseInterface<{
-        _id: {
-            type: import("mongoose").Types.ObjectIdConstructor;
-            auto: boolean;
-        };
-        departmentId: {
-            type: import("mongoose").Types.ObjectIdConstructor;
-            ref: string;
-            required: boolean;
-            unique: boolean;
-        };
-        location: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        statusMap: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        status: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        vehicleStatus: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        vehicle: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        incident: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        personnel: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    message: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                    firstSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    lastSeenAt: {
-                        type: DateConstructor;
-                        default: typeof currentDate;
-                    };
-                    clearedAt: {
-                        type: DateConstructor;
-                        default: undefined;
-                    };
-                    payload: {
-                        type: ObjectConstructor;
-                        default: {};
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        modified: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-    }>;
-    _methods: unknown;
-};
-export declare function ValidationReportModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
-    _id: import("mongoose").Types.ObjectId;
-    departmentId: import("mongoose").Types.ObjectId;
-    location: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    statusMap: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    status: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    vehicleStatus: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    vehicle: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    incident: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    personnel: import("../helpers").MongooseInterface<{
-        message: {
-            type: StringConstructor;
-            default: string;
-        };
-        firstSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        lastSeenAt: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        clearedAt: {
-            type: DateConstructor;
-            default: undefined;
-        };
-        payload: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>[];
-    modified: string;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface ValidationReport extends ItemTypeFromTypeSchemaFunction<typeof ValidationReportModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Model, Types } from "mongoose";
+import { MongooseModule } from "../helpers";
+import { ValidationErrorItemSchemaType } from "./schema/validation-error-item";
+export interface ValidationReport {
+    _id: Types.ObjectId;
+    departmentId: Types.ObjectId;
+    location: ValidationErrorItemSchemaType[];
+    statusMap: ValidationErrorItemSchemaType[];
+    status: ValidationErrorItemSchemaType[];
+    vehicleStatus: ValidationErrorItemSchemaType[];
+    vehicle: ValidationErrorItemSchemaType[];
+    incident: ValidationErrorItemSchemaType[];
+    personnel: ValidationErrorItemSchemaType[];
+    modified: Date;
 }
-export interface ValidationReportModel extends ModelTypeFromTypeSchemaFunction<ValidationReport> {
+export declare function ValidationReportSchema(mongoose: MongooseModule): import("mongoose").Schema<ValidationReport, Model<ValidationReport, any, any, any, import("mongoose").Document<unknown, any, ValidationReport> & ValidationReport & Required<{
+    _id: Types.ObjectId;
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ValidationReport, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ValidationReport>> & import("mongoose").FlatRecord<ValidationReport> & Required<{
+    _id: Types.ObjectId;
+}>>;
+export default function ValidationReportModule(mongoose: MongooseModule): Promise<Model<ValidationReport, {}, {}, {}, import("mongoose").Document<unknown, {}, ValidationReport> & ValidationReport & Required<{
+    _id: Types.ObjectId;
+}>, any>>;
+export interface ValidationReportModel extends Model<ValidationReport> {
 }
-declare const _default: ReplaceModelReturnType<typeof ValidationReportModule, ValidationReportModel>;
-export default _default;
 //# sourceMappingURL=validation-report.d.ts.map

package/definitions/models/validation-report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-report.d.ts","sourceRoot":"","sources":["../../src/models/validation-report.ts"],"names":[],"mappings":";AAAA,OAAO,EAGL,WAAW,EACX,8BAA8B,EAC9B,+BAA+B,EAC/B,cAAc,EACd,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqD9D;AAED,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGpE;AAED,MAAM,WAAW,gBAAiB,SAAQ,8BAA8B,CAAC,OAAO,sBAAsB,CAAC;CAAI;AAC3G,MAAM,WAAW,qBAAsB,SAAQ,+BAA+B,CAAC,gBAAgB,CAAC;CAAI;;AACpG,wBAAsH"}
+{"version":3,"file":"validation-report.d.ts","sourceRoot":"","sources":["../../src/models/validation-report.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAEL,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAkC,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAE1G,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC;IACpB,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC;IAC7B,QAAQ,EAAE,6BAA6B,EAAE,CAAC;IAC1C,SAAS,EAAE,6BAA6B,EAAE,CAAC;IAC3C,MAAM,EAAE,6BAA6B,EAAE,CAAC;IACxC,aAAa,EAAE,6BAA6B,EAAE,CAAC;IAC/C,OAAO,EAAE,6BAA6B,EAAE,CAAC;IACzC,QAAQ,EAAE,6BAA6B,EAAE,CAAC;IAC1C,SAAS,EAAE,6BAA6B,EAAE,CAAC;IAC3C,QAAQ,EAAE,IAAI,CAAC;CAChB;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc;;;;IAoD9D;AAED,wBAA8B,sBAAsB,CAAC,QAAQ,EAAE,cAAc;;UAG5E;AAED,MAAM,WAAW,qBAAsB,SAAQ,KAAK,CAAC,gBAAgB,CAAC;CAAI"}

package/definitions/test/mock.d.ts

@@ -1,6 +1,4 @@
-export default function MockModule(dependecies: {
-    models: unknown;
-}): {
+export default function MockModule(): {
     cleanup: () => Promise<string>;
     arcGISGroup: {
         access: string;

package/definitions/test/mock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/test/mock.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,WAAW,EAAE;IAC9C,MAAM,EAAE,OAAO,CAAC;CACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDA"}
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/test/mock.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0DjC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabletcommand-backend-models",
-  "version": "5.39.6",
+  "version": "7.0.0",
   "description": "Tablet Command Backend Models",
   "scripts": {
     "build": "gulp build",
@@ -21,7 +21,7 @@
     "debug": "^4.3.5",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.45",
-    "mongoose": "=5.10.19",
+    "mongoose": "^7.7.0",
     "mongoose-lean-virtuals": "^0.7.6",
     "uuid": "~10.0.0"
   },
@@ -30,8 +30,6 @@
     "@types/chai": "^4.3.16",
     "@types/lodash": "^4.14.202",
     "@types/mocha": "^10.0.7",
-    "@types/mongodb": "^3.6.20",
-    "@types/mongoose": "~5.10.5",
     "@types/uuid": "~10.0.0",
     "@typescript-eslint/eslint-plugin": "~6.20.0",
     "@typescript-eslint/parser": "~6.20.0",

package/src/constants.ts

@@ -1,8 +1,25 @@
 // These should be converted to Typescript Enum after upgrading mongoose to 6.x or newer
 
-export type LocationSource =
-  "CAD" | "FleetComplete" | "GST" |
-  "Samsara" | "Skymira" | "SKYTRAC" | "Somewear" |
-  "TC-Android" | "TC-iOS" | "TCMobile-Android" | "TCMobile-iOS" |
-  "VehicleModem";
-export type LocationKindType = "fixed-wing" | "helicopter" | "marine" | "person" | "vehicle";
+
+export enum LocationSource {
+  CAD = "CAD",
+  FleetComplete = "FleetComplete",
+  GST = "GST",
+  Samsara = "Samsara",
+  Skymira = "Skymira",
+  SKYTRAC = "SKYTRAC",
+  Somewear = "Somewear",
+  TCAndroid = "TC-Android",
+  TCIOS = "TC-iOS",
+  TCMobileAndroid = "TCMobile-Android",
+  TCMobileIOS = "TCMobile-iOS",
+  VehicleModem = "VehicleModem"
+}
+
+export enum LocationKindType {
+  FixedWing = "fixed-wing",
+  Helicopter = "helicopter",
+  Marine = "marine",
+  Person = "person",
+  Vehicle = "vehicle"
+}

package/src/helpers.ts

@@ -63,14 +63,6 @@ export function createSchema
   return schema as unknown as Schema & { _interface: MongooseInterface<T>, _methods: TMethods };
 }
 
-export function createModel<T, TMethods>(mongoose: MongooseModule, name: string, schema: Schema & { _interface: T, _methods?: TMethods }) {
-  if (mongoose.models[name]) {
-    return mongoose.model<Document & T & TMethods>(name) as Model<Document & T & TMethods> & { __methods?: TMethods };
-  } else {
-    return mongoose.model<Document & T & TMethods>(name, schema) as Model<Document & T & TMethods> & { __methods?: TMethods };
-  }
-}
-
 export type ModelFromSchemaDefinition<T extends SchemaDefinition> = ModelFromSchema<Schema & { _interface: MongooseInterface<T> }>;
 export type ModelFromSchema<T extends Schema> = Model<DocumentTypeFromSchema<T>>;
 export type DocumentFromSchemaDefinition<T extends SchemaDefinition> = DocumentTypeFromSchema<Schema & { _interface: MongooseInterface<T> }>;
@@ -86,6 +78,13 @@ export function currentDate() {
   return new Date();
 }
 
+export function convertToObjectId(id: string): Types.ObjectId {
+  if (id) {
+    return new Types.ObjectId(id);
+  }
+  return new Types.ObjectId();
+}
+
 type Or<T> = T & {
   $or?: Or<T>[],
 };

package/src/index.ts

@@ -1,5 +1,5 @@
 import * as _ from "lodash";
-import { ConnectionOptions } from "mongoose";
+import { ConnectOptions } from "mongoose";
 import { MongooseModule } from "./helpers";
 import {
   LocationKindType,
@@ -125,24 +125,27 @@ export { ValidationReport, ValidationReportModel } from "./models/validation-rep
 
 export * from "./helpers";
 
-export async function connect(url: string, overwriteOpts?: ConnectionOptions) {
+export async function connect(url: string, overwriteOpts?: ConnectOptions) {
   const mongoose = await import("mongoose");
   mongoose.Promise = await import("bluebird");
-
   const models = await wireModels(mongoose);
-  const defaultOpts: ConnectionOptions = {
+  const defaultOpts: ConnectOptions = {
     autoIndex: false,
     readPreference: "primaryPreferred",
-    useNewUrlParser: true,
-    useUnifiedTopology: true,
   };
   // If present, overwrite options
-  const opts: ConnectionOptions = _.assign({}, defaultOpts, overwriteOpts);
+  const opts: ConnectOptions = _.assign({}, defaultOpts, overwriteOpts);
   const connection = await mongoose.connect(url, opts);
 
   return { mongoose, connection, models };
 }
 
+export async function getMongoose() {
+  const mongoose = await import("mongoose");
+  return mongoose;
+}
+
 type UnboxPromise<T extends Promise<unknown>> = T extends Promise<infer U> ? U : never;
 export type BackendModels = UnboxPromise<ReturnType<typeof connect>>["models"];
+export type MongooseTypes = MongooseModule;
 export default connect;

package/src/models/action-log.ts

@@ -1,20 +1,31 @@
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
   retrieveCurrentUnixTime,
-  ModelTypeFromTypeSchemaFunction,
-  ItemTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-export async function ActionLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ActionLog {
+  _id: Types.ObjectId,
+  departmentId: string,
+  email: string,
+  userId: string,
+  action: string,
+  object: object,
+  before: object,
+  after: object,
+  delta: object,
+  message: string,
+  createdAt: Date,
+  modified_unix_date: number,
 
-  const modelSchema = createSchema(Schema, {
+}
+
+export default async function ActionLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const modelSchema = new Schema<ActionLog>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -62,12 +73,9 @@ export async function ActionLogModule(mongoose: MongooseModule) {
       default: retrieveCurrentUnixTime,
     },
   }, {
-    collection: "massive_action_log",
+    autoIndex: false
   });
-  modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "ActionLog", modelSchema);
+  return mongoose.model<ActionLog>("ActionLog", modelSchema, "massive_action_log", { overwriteModels: true });
 }
 
-export interface ActionLog extends ItemTypeFromTypeSchemaFunction<typeof ActionLogModule> { }
-export interface ActionLogModel extends ModelTypeFromTypeSchemaFunction<ActionLog> { }
-export default ActionLogModule as ReplaceModelReturnType<typeof ActionLogModule, ActionLogModel>;
+export interface ActionLogModel extends Model<ActionLog> { }