@oneuptime/common 12.0.7 → 12.0.8

package/Tests/Utils/Schema/ModelSchema.test.ts

@@ -0,0 +1,268 @@
+import { ModelSchema } from "../../../Utils/Schema/ModelSchema";
+import Zod from "../../../Utils/Schema/Zod";
+import {
+  getTableColumns,
+  TableColumnMetadata,
+} from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import Dictionary from "../../../Types/Dictionary";
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Label from "../../../Models/DatabaseModels/Label";
+import ApiKey from "../../../Models/DatabaseModels/ApiKey";
+import Team from "../../../Models/DatabaseModels/Team";
+import ShortLink from "../../../Models/DatabaseModels/ShortLink";
+import MonitorGroup from "../../../Models/DatabaseModels/MonitorGroup";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+
+/*
+ * Unit tests for ModelSchema — the Zod schema generator behind the public API
+ * (OpenAPI spec, request validation, and the Terraform provider generator) for
+ * every Postgres-backed database model.
+ *
+ * The generator is pure: it reads TypeORM column metadata and per-column
+ * access control off a freshly instantiated model, so no database connection is
+ * needed. These tests pin down the create/update/delete/select/sort/group-by
+ * contracts that API consumers depend on.
+ */
+
+type ModelCtor = new () => DatabaseBaseModel;
+
+// A curated set of small, stable models spanning different column shapes.
+const SAMPLE_MODELS: Array<ModelCtor> = [
+  Label,
+  ApiKey,
+  Team,
+  ShortLink,
+  MonitorGroup,
+  StatusPage,
+  Incident,
+];
+
+// Column types ModelSchema.getSortableTypes() considers sortable.
+const SORTABLE_TYPES: Array<TableColumnType> = [
+  TableColumnType.VeryLongText,
+  TableColumnType.Slug,
+  TableColumnType.ShortText,
+  TableColumnType.LongText,
+  TableColumnType.Number,
+  TableColumnType.Date,
+  TableColumnType.Boolean,
+  TableColumnType.Description,
+  TableColumnType.ObjectID,
+];
+
+const CREATE_EXCLUDED_FIELDS: Array<string> = [
+  "_id",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "version",
+];
+
+const UPDATE_EXCLUDED_FIELDS: Array<string> = [
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "version",
+];
+
+const isZodObject: (schema: unknown) => boolean = (
+  schema: unknown,
+): boolean => {
+  return schema instanceof Zod.ZodObject;
+};
+
+const shapeKeys: (schema: any) => Array<string> = (
+  schema: any,
+): Array<string> => {
+  return Object.keys(schema.shape);
+};
+
+describe("ModelSchema (Postgres)", () => {
+  describe("getModelSchema / getReadModelSchema", () => {
+    test("returns a non-empty ZodObject for a real model", () => {
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+
+      expect(isZodObject(schema)).toBe(true);
+      expect(shapeKeys(schema).length).toBeGreaterThan(0);
+    });
+
+    test("excludes Entity (relation) columns from the schema", () => {
+      const model: Label = new Label();
+      const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const key in columns) {
+        const column: TableColumnMetadata | undefined = columns[key];
+        if (column && column.type === TableColumnType.Entity) {
+          expect(keys).not.toContain(key);
+        }
+      }
+    });
+
+    test("only includes columns that grant read access", () => {
+      const model: Label = new Label();
+      const accessControl: any = model.getColumnAccessControlForAllColumns();
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+
+      for (const key of shapeKeys(schema)) {
+        const control: any = accessControl[key];
+        /*
+         * Columns with declared access control must expose read permissions;
+         * columns without any declared control are allowed through.
+         */
+        if (control) {
+          expect(control.read.length).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    test("builds read schemas for every sample model", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        expect(isZodObject(ModelSchema.getModelSchema({ modelType }))).toBe(
+          true,
+        );
+        expect(isZodObject(ModelSchema.getReadModelSchema({ modelType }))).toBe(
+          true,
+        );
+      }
+    });
+  });
+
+  describe("getCreateModelSchema", () => {
+    test("excludes auto-generated system fields", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getCreateModelSchema({ modelType });
+        const keys: Array<string> = shapeKeys(schema);
+        for (const excluded of CREATE_EXCLUDED_FIELDS) {
+          expect(keys).not.toContain(excluded);
+        }
+      }
+    });
+
+    test("produces the same fields with and without OpenAPI metadata", () => {
+      const withOpenApi: any = ModelSchema.getCreateModelSchema({
+        modelType: Label,
+      });
+      const withoutOpenApi: any = ModelSchema.getCreateModelSchema({
+        modelType: Label,
+        disableOpenApiSchema: true,
+      });
+
+      expect(isZodObject(withoutOpenApi)).toBe(true);
+      expect(shapeKeys(withoutOpenApi).sort()).toEqual(
+        shapeKeys(withOpenApi).sort(),
+      );
+    });
+  });
+
+  describe("getUpdateModelSchema", () => {
+    test("excludes immutable audit fields but keeps _id", () => {
+      const schema: any = ModelSchema.getUpdateModelSchema({
+        modelType: Label,
+      });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const excluded of UPDATE_EXCLUDED_FIELDS) {
+        expect(keys).not.toContain(excluded);
+      }
+    });
+
+    test("treats every field as optional (empty patch is valid)", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getUpdateModelSchema({ modelType });
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+
+  describe("getDeleteModelSchema", () => {
+    test("only exposes the identifier field", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getDeleteModelSchema({ modelType });
+        expect(shapeKeys(schema)).toEqual(["_id"]);
+      }
+    });
+  });
+
+  describe("getSelectModelSchema", () => {
+    test("marks fields as optional booleans and rejects other types", () => {
+      const schema: any = ModelSchema.getSelectModelSchema({
+        modelType: Label,
+      });
+      const keys: Array<string> = shapeKeys(schema);
+      const someKey: string = keys[0]!;
+
+      expect(keys.length).toBeGreaterThan(0);
+      expect(schema.safeParse({}).success).toBe(true);
+      expect(schema.safeParse({ [someKey]: true }).success).toBe(true);
+      expect(schema.safeParse({ [someKey]: "select-me" }).success).toBe(false);
+    });
+
+    test("builds a select schema for every sample model", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        expect(
+          isZodObject(ModelSchema.getSelectModelSchema({ modelType })),
+        ).toBe(true);
+      }
+    });
+  });
+
+  describe("getSortModelSchema", () => {
+    test("includes only sortable column types", () => {
+      const model: Label = new Label();
+      const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+      const schema: any = ModelSchema.getSortModelSchema({ modelType: Label });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const key in columns) {
+        const column: TableColumnMetadata | undefined = columns[key];
+        if (!column) {
+          continue;
+        }
+        if (SORTABLE_TYPES.includes(column.type)) {
+          expect(keys).toContain(key);
+        } else {
+          expect(keys).not.toContain(key);
+        }
+      }
+    });
+
+    test("accepts only ASC/DESC values", () => {
+      const schema: any = ModelSchema.getSortModelSchema({ modelType: Label });
+      const key: string = shapeKeys(schema)[0]!;
+
+      expect(schema.safeParse({}).success).toBe(true);
+      expect(schema.safeParse({ [key]: SortOrder.Ascending }).success).toBe(
+        true,
+      );
+      expect(schema.safeParse({ [key]: SortOrder.Descending }).success).toBe(
+        true,
+      );
+      expect(schema.safeParse({ [key]: "RANDOM" }).success).toBe(false);
+    });
+  });
+
+  describe("getGroupByModelSchema", () => {
+    test("builds a group-by schema and accepts an empty object", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getGroupByModelSchema({ modelType });
+        expect(isZodObject(schema)).toBe(true);
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+
+  describe("getQueryModelSchema", () => {
+    test("builds a query schema that accepts an empty query", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getQueryModelSchema({ modelType });
+        expect(isZodObject(schema)).toBe(true);
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+});

package/Tests/Utils/Telemetry/EntityKeyNonTelemetry.test.ts

@@ -0,0 +1,193 @@
+import {
+  computeEntityKey,
+  INVENTORY_ENTITY_IDENTITY_ATTRIBUTE,
+  keyForInventoryEntity,
+  keyForManualEntity,
+  MANUAL_ENTITY_IDENTITY_ATTRIBUTE,
+} from "../../../Utils/Telemetry/EntityKey";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Identity for the two entity flavours that never pass through ingest:
+ * manually registered CIs and rows mirrored from OneUptime's inventory
+ * tables. Neither has an ingest-side resolver to byte-match, so the only
+ * things that must hold are the ones tested here — determinism, tenant and
+ * type separation, and the specific choice of what each keys on (a manual CI
+ * on its name, an inventory mirror on its owning row's id).
+ *
+ * The consequence of getting these wrong is duplicate registry rows that
+ * both look correct, so each property is pinned rather than assumed.
+ */
+
+const PROJECT: string = "proj1";
+const OTHER_PROJECT: string = "proj2";
+const RESOURCE_ID: string = "6f2e5c1a-0b3d-4e5f-8a9b-1c2d3e4f5a6b";
+
+describe("keyForManualEntity", () => {
+  test("is deterministic", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    );
+  });
+
+  test("is a 16-char lowercase hex key, like every other entity key", () => {
+    const key: string = keyForManualEntity(
+      PROJECT,
+      EntityType.ExternalService,
+      "Stripe API",
+    );
+    expect(key).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  test("canonicalizes the name, so casing and padding do not fork identity", () => {
+    const canonical: string = keyForManualEntity(
+      PROJECT,
+      EntityType.ExternalService,
+      "Stripe API",
+    );
+
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "  stripe api "),
+    ).toBe(canonical);
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "STRIPE API"),
+    ).toBe(canonical);
+  });
+
+  test("separates tenants", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).not.toBe(
+      keyForManualEntity(
+        OTHER_PROJECT,
+        EntityType.ExternalService,
+        "Stripe API",
+      ),
+    );
+  });
+
+  test("separates types, so one name can exist as two kinds of thing", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "payments"),
+    ).not.toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalDatabase, "payments"),
+    );
+  });
+
+  test("distinct names within a type get distinct keys", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).not.toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Adyen API"),
+    );
+  });
+
+  test("matches computeEntityKey over the documented identity attribute", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.Appliance, "Rack PDU 3"),
+    ).toBe(
+      computeEntityKey({
+        projectId: PROJECT,
+        entityType: EntityType.Appliance,
+        identifyingAttributes: {
+          [MANUAL_ENTITY_IDENTITY_ATTRIBUTE]: "rack pdu 3",
+        },
+      }),
+    );
+  });
+});
+
+describe("keyForInventoryEntity", () => {
+  test("is deterministic", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).toBe(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    );
+  });
+
+  test("keys on the owning row id, so renaming the row keeps its identity", () => {
+    /*
+     * This is the whole reason inventory mirrors key on the id rather than
+     * the name: a rename must update the existing registry row, not orphan
+     * it and mint a second one alongside.
+     */
+    const key: string = keyForInventoryEntity(
+      PROJECT,
+      EntityType.NetworkDevice,
+      RESOURCE_ID,
+    );
+
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).toBe(key);
+  });
+
+  test("separates tenants and types", () => {
+    const key: string = keyForInventoryEntity(
+      PROJECT,
+      EntityType.NetworkDevice,
+      RESOURCE_ID,
+    );
+
+    expect(
+      keyForInventoryEntity(
+        OTHER_PROJECT,
+        EntityType.NetworkDevice,
+        RESOURCE_ID,
+      ),
+    ).not.toBe(key);
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.IoTDevice, RESOURCE_ID),
+    ).not.toBe(key);
+  });
+
+  test("distinct rows get distinct keys", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).not.toBe(
+      keyForInventoryEntity(
+        PROJECT,
+        EntityType.NetworkDevice,
+        "11111111-2222-3333-4444-555555555555",
+      ),
+    );
+  });
+
+  test("matches computeEntityKey over the documented identity attribute", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.CloudResource, RESOURCE_ID),
+    ).toBe(
+      computeEntityKey({
+        projectId: PROJECT,
+        entityType: EntityType.CloudResource,
+        identifyingAttributes: {
+          [INVENTORY_ENTITY_IDENTITY_ATTRIBUTE]: RESOURCE_ID,
+        },
+      }),
+    );
+  });
+});
+
+describe("manual and inventory identities do not collide", () => {
+  test("the two attributes are distinct", () => {
+    expect(MANUAL_ENTITY_IDENTITY_ATTRIBUTE).not.toBe(
+      INVENTORY_ENTITY_IDENTITY_ATTRIBUTE,
+    );
+  });
+
+  test("same project, same type, same literal value still key differently", () => {
+    /*
+     * A manual CI literally named after a resource id would otherwise
+     * collide with the mirror of that resource.
+     */
+    expect(
+      keyForManualEntity(PROJECT, EntityType.Appliance, RESOURCE_ID),
+    ).not.toBe(
+      keyForInventoryEntity(PROJECT, EntityType.Appliance, RESOURCE_ID),
+    );
+  });
+});

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -26,6 +26,31 @@ export type NetworkTopologyLinkProtocol = "lldp" | "cdp" | "fdb";
  */
 export type NetworkTopologyNodeKind = "device" | "unmanaged" | "endpoint";
 
+/*
+ * What the node DOES on the network, as opposed to what we know about it
+ * (`kind`). Derived server-side from the identity SNMP and the discovery
+ * protocols already report — sysObjectId, sysDescr, model/platform, and
+ * finally the hostname — because a map on which a router, a switch and a
+ * camera are the same circle cannot be read at a glance.
+ *
+ * "unknown" is a real answer, not a failure: guessing a role from thin
+ * evidence is worse than drawing a neutral node, so the classifier only
+ * commits when the evidence names a product family or says the word.
+ */
+export type NetworkTopologyDeviceRole =
+  | "router"
+  | "switch"
+  | "firewall"
+  | "wirelessAccessPoint"
+  | "loadBalancer"
+  | "server"
+  | "storage"
+  | "printer"
+  | "camera"
+  | "phone"
+  | "host"
+  | "unknown";
+
 export interface NetworkTopologyNode {
   // Device id for managed nodes; a synthetic "unmanaged:<key>" id otherwise.
   id: string;
@@ -34,6 +59,12 @@ export interface NetworkTopologyNode {
   status: NetworkTopologyNodeStatus;
   // Missing on older payloads — derive from isManaged.
   kind?: NetworkTopologyNodeKind | undefined;
+  /*
+   * What the node does on the network (router, switch, firewall, ...).
+   * Missing on older payloads, and "unknown" when the evidence did not
+   * name one — readers must treat both the same way.
+   */
+  role?: NetworkTopologyDeviceRole | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
   // Extra device identity for search and the detail panel (managed nodes).

package/Types/SerializableObjectDictionary.ts

@@ -40,46 +40,140 @@ import Phone from "./Phone";
 import Port from "./Port";
 import Version from "./Version";
 
+/*
+ * Every entry is a getter, not a direct reference.
+ *
+ * Three of these classes — Includes, IncludesAll and IncludesNone — import
+ * JSONFunctions so their fromJSON can deserialize the values inside them, and
+ * JSONFunctions imports this dictionary. That is a cycle, and with a plain
+ * object literal the entry a cycle passes through is captured as `undefined`:
+ * whichever of the two modules loads second sees the first only half
+ * initialized. Which of them loads first depends on the whole app's import
+ * graph, so `{"_type":"Includes","value":[...]}` deserialized into a real
+ * Includes in some entry points and stayed a plain object in others — and a
+ * plain object reaching TypeORM is a silently wrong query, not an error.
+ *
+ * A getter defers the lookup to the first property access, by which time every
+ * module has finished initializing.
+ */
 const SerializableObjectDictionary: Dictionary<any> = {
-  [ObjectType.Phone]: Phone,
-  [ObjectType.DateTime]: OneUptimeDate,
-  [ObjectType.ObjectID]: ObjectID,
-  [ObjectType.Name]: Name,
-  [ObjectType.EqualTo]: EqualTo,
-  [ObjectType.EqualToOrNull]: EqualToOrNull,
-  [ObjectType.MonitorSteps]: MonitorSteps,
-  [ObjectType.MonitorStep]: MonitorStep,
-  [ObjectType.MonitorCriteria]: MonitorCriteria,
-  [ObjectType.MonitorCriteriaInstance]: MonitorCriteriaInstance,
-  [ObjectType.NotEqual]: NotEqual,
-  [ObjectType.Email]: Email,
-  [ObjectType.Color]: Color,
-  [ObjectType.Domain]: Domain,
-  [ObjectType.Version]: Version,
-  [ObjectType.Route]: Route,
-  [ObjectType.URL]: URL,
-  [ObjectType.IP]: IP,
-  [ObjectType.Search]: Search,
-  [ObjectType.MultiSearch]: MultiSearch,
-  [ObjectType.GreaterThan]: GreaterThan,
-  [ObjectType.GreaterThanOrEqual]: GreaterThanOrEqual,
-  [ObjectType.LessThan]: LessThan,
-  [ObjectType.LessThanOrEqual]: LessThanOrEqual,
-  [ObjectType.LessThanOrNull]: LessThanOrNull,
-  [ObjectType.GreaterThanOrNull]: GreaterThanOrNull,
-  [ObjectType.Port]: Port,
-  [ObjectType.Hostname]: Hostname,
-  [ObjectType.HashedString]: HashedString,
-  [ObjectType.InBetween]: InBetween,
-  [ObjectType.Includes]: Includes,
-  [ObjectType.IncludesAll]: IncludesAll,
-  [ObjectType.IncludesNone]: IncludesNone,
-  [ObjectType.StartsWith]: StartsWith,
-  [ObjectType.EndsWith]: EndsWith,
-  [ObjectType.NotContains]: NotContains,
-  [ObjectType.NotNull]: NotNull,
-  [ObjectType.IsNull]: IsNull,
-  [ObjectType.Recurring]: Recurring,
+  get [ObjectType.Phone](): any {
+    return Phone;
+  },
+  get [ObjectType.DateTime](): any {
+    return OneUptimeDate;
+  },
+  get [ObjectType.ObjectID](): any {
+    return ObjectID;
+  },
+  get [ObjectType.Name](): any {
+    return Name;
+  },
+  get [ObjectType.EqualTo](): any {
+    return EqualTo;
+  },
+  get [ObjectType.EqualToOrNull](): any {
+    return EqualToOrNull;
+  },
+  get [ObjectType.MonitorSteps](): any {
+    return MonitorSteps;
+  },
+  get [ObjectType.MonitorStep](): any {
+    return MonitorStep;
+  },
+  get [ObjectType.MonitorCriteria](): any {
+    return MonitorCriteria;
+  },
+  get [ObjectType.MonitorCriteriaInstance](): any {
+    return MonitorCriteriaInstance;
+  },
+  get [ObjectType.NotEqual](): any {
+    return NotEqual;
+  },
+  get [ObjectType.Email](): any {
+    return Email;
+  },
+  get [ObjectType.Color](): any {
+    return Color;
+  },
+  get [ObjectType.Domain](): any {
+    return Domain;
+  },
+  get [ObjectType.Version](): any {
+    return Version;
+  },
+  get [ObjectType.Route](): any {
+    return Route;
+  },
+  get [ObjectType.URL](): any {
+    return URL;
+  },
+  get [ObjectType.IP](): any {
+    return IP;
+  },
+  get [ObjectType.Search](): any {
+    return Search;
+  },
+  get [ObjectType.MultiSearch](): any {
+    return MultiSearch;
+  },
+  get [ObjectType.GreaterThan](): any {
+    return GreaterThan;
+  },
+  get [ObjectType.GreaterThanOrEqual](): any {
+    return GreaterThanOrEqual;
+  },
+  get [ObjectType.LessThan](): any {
+    return LessThan;
+  },
+  get [ObjectType.LessThanOrEqual](): any {
+    return LessThanOrEqual;
+  },
+  get [ObjectType.LessThanOrNull](): any {
+    return LessThanOrNull;
+  },
+  get [ObjectType.GreaterThanOrNull](): any {
+    return GreaterThanOrNull;
+  },
+  get [ObjectType.Port](): any {
+    return Port;
+  },
+  get [ObjectType.Hostname](): any {
+    return Hostname;
+  },
+  get [ObjectType.HashedString](): any {
+    return HashedString;
+  },
+  get [ObjectType.InBetween](): any {
+    return InBetween;
+  },
+  get [ObjectType.Includes](): any {
+    return Includes;
+  },
+  get [ObjectType.IncludesAll](): any {
+    return IncludesAll;
+  },
+  get [ObjectType.IncludesNone](): any {
+    return IncludesNone;
+  },
+  get [ObjectType.StartsWith](): any {
+    return StartsWith;
+  },
+  get [ObjectType.EndsWith](): any {
+    return EndsWith;
+  },
+  get [ObjectType.NotContains](): any {
+    return NotContains;
+  },
+  get [ObjectType.NotNull](): any {
+    return NotNull;
+  },
+  get [ObjectType.IsNull](): any {
+    return IsNull;
+  },
+  get [ObjectType.Recurring](): any {
+    return Recurring;
+  },
 };
 
 export default SerializableObjectDictionary;