@oneuptime/common 14.0.6 → 14.0.8

package/Models/DatabaseModels/Incident.ts

@@ -23,6 +23,7 @@ import IoTFleet from "./IoTFleet";
 import DockerSwarmCluster from "./DockerSwarmCluster";
 import Service from "./Service";
 import ServiceLevelObjective from "./ServiceLevelObjective";
+import StatusPage from "./StatusPage";
 import User from "./User";
 import File from "./File";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -1947,6 +1948,37 @@ export default class Incident extends BaseModel {
   })
   public subscriberNotificationStatusMessage?: string = undefined;
 
+  /*
+   * When a subscriber job last claimed the 'incident created' notification
+   * (SubscriberNotificationClaim), which the sweeper
+   * (StatusPageSubscriber:TimeoutStuckNotifications) times a notification
+   * still In progress from. Not updatedAt: other code writes this row on a
+   * schedule while the incident is open - the owners' reminders, state
+   * changes, scope and field edits - so updatedAt could keep an interrupted
+   * send from ever looking stuck, and Retry, Resend and the added-pages
+   * notification all wait for it to settle. Written by the claim only;
+   * nobody reads or writes it through the API.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    computed: true,
+    hideColumnInDocumentation: true,
+    required: false,
+    type: TableColumnType.Date,
+    title: "Subscriber Notification Claimed At on Incident Created",
+    description:
+      "When a subscriber notification job last started sending the notification that this incident was created.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public subscriberNotificationClaimedAtOnIncidentCreated?: Date = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
@@ -2036,6 +2068,38 @@ export default class Incident extends BaseModel {
   public subscriberNotificationStatusMessageOnPostmortemPublished?: string =
     undefined;
 
+  /*
+   * When a subscriber job last claimed the postmortem notification
+   * (SubscriberNotificationClaim), which the sweeper
+   * (StatusPageSubscriber:TimeoutStuckNotifications) times a notification
+   * still In progress from. Not updatedAt: other code writes this row on a
+   * schedule while the incident is open - the owners' reminders, state
+   * changes, scope and field edits - so updatedAt could keep an interrupted
+   * send from ever looking stuck, and Retry, Resend and the added-pages
+   * notification all wait for it to settle. Written by the claim only;
+   * nobody reads or writes it through the API.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    computed: true,
+    hideColumnInDocumentation: true,
+    required: false,
+    type: TableColumnType.Date,
+    title: "Subscriber Notification Claimed At on Postmortem Published",
+    description:
+      "When a subscriber notification job last started sending the notification about this incident's postmortem.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public subscriberNotificationClaimedAtOnPostmortemPublished?: Date =
+    undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
@@ -2104,7 +2168,8 @@ export default class Incident extends BaseModel {
     required: false,
     type: TableColumnType.JSON,
     title: "Custom Fields",
-    description: "Custom Fields on this resource.",
+    description:
+      "The incident's custom field values, keyed by each incident custom field's name. When a user or an API key creates or updates an incident, each value it sets or changes must fit its field - a number for a Number field, true or false for a Boolean, one of the options for a Dropdown, and so on - or the request is refused. Values left as they were, keys that are not the name of a field and empty values are not checked. Required on Create is not enforced here: it applies to the dashboard's Declare Incident form only.",
   })
   @Column({
     type: ColumnType.JSON,
@@ -2882,6 +2947,207 @@ export default class Incident extends BaseModel {
   })
   public isVisibleOnStatusPage?: boolean = undefined;
 
+  /*
+   * The status pages this incident is limited to. An incident reaches a
+   * status page through its monitors: every page that lists one of them shows
+   * it and notifies its subscribers. So a monitor shared by ten site pages
+   * used to tell all ten sites about an outage that affects two. Picking
+   * pages here narrows that: a scoped incident shows on, and notifies, only
+   * the selected pages among those its monitors already reach (the two sets
+   * intersect - a scope never puts an incident on a page that does not list
+   * its monitors). Empty means unscoped: every page its monitors reach, as
+   * before. Status pages that only show scoped incidents
+   * (StatusPage.onlyShowScopedIncidents) never show an unscoped one.
+   *
+   * Shaped like ScheduledMaintenance.statusPages, with the access control of
+   * the monitors list above. Whether an incident is scoped is kept separately
+   * in isScopedToStatusPages, so the status page queries can filter on it.
+   *
+   * Like the monitors list, the pages are part of the incident: anyone who
+   * can read it sees their names (StatusPage.name is readable on a relation
+   * query), whether or not they can read those status pages. Picking a page
+   * needs read access to it (StatusPageReadAccess).
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.CreateProjectIncident,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadProjectIncident,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.EditProjectIncident,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: StatusPage,
+    title: "Status Pages",
+    description:
+      "Limit this incident to these status pages. When set, the incident is shown on, and notifies the subscribers of, only these pages among the status pages that list its monitors. Leave empty to reach every status page that lists its monitors.",
+  })
+  @ManyToMany(
+    () => {
+      return StatusPage;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentStatusPage",
+    inverseJoinColumn: {
+      name: "statusPageId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentId",
+      referencedColumnName: "_id",
+    },
+  })
+  public statusPages?: Array<StatusPage> = undefined;
+
+  /*
+   * Whether this incident is limited to the status pages in statusPages. The
+   * status page queries split on it (unscoped incidents by monitor, scoped
+   * ones by monitor AND page), which keeps the scope in SQL rather than in a
+   * post-filter that a LIMIT could silently cut.
+   *
+   * IncidentService derives it from writes to statusPages and ignores any
+   * value a client sends. It is deliberately never recomputed when join rows
+   * disappear: deleting the only status page an incident is scoped to
+   * cascades its join row away, and the incident stays scoped - to nothing -
+   * so it is hidden everywhere rather than widened to every page its monitors
+   * reach.
+   *
+   * Computed, so a client cannot set it on create. Its update access control
+   * matches statusPages all the same: the service writes it into the caller's
+   * own update, and the column check that runs after the hook exempts computed
+   * columns only on create.
+   *
+   * Not indexed. It is false on nearly every row, so an index cannot help the
+   * unscoped half of those queries, and the scoped half reaches its incidents
+   * through the IncidentStatusPage join table's statusPageId index. Building
+   * one would also have held the lock of the migration's ALTER TABLE on
+   * Incident - reads included - for as long as it took on a large table.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.CreateProjectIncident,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadProjectIncident,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.EditProjectIncident,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    computed: true,
+    hideColumnInDocumentation: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Scoped To Status Pages",
+    description:
+      "Whether this incident is limited to the status pages in Status Pages. Derived from Status Pages; any value sent for it is ignored.",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isScopedToStatusPages?: boolean = undefined;
+
+  /*
+   * The ids of the status pages whose subscribers were sent this incident's
+   * 'created' notification. A status page added to the scope later can then
+   * be told exactly once, without telling the pages that already heard.
+   *
+   * The Incident:SendNotificationToSubscribers job writes it as root, once per
+   * send, with the status it settles on. It is computed and never taken from
+   * a client; its update access control matches
+   * subscriberNotificationStatusOnIncidentCreated so IncidentService can write
+   * it inside the caller's own update: it empties it when the update resends
+   * the notification to every page (the status set back to Pending), and when
+   * pages are added to an incident whose notification was skipped, it lists
+   * the pages the incident was limited to before, which were deliberately not
+   * told, so only the added ones are (see IncidentScopeAddedPagesNotification).
+   *
+   * Null means no send has settled since the column was added: an incident
+   * whose notification went out before then has no record, and pages added to
+   * it are not sent the notification again.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadProjectIncident,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.EditProjectIncident,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    computed: true,
+    hideColumnInDocumentation: true,
+    type: TableColumnType.JSON,
+    title: "Status Pages Notified On Creation",
+    description:
+      "IDs of the status pages whose subscribers were sent the notification that this incident was created.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public statusPagesNotifiedOnCreation?: Array<string> = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/IncidentCustomField.ts

@@ -68,6 +68,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 @Entity({
   name: "IncidentCustomField",
 })
+@Index(["projectId", "variableKey"], { unique: true })
 export default class IncidentCustomField extends BaseModel {
   @ColumnAccessControl({
     create: [
@@ -360,6 +361,207 @@ export default class IncidentCustomField extends BaseModel {
   })
   public mapFromCustomFieldName?: string = undefined;
 
+  /*
+   * The four columns below are incident-only on purpose: the other eight
+   * custom field definition tables do not have them, and the shared settings
+   * page and Custom Fields card offer them only for a definition model that
+   * has the column (DatabaseBaseModel.hasColumn).
+   */
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentCustomField,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Required on Create",
+    description:
+      "When on, an incident declared from the dashboard cannot be created until this field is filled in (a Boolean field must be ticked). It applies only to fields shown on create. Incidents created by monitors, the API, Slack, Microsoft Teams or AI can leave it empty, and it stays optional when an incident is edited later.",
+    defaultValue: false,
+    example: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isRequiredOnCreate?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentCustomField,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Order",
+    description:
+      "Where this field appears among the incident's custom fields, lowest first. Fields with no order come after the ones that have one.",
+    example: 1,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+  })
+  public sortOrder?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentCustomField,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Show on Create",
+    description:
+      "When on, this field is asked for in a Details step when an incident is declared from the dashboard, and incident templates can fill it in.",
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public showOnCreate?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentCustomField,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentCustomField,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentCustomField,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Include in Subscriber Notifications",
+    description:
+      "When on, this field and its value appear in the messages status page subscribers get about an incident: the default email, Slack and Microsoft Teams messages, and webhooks (under customFields, by the field's template variable key). The default SMS is kept short and leaves it out. Subscribers are usually people outside your team, so turn this on only for fields that are safe to share with them.",
+    defaultValue: false,
+    example: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public includeInSubscriberNotifications?: boolean = undefined;
+
+  /*
+   * The key templates reach this field by, {{customFields.<variableKey>}}.
+   * Made from the name when the field is created
+   * (IncidentCustomFieldService.onBeforeCreate, with
+   * generateCustomFieldVariableKey) and never changed afterwards, so renaming
+   * a field does not break the templates that use it.
+   *
+   * Computed with an empty create and update access control: whatever a
+   * client sends for it is replaced on create and dropped on update. Unique
+   * per project, which the index below holds even against two fields created
+   * at the same moment. Nullable only so the column could be added to a table
+   * that already had rows; the migration that added it gave every one a key.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentCustomField,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    computed: true,
+    required: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Template Variable Key",
+    description:
+      "The key this field is reached by in templates, as {{customFields.<key>}}. Made from the field's name when it is created - lowercase letters, digits and underscores, with _2, _3 and so on added when another field already has it - and never changed afterwards, so renaming the field does not break templates that use it.",
+    example: "expected_resolution",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public variableKey?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/IncidentEpisode.ts

@@ -1693,6 +1693,36 @@ export default class IncidentEpisode extends BaseModel {
   })
   public subscriberNotificationStatusMessage?: string = undefined;
 
+  /*
+   * When a subscriber job last claimed the 'episode created' notification
+   * (SubscriberNotificationClaim), which the sweeper
+   * (StatusPageSubscriber:TimeoutStuckNotifications) times a notification
+   * still In progress from. Not updatedAt: other code writes this row all
+   * the time while it is open - incidents joining it, its severity and
+   * state, edits - so updatedAt could keep an interrupted send from ever
+   * looking stuck, and Retry waits for it to settle. Written by the claim
+   * only; nobody reads or writes it through the API.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    computed: true,
+    hideColumnInDocumentation: true,
+    required: false,
+    type: TableColumnType.Date,
+    title: "Subscriber Notification Claimed At on Episode Created",
+    description:
+      "When a subscriber notification job last started sending the notification that this episode was created.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public subscriberNotificationClaimedAtOnEpisodeCreated?: Date = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/IncidentTemplate.ts

@@ -10,6 +10,7 @@ import MonitorStatus from "./MonitorStatus";
 import OnCallDutyPolicy from "./OnCallDutyPolicy";
 import Project from "./Project";
 import Service from "./Service";
+import StatusPage from "./StatusPage";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Route from "../../Types/API/Route";
@@ -900,6 +901,129 @@ export default class IncidentTemplate extends BaseModel {
   })
   public onCallDutyPolicies?: Array<OnCallDutyPolicy> = undefined; // on-call duty policies affected by this incident template.
 
+  /*
+   * The status pages an incident declared from this template is limited to
+   * (see Incident.statusPages). A 'Region East outage' template can carry the
+   * East site pages, so declaring from it scopes the incident in one step.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.CreateIncidentTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.EditIncidentTemplate,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: StatusPage,
+    title: "Status Pages",
+    description:
+      "Limit incidents declared from this template to these status pages. Leave empty to reach every status page that lists the incident's monitors.",
+  })
+  @ManyToMany(
+    () => {
+      return StatusPage;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentTemplateStatusPage",
+    inverseJoinColumn: {
+      name: "statusPageId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentTemplateId",
+      referencedColumnName: "_id",
+    },
+  })
+  public statusPages?: Array<StatusPage> = undefined;
+
+  /*
+   * Whether this template limits the incidents declared from it to status
+   * pages - kept apart from statusPages for the same reason as
+   * Incident.isScopedToStatusPages. Deleting a status page cascades its row
+   * in IncidentTemplateStatusPage away, and a template whose every page was
+   * deleted would otherwise look unscoped, so its incidents would reach
+   * every status page that lists their monitors - exactly the audience the
+   * template was set up to avoid. With the flag, IncidentService declares
+   * such an incident scoped to nothing (hidden from every status page), and
+   * the dashboard warns about the template.
+   *
+   * IncidentTemplateService derives it from writes to statusPages and ignores
+   * any value a client sends; it is never recomputed when join rows
+   * disappear. Computed, so a client cannot set it on create; its update
+   * access control matches statusPages because the service writes it into
+   * the caller's own update.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.CreateIncidentTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.EditIncidentTemplate,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    computed: true,
+    hideColumnInDocumentation: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Scoped To Status Pages",
+    description:
+      "Whether incidents declared from this template are limited to the status pages in Status Pages. Derived from Status Pages; any value sent for it is ignored.",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isScopedToStatusPages?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
@@ -1252,7 +1376,8 @@ export default class IncidentTemplate extends BaseModel {
     required: false,
     type: TableColumnType.JSON,
     title: "Custom Fields",
-    description: "Custom Fields on this resource.",
+    description:
+      "The custom field values incidents declared from this template start with, keyed by each incident custom field's name. They are merged one field at a time under the values the request or the Declare Incident form supplies.",
     example: {
       priority: "high",
       category: "infrastructure",