@overmap-ai/core 1.0.78-attachment-model-improvements.0 → 1.0.78-attachment-model-improvements.1

package/dist/overmap-core.js

@@ -254,7 +254,7 @@ function M_(t) {
 function Dc(t) {
   return typeof t == "string" && t.startsWith("blob:");
 }
-function Je(t) {
+function C(t) {
   const s = t.name;
   return s.includes(".") ? s.split(".").pop() : "";
 }
@@ -402,7 +402,7 @@ class B_ {
 const A = (
   // oxlint-disable-next-line no-explicit-any REASON: Need for generic args
   (t) => (...s) => (e) => t(e, ...s)
-), C = R((t) => t.uuid), ts = {
+), L = R((t) => t.uuid), ts = {
   instances: {}
 }, Ii = F({
   name: "agents",
@@ -412,15 +412,15 @@ const A = (
     (s) => Object.assign(s, ts)
   ),
   reducers: {
-    initializeConversations: C.initialize,
-    addConversation: C.addOne,
-    addConversations: C.addMany,
-    setConversation: C.setOne,
-    setConversations: C.setMany,
-    updateConversation: C.updateOne,
-    updateConversations: C.updateMany,
-    deleteConversation: C.deleteOne,
-    deleteConversations: C.deleteMany
+    initializeConversations: L.initialize,
+    addConversation: L.addOne,
+    addConversations: L.addMany,
+    setConversation: L.setOne,
+    setConversations: L.setMany,
+    updateConversation: L.updateOne,
+    updateConversations: L.updateMany,
+    deleteConversation: L.deleteOne,
+    deleteConversations: L.deleteMany
   }
 }), {
   initializeConversations: Gc,
@@ -440,7 +440,7 @@ const A = (
     [_i, (t, s) => s],
     (t, s) => t[s]
   )
-), Zc = Ii.reducer, L = R((t) => t.uuid), ss = {
+), Zc = Ii.reducer, N = R((t) => t.uuid), ss = {
   instances: {}
 }, bi = F({
   name: "assetAttachments",
@@ -450,15 +450,15 @@ const A = (
     (s) => Object.assign(s, ss)
   ),
   reducers: {
-    initializeAssetAttachments: L.initialize,
-    addAssetAttachment: L.addOne,
-    addAssetAttachments: L.addMany,
-    setAssetAttachment: L.setOne,
-    setAssetAttachments: L.setMany,
-    updateAssetAttachment: L.updateOne,
-    updateAssetAttachments: L.updateMany,
-    deleteAssetAttachment: L.deleteOne,
-    deleteAssetAttachments: L.deleteMany
+    initializeAssetAttachments: N.initialize,
+    addAssetAttachment: N.addOne,
+    addAssetAttachments: N.addMany,
+    setAssetAttachment: N.setOne,
+    setAssetAttachments: N.setMany,
+    updateAssetAttachment: N.updateOne,
+    updateAssetAttachments: N.updateMany,
+    deleteAssetAttachment: N.deleteOne,
+    deleteAssetAttachments: N.deleteMany
   }
 }), {
   initializeAssetAttachments: Jc,
@@ -480,7 +480,7 @@ const A = (
   })
 ), rr = A(
   m([Fi, (t, s) => s], (t, s) => T(t.filter(({ asset: e }) => s === e)))
-), dr = bi.reducer, N = R(({ uuid: t }) => t), is = {
+), dr = bi.reducer, H = R(({ uuid: t }) => t), is = {
   instances: {}
 }, Mi = F({
   name: "assetProcedureTypeAttachments",
@@ -490,15 +490,15 @@ const A = (
     (s) => Object.assign(s, is)
   ),
   reducers: {
-    initializeAssetProcedureTypeAttachments: N.initialize,
-    addAssetProcedureTypeAttachment: N.addOne,
-    addAssetProcedureTypeAttachments: N.addMany,
-    setAssetProcedureTypeAttachment: N.setOne,
-    setAssetProcedureTypeAttachments: N.setMany,
-    updateAssetProcedureTypeAttachment: N.updateOne,
-    updateAssetProcedureTypeAttachments: N.updateMany,
-    deleteAssetProcedureTypeAttachment: N.deleteOne,
-    deleteAssetProcedureTypeAttachments: N.deleteMany
+    initializeAssetProcedureTypeAttachments: H.initialize,
+    addAssetProcedureTypeAttachment: H.addOne,
+    addAssetProcedureTypeAttachments: H.addMany,
+    setAssetProcedureTypeAttachment: H.setOne,
+    setAssetProcedureTypeAttachments: H.setMany,
+    updateAssetProcedureTypeAttachment: H.updateOne,
+    updateAssetProcedureTypeAttachments: H.updateMany,
+    deleteAssetProcedureTypeAttachment: H.deleteOne,
+    deleteAssetProcedureTypeAttachments: H.deleteMany
   }
 }), {
   initializeAssetProcedureTypeAttachments: or,
@@ -523,7 +523,7 @@ const A = (
     [Ri, (t, s) => s],
     (t, s) => T(t.filter(({ asset_procedure_type: e }) => s === e))
   )
-), H = R(({ uuid: t }) => t), ns = {
+), G = R(({ uuid: t }) => t), ns = {
   instances: {}
 }, wi = F({
   name: "assetProcedureTypeFieldsAttachments",
@@ -533,15 +533,15 @@ const A = (
     (s) => Object.assign(s, ns)
   ),
   reducers: {
-    initializeAssetProcedureTypeFieldsAttachments: H.initialize,
-    addAssetProcedureTypeFieldsAttachment: H.addOne,
-    addAssetProcedureTypeFieldsAttachments: H.addMany,
-    setAssetProcedureTypeFieldsAttachment: H.setOne,
-    setAssetProcedureTypeFieldsAttachments: H.setMany,
-    updateAssetProcedureTypeFieldsAttachment: H.updateOne,
-    updateAssetProcedureTypeFieldsAttachments: H.updateMany,
-    deleteAssetProcedureTypeFieldsAttachment: H.deleteOne,
-    deleteAssetProcedureTypeFieldsAttachments: H.deleteMany
+    initializeAssetProcedureTypeFieldsAttachments: G.initialize,
+    addAssetProcedureTypeFieldsAttachment: G.addOne,
+    addAssetProcedureTypeFieldsAttachments: G.addMany,
+    setAssetProcedureTypeFieldsAttachment: G.setOne,
+    setAssetProcedureTypeFieldsAttachments: G.setMany,
+    updateAssetProcedureTypeFieldsAttachment: G.updateOne,
+    updateAssetProcedureTypeFieldsAttachments: G.updateMany,
+    deleteAssetProcedureTypeFieldsAttachment: G.deleteOne,
+    deleteAssetProcedureTypeFieldsAttachments: G.deleteMany
   }
 }), {
   initializeAssetProcedureTypeFieldsAttachments: _r,
@@ -569,7 +569,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), G = R(({ uuid: t }) => t), as = {
+), W = R(({ uuid: t }) => t), as = {
   instances: {}
 }, vi = F({
   name: "assetProcedureTypeFields",
@@ -579,15 +579,15 @@ const A = (
     (s) => Object.assign(s, as)
   ),
   reducers: {
-    initializeAssetProcedureTypeFields: G.initialize,
-    addAssetProcedureTypeFields: G.addOne,
-    addAssetProcedureTypeFieldsMany: G.addMany,
-    setAssetProcedureTypeFields: G.setOne,
-    setAssetProcedureTypeFieldsMany: G.setMany,
-    updateAssetProcedureTypeFields: G.updateOne,
-    updateAssetProcedureTypeFieldsMany: G.updateMany,
-    deleteAssetProcedureTypeFields: G.deleteOne,
-    deleteAssetProcedureTypeFieldsMany: G.deleteMany
+    initializeAssetProcedureTypeFields: W.initialize,
+    addAssetProcedureTypeFields: W.addOne,
+    addAssetProcedureTypeFieldsMany: W.addMany,
+    setAssetProcedureTypeFields: W.setOne,
+    setAssetProcedureTypeFieldsMany: W.setMany,
+    updateAssetProcedureTypeFields: W.updateOne,
+    updateAssetProcedureTypeFieldsMany: W.updateMany,
+    deleteAssetProcedureTypeFields: W.deleteOne,
+    deleteAssetProcedureTypeFieldsMany: W.deleteMany
   }
 }), {
   initializeAssetProcedureTypeFields: jr,
@@ -620,7 +620,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), W = R(({ uuid: t }) => t), cs = {
+), K = R(({ uuid: t }) => t), cs = {
   instances: {}
 }, ki = F({
   name: "assetProcedureTypeFieldValuesAttachments",
@@ -630,15 +630,15 @@ const A = (
     (s) => Object.assign(s, cs)
   ),
   reducers: {
-    initializeAssetProcedureTypeFieldValuesAttachments: W.initialize,
-    addAssetProcedureTypeFieldValuesAttachment: W.addOne,
-    addAssetProcedureTypeFieldValuesAttachments: W.addMany,
-    setAssetProcedureTypeFieldValuesAttachment: W.setOne,
-    setAssetProcedureTypeFieldValuesAttachments: W.setMany,
-    updateAssetProcedureTypeFieldValuesAttachment: W.updateOne,
-    updateAssetProcedureTypeFieldValuesAttachments: W.updateMany,
-    deleteAssetProcedureTypeFieldValuesAttachment: W.deleteOne,
-    deleteAssetProcedureTypeFieldValuesAttachments: W.deleteMany
+    initializeAssetProcedureTypeFieldValuesAttachments: K.initialize,
+    addAssetProcedureTypeFieldValuesAttachment: K.addOne,
+    addAssetProcedureTypeFieldValuesAttachments: K.addMany,
+    setAssetProcedureTypeFieldValuesAttachment: K.setOne,
+    setAssetProcedureTypeFieldValuesAttachments: K.setMany,
+    updateAssetProcedureTypeFieldValuesAttachment: K.updateOne,
+    updateAssetProcedureTypeFieldValuesAttachments: K.updateMany,
+    deleteAssetProcedureTypeFieldValuesAttachment: K.deleteOne,
+    deleteAssetProcedureTypeFieldValuesAttachments: K.deleteMany
   }
 }), {
   initializeAssetProcedureTypeFieldValuesAttachments: Kr,
@@ -669,7 +669,7 @@ const A = (
     [ji, (t, s) => s],
     (t, s) => T(t.filter((e) => e.field_values === s))
   )
-), K = R(({ uuid: t }) => t), rs = {
+), Y = R(({ uuid: t }) => t), rs = {
   instances: {}
 }, Vi = F({
   name: "assetProcedureTypeFieldValues",
@@ -679,15 +679,15 @@ const A = (
     (s) => Object.assign(s, rs)
   ),
   reducers: {
-    initializeAssetProcedureTypeFieldValues: K.initialize,
-    addAssetProcedureTypeFieldValues: K.addOne,
-    addAssetProcedureTypeFieldValuesMany: K.addMany,
-    setAssetProcedureTypeFieldValues: K.setOne,
-    setAssetProcedureTypeFieldValuesMany: K.setMany,
-    updateAssetProcedureTypeFieldValues: K.updateOne,
-    updateAssetProcedureTypeFieldValuesMany: K.updateMany,
-    deleteAssetProcedureTypeFieldValues: K.deleteOne,
-    deleteAssetProcedureTypeFieldValuesMany: K.deleteMany
+    initializeAssetProcedureTypeFieldValues: Y.initialize,
+    addAssetProcedureTypeFieldValues: Y.addOne,
+    addAssetProcedureTypeFieldValuesMany: Y.addMany,
+    setAssetProcedureTypeFieldValues: Y.setOne,
+    setAssetProcedureTypeFieldValuesMany: Y.setMany,
+    updateAssetProcedureTypeFieldValues: Y.updateOne,
+    updateAssetProcedureTypeFieldValuesMany: Y.updateMany,
+    deleteAssetProcedureTypeFieldValues: Y.deleteOne,
+    deleteAssetProcedureTypeFieldValuesMany: Y.deleteMany
   }
 }), {
   initializeAssetProcedureTypeFieldValues: cd,
@@ -720,7 +720,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), Y = R(
+), Z = R(
   ({ uuid: t }) => t
 ), ds = {
   instances: {}
@@ -732,15 +732,15 @@ const A = (
     (s) => Object.assign(s, ds)
   ),
   reducers: {
-    initializeAssetProcedures: Y.initialize,
-    addAssetProcedure: Y.addOne,
-    addAssetProcedures: Y.addMany,
-    setAssetProcedure: Y.setOne,
-    setAssetProcedures: Y.setMany,
-    updateAssetProcedure: Y.updateOne,
-    updateAssetProcedures: Y.updateMany,
-    deleteAssetProcedure: Y.deleteOne,
-    deleteAssetProcedures: Y.deleteMany
+    initializeAssetProcedures: Z.initialize,
+    addAssetProcedure: Z.addOne,
+    addAssetProcedures: Z.addMany,
+    setAssetProcedure: Z.setOne,
+    setAssetProcedures: Z.setMany,
+    updateAssetProcedure: Z.updateOne,
+    updateAssetProcedures: Z.updateMany,
+    deleteAssetProcedure: Z.deleteOne,
+    deleteAssetProcedures: Z.deleteMany
   }
 }), {
   initializeAssetProcedures: Sd,
@@ -766,7 +766,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), Z = R((t) => t.uuid), os = {
+), J = R((t) => t.uuid), os = {
   instances: {}
 }, Di = F({
   name: "assetProcedureTypes",
@@ -776,15 +776,15 @@ const A = (
     (s) => Object.assign(s, os)
   ),
   reducers: {
-    initializeAssetProcedureTypes: Z.initialize,
-    addAssetProcedureType: Z.addOne,
-    addAssetProcedureTypes: Z.addMany,
-    setAssetProcedureType: Z.setOne,
-    setAssetProcedureTypes: Z.setMany,
-    updateAssetProcedureType: Z.updateOne,
-    updateAssetProcedureTypes: Z.updateMany,
-    deleteAssetProcedureType: Z.deleteOne,
-    deleteAssetProcedureTypes: Z.deleteMany
+    initializeAssetProcedureTypes: J.initialize,
+    addAssetProcedureType: J.addOne,
+    addAssetProcedureTypes: J.addMany,
+    setAssetProcedureType: J.setOne,
+    setAssetProcedureTypes: J.setMany,
+    updateAssetProcedureType: J.updateOne,
+    updateAssetProcedureTypes: J.updateMany,
+    deleteAssetProcedureType: J.deleteOne,
+    deleteAssetProcedureTypes: J.deleteMany
   }
 }), {
   initializeAssetProcedureTypes: vd,
@@ -812,7 +812,7 @@ const A = (
     [Ui, (t, s) => s],
     (t, s) => T(t.filter((e) => e.organization === s))
   )
-), J = R((t) => t.uuid), us = {
+), X = R((t) => t.uuid), us = {
   instances: {}
 }, Ci = F({
   name: "assetProcedureStepFieldsAttachments",
@@ -822,15 +822,15 @@ const A = (
     (s) => Object.assign(s, us)
   ),
   reducers: {
-    initializeAssetProcedureStepFieldsAttachments: J.initialize,
-    addAssetProcedureStepFieldsAttachment: J.addOne,
-    addAssetProcedureStepFieldsAttachments: J.addMany,
-    setAssetProcedureStepFieldsAttachment: J.setOne,
-    setAssetProcedureStepFieldsAttachments: J.setMany,
-    updateAssetProcedureStepFieldsAttachment: J.updateOne,
-    updateAssetProcedureStepFieldsAttachments: J.updateMany,
-    deleteAssetProcedureStepFieldsAttachment: J.deleteOne,
-    deleteAssetProcedureStepFieldsAttachments: J.deleteMany
+    initializeAssetProcedureStepFieldsAttachments: X.initialize,
+    addAssetProcedureStepFieldsAttachment: X.addOne,
+    addAssetProcedureStepFieldsAttachments: X.addMany,
+    setAssetProcedureStepFieldsAttachment: X.setOne,
+    setAssetProcedureStepFieldsAttachments: X.setMany,
+    updateAssetProcedureStepFieldsAttachment: X.updateOne,
+    updateAssetProcedureStepFieldsAttachments: X.updateMany,
+    deleteAssetProcedureStepFieldsAttachment: X.deleteOne,
+    deleteAssetProcedureStepFieldsAttachments: X.deleteMany
   }
 }), {
   initializeAssetProcedureStepFieldsAttachments: Nd,
@@ -858,7 +858,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), so = Ci.reducer, X = R((t) => t.uuid), ls = {
+), so = Ci.reducer, Q = R((t) => t.uuid), ls = {
   instances: {}
 }, Ni = F({
   name: "assetProcedureStepFields",
@@ -868,15 +868,15 @@ const A = (
     (s) => Object.assign(s, ls)
   ),
   reducers: {
-    initializeAssetProcedureStepFields: X.initialize,
-    addAssetProcedureStepFields: X.addOne,
-    addAssetProcedureStepFieldsMany: X.addMany,
-    setAssetProcedureStepFields: X.setOne,
-    setAssetProcedureStepFieldsMany: X.setMany,
-    updateAssetProcedureStepFields: X.updateOne,
-    updateAssetProcedureStepFieldsMany: X.updateMany,
-    deleteAssetProcedureStepFields: X.deleteOne,
-    deleteAssetProcedureStepFieldsMany: X.deleteMany
+    initializeAssetProcedureStepFields: Q.initialize,
+    addAssetProcedureStepFields: Q.addOne,
+    addAssetProcedureStepFieldsMany: Q.addMany,
+    setAssetProcedureStepFields: Q.setOne,
+    setAssetProcedureStepFieldsMany: Q.setMany,
+    updateAssetProcedureStepFields: Q.updateOne,
+    updateAssetProcedureStepFieldsMany: Q.updateMany,
+    deleteAssetProcedureStepFields: Q.deleteOne,
+    deleteAssetProcedureStepFieldsMany: Q.deleteMany
   }
 }), {
   initializeAssetProcedureStepFields: io,
@@ -919,7 +919,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), yo = Ni.reducer, Q = R((t) => t.uuid), hs = {
+), yo = Ni.reducer, ee = R((t) => t.uuid), hs = {
   instances: {}
 }, Gi = F({
   name: "assetProcedureStepFieldValuesAttachments",
@@ -929,15 +929,15 @@ const A = (
     (s) => Object.assign(s, hs)
   ),
   reducers: {
-    initializeAssetProcedureStepFieldValuesAttachments: Q.initialize,
-    addAssetProcedureStepFieldValuesAttachment: Q.addOne,
-    addAssetProcedureStepFieldValuesAttachments: Q.addMany,
-    setAssetProcedureStepFieldValuesAttachment: Q.setOne,
-    setAssetProcedureStepFieldValuesAttachments: Q.setMany,
-    updateAssetProcedureStepFieldValuesAttachment: Q.updateOne,
-    updateAssetProcedureStepFieldValuesAttachments: Q.updateMany,
-    deleteAssetProcedureStepFieldValuesAttachment: Q.deleteOne,
-    deleteAssetProcedureStepFieldValuesAttachments: Q.deleteMany
+    initializeAssetProcedureStepFieldValuesAttachments: ee.initialize,
+    addAssetProcedureStepFieldValuesAttachment: ee.addOne,
+    addAssetProcedureStepFieldValuesAttachments: ee.addMany,
+    setAssetProcedureStepFieldValuesAttachment: ee.setOne,
+    setAssetProcedureStepFieldValuesAttachments: ee.setMany,
+    updateAssetProcedureStepFieldValuesAttachment: ee.updateOne,
+    updateAssetProcedureStepFieldValuesAttachments: ee.updateMany,
+    deleteAssetProcedureStepFieldValuesAttachment: ee.deleteOne,
+    deleteAssetProcedureStepFieldValuesAttachments: ee.deleteMany
   }
 }), {
   initializeAssetProcedureStepFieldValuesAttachments: fo,
@@ -968,7 +968,7 @@ const A = (
     [Yi, (t, s) => s],
     (t, s) => T(t.filter((e) => e.field_values === s))
   )
-), Mo = Gi.reducer, ee = R((t) => t.uuid), ps = {
+), Mo = Gi.reducer, te = R((t) => t.uuid), ps = {
   instances: {}
 }, Zi = F({
   name: "assetProcedureStepFieldValues",
@@ -978,15 +978,15 @@ const A = (
     (s) => Object.assign(s, ps)
   ),
   reducers: {
-    initializeAssetProcedureStepFieldValues: ee.initialize,
-    addAssetProcedureStepFieldValues: ee.addOne,
-    addAssetProcedureStepFieldValuesMany: ee.addMany,
-    setAssetProcedureStepFieldValues: ee.setOne,
-    setAssetProcedureStepFieldValuesMany: ee.setMany,
-    updateAssetProcedureStepFieldValues: ee.updateOne,
-    updateAssetProcedureStepFieldValuesMany: ee.updateMany,
-    deleteAssetProcedureStepFieldValues: ee.deleteOne,
-    deleteAssetProcedureStepFieldValuesMany: ee.deleteMany
+    initializeAssetProcedureStepFieldValues: te.initialize,
+    addAssetProcedureStepFieldValues: te.addOne,
+    addAssetProcedureStepFieldValuesMany: te.addMany,
+    setAssetProcedureStepFieldValues: te.setOne,
+    setAssetProcedureStepFieldValuesMany: te.setMany,
+    updateAssetProcedureStepFieldValues: te.updateOne,
+    updateAssetProcedureStepFieldValuesMany: te.updateMany,
+    deleteAssetProcedureStepFieldValues: te.deleteOne,
+    deleteAssetProcedureStepFieldValuesMany: te.deleteMany
   }
 }), {
   initializeAssetProcedureStepFieldValues: Ro,
@@ -1024,7 +1024,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), Do = Zi.reducer, te = R((t) => t.uuid), ms = {
+), Do = Zi.reducer, se = R((t) => t.uuid), ms = {
   instances: {}
 }, Ji = F({
   name: "assetProcedureSteps",
@@ -1034,15 +1034,15 @@ const A = (
     (s) => Object.assign(s, ms)
   ),
   reducers: {
-    initializeAssetProcedureSteps: te.initialize,
-    setAssetProcedureStep: te.setOne,
-    setAssetProcedureSteps: te.setMany,
-    addAssetProcedureStep: te.addOne,
-    addAssetProcedureSteps: te.addMany,
-    updateAssetProcedureStep: te.updateOne,
-    updateAssetProcedureSteps: te.updateMany,
-    deleteAssetProcedureStep: te.deleteOne,
-    deleteAssetProcedureSteps: te.deleteMany
+    initializeAssetProcedureSteps: se.initialize,
+    setAssetProcedureStep: se.setOne,
+    setAssetProcedureSteps: se.setMany,
+    addAssetProcedureStep: se.addOne,
+    addAssetProcedureSteps: se.addMany,
+    updateAssetProcedureStep: se.updateOne,
+    updateAssetProcedureSteps: se.updateMany,
+    deleteAssetProcedureStep: se.deleteOne,
+    deleteAssetProcedureSteps: se.deleteMany
   }
 }), {
   initializeAssetProcedureSteps: Uo,
@@ -1083,7 +1083,7 @@ const A = (
       return T(n);
     }
   )
-), se = R((t) => t.uuid), ys = {
+), ie = R((t) => t.uuid), ys = {
   instances: {}
 }, Qi = F({
   name: "assets",
@@ -1093,15 +1093,15 @@ const A = (
     (s) => Object.assign(s, ys)
   ),
   reducers: {
-    initializeAssets: se.initialize,
-    addAsset: se.addOne,
-    addAssets: se.addMany,
-    setAsset: se.setOne,
-    setAssets: se.setMany,
-    updateAsset: se.updateOne,
-    updateAssets: se.updateMany,
-    deleteAsset: se.deleteOne,
-    deleteAssets: se.deleteMany
+    initializeAssets: ie.initialize,
+    addAsset: ie.addOne,
+    addAssets: ie.addMany,
+    setAsset: ie.setOne,
+    setAssets: ie.setMany,
+    updateAsset: ie.updateOne,
+    updateAssets: ie.updateMany,
+    deleteAsset: ie.deleteOne,
+    deleteAssets: ie.deleteMany
   }
 }), {
   initializeAssets: eu,
@@ -1122,7 +1122,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), lu = Qi.reducer, ie = R((t) => t.uuid), fs = {
+), lu = Qi.reducer, ne = R((t) => t.uuid), fs = {
   instances: {}
 }, sn = F({
   name: "assetStageCompletions",
@@ -1132,15 +1132,15 @@ const A = (
     (s) => Object.assign(s, fs)
   ),
   reducers: {
-    initializeAssetStageCompletions: ie.initialize,
-    addAssetStageCompletion: ie.addOne,
-    addAssetStageCompletions: ie.addMany,
-    setAssetStageCompletion: ie.setOne,
-    setAssetStageCompletions: ie.setMany,
-    updateAssetStageCompletion: ie.updateOne,
-    updateAssetStageCompletions: ie.updateMany,
-    deleteAssetStageCompletion: ie.deleteOne,
-    deleteAssetStageCompletions: ie.deleteMany
+    initializeAssetStageCompletions: ne.initialize,
+    addAssetStageCompletion: ne.addOne,
+    addAssetStageCompletions: ne.addMany,
+    setAssetStageCompletion: ne.setOne,
+    setAssetStageCompletions: ne.setMany,
+    updateAssetStageCompletion: ne.updateOne,
+    updateAssetStageCompletions: ne.updateMany,
+    deleteAssetStageCompletion: ne.deleteOne,
+    deleteAssetStageCompletions: ne.deleteMany
   }
 }), {
   initializeAssetStageCompletions: hu,
@@ -1163,7 +1163,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), ne = R(
+), ae = R(
   (t) => t.uuid
 ), As = {
   instances: {}
@@ -1175,15 +1175,15 @@ const A = (
     (s) => Object.assign(s, As)
   ),
   reducers: {
-    initializeAssetStages: ne.initialize,
-    setAssetStage: ne.setOne,
-    setAssetStages: ne.setMany,
-    addAssetStage: ne.addOne,
-    addAssetStages: ne.addMany,
-    updateAssetStage: ne.updateOne,
-    updateAssetStages: ne.updateMany,
-    deleteAssetStage: ne.deleteOne,
-    deleteAssetStages: ne.deleteMany
+    initializeAssetStages: ae.initialize,
+    setAssetStage: ae.setOne,
+    setAssetStages: ae.setMany,
+    addAssetStage: ae.addOne,
+    addAssetStages: ae.addMany,
+    updateAssetStage: ae.updateOne,
+    updateAssetStages: ae.updateMany,
+    deleteAssetStage: ae.deleteOne,
+    deleteAssetStages: ae.deleteMany
   }
 }), {
   initializeAssetStages: Fu,
@@ -1209,7 +1209,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), ae = R((t) => t.uuid), Ts = {
+), ce = R((t) => t.uuid), Ts = {
   instances: {}
 }, rn = F({
   name: "assetTypeAttachments",
@@ -1219,15 +1219,15 @@ const A = (
     (s) => Object.assign(s, Ts)
   ),
   reducers: {
-    initializeAssetTypeAttachments: ae.initialize,
-    addAssetTypeAttachment: ae.addOne,
-    addAssetTypeAttachments: ae.addMany,
-    setAssetTypeAttachment: ae.setOne,
-    setAssetTypeAttachments: ae.setMany,
-    updateAssetTypeAttachment: ae.updateOne,
-    updateAssetTypeAttachments: ae.updateMany,
-    deleteAssetTypeAttachment: ae.deleteOne,
-    deleteAssetTypeAttachments: ae.deleteMany
+    initializeAssetTypeAttachments: ce.initialize,
+    addAssetTypeAttachment: ce.addOne,
+    addAssetTypeAttachments: ce.addMany,
+    setAssetTypeAttachment: ce.setOne,
+    setAssetTypeAttachments: ce.setMany,
+    updateAssetTypeAttachment: ce.updateOne,
+    updateAssetTypeAttachments: ce.updateMany,
+    deleteAssetTypeAttachment: ce.deleteOne,
+    deleteAssetTypeAttachments: ce.deleteMany
   }
 }), {
   initializeAssetTypeAttachments: $u,
@@ -1252,7 +1252,7 @@ const A = (
   )
 ), Ku = A(
   m([un, (t, s) => s], (t, s) => T(t.filter(({ asset_type: e }) => s === e)))
-), Yu = rn.reducer, ce = R((t) => t.uuid), Ss = {
+), Yu = rn.reducer, re = R((t) => t.uuid), Ss = {
   instances: {}
 }, ln = F({
   name: "assetTypeFieldsAttachments",
@@ -1262,15 +1262,15 @@ const A = (
     (s) => Object.assign(s, Ss)
   ),
   reducers: {
-    initializeAssetTypeFieldsAttachments: ce.initialize,
-    addAssetTypeFieldsAttachment: ce.addOne,
-    addAssetTypeFieldsAttachments: ce.addMany,
-    setAssetTypeFieldsAttachment: ce.setOne,
-    setAssetTypeFieldsAttachments: ce.setMany,
-    updateAssetTypeFieldsAttachment: ce.updateOne,
-    updateAssetTypeFieldsAttachments: ce.updateMany,
-    deleteAssetTypeFieldsAttachment: ce.deleteOne,
-    deleteAssetTypeFieldsAttachments: ce.deleteMany
+    initializeAssetTypeFieldsAttachments: re.initialize,
+    addAssetTypeFieldsAttachment: re.addOne,
+    addAssetTypeFieldsAttachments: re.addMany,
+    setAssetTypeFieldsAttachment: re.setOne,
+    setAssetTypeFieldsAttachments: re.setMany,
+    updateAssetTypeFieldsAttachment: re.updateOne,
+    updateAssetTypeFieldsAttachments: re.updateMany,
+    deleteAssetTypeFieldsAttachment: re.deleteOne,
+    deleteAssetTypeFieldsAttachments: re.deleteMany
   }
 }), {
   initializeAssetTypeFieldsAttachments: Zu,
@@ -1298,7 +1298,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), dl = ln.reducer, re = R((t) => t.uuid), Os = {
+), dl = ln.reducer, de = R((t) => t.uuid), Os = {
   instances: {}
 }, pn = F({
   name: "assetTypeFields",
@@ -1308,15 +1308,15 @@ const A = (
     (s) => Object.assign(s, Os)
   ),
   reducers: {
-    initializeAssetTypeFields: re.initialize,
-    addAssetTypeFields: re.addOne,
-    addAssetTypeFieldsMany: re.addMany,
-    setAssetTypeFields: re.setOne,
-    setAssetTypeFieldsMany: re.setMany,
-    updateAssetTypeFields: re.updateOne,
-    updateAssetTypeFieldsMany: re.updateMany,
-    deleteAssetTypeFields: re.deleteOne,
-    deleteAssetTypeFieldsMany: re.deleteMany
+    initializeAssetTypeFields: de.initialize,
+    addAssetTypeFields: de.addOne,
+    addAssetTypeFieldsMany: de.addMany,
+    setAssetTypeFields: de.setOne,
+    setAssetTypeFieldsMany: de.setMany,
+    updateAssetTypeFields: de.updateOne,
+    updateAssetTypeFieldsMany: de.updateMany,
+    deleteAssetTypeFields: de.deleteOne,
+    deleteAssetTypeFieldsMany: de.deleteMany
   }
 }), {
   initializeAssetTypeFields: ol,
@@ -1337,7 +1337,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), Il = pn.reducer, de = R((t) => t.uuid), Is = {
+), Il = pn.reducer, oe = R((t) => t.uuid), Is = {
   instances: {}
 }, mn = F({
   name: "assetTypeFieldValuesAttachments",
@@ -1347,15 +1347,15 @@ const A = (
     (s) => Object.assign(s, Is)
   ),
   reducers: {
-    initializeAssetTypeFieldValuesAttachments: de.initialize,
-    addAssetTypeFieldValuesAttachment: de.addOne,
-    addAssetTypeFieldValuesAttachments: de.addMany,
-    setAssetTypeFieldValuesAttachment: de.setOne,
-    setAssetTypeFieldValuesAttachments: de.setMany,
-    updateAssetTypeFieldValuesAttachment: de.updateOne,
-    updateAssetTypeFieldValuesAttachments: de.updateMany,
-    deleteAssetTypeFieldValuesAttachment: de.deleteOne,
-    deleteAssetTypeFieldValuesAttachments: de.deleteMany
+    initializeAssetTypeFieldValuesAttachments: oe.initialize,
+    addAssetTypeFieldValuesAttachment: oe.addOne,
+    addAssetTypeFieldValuesAttachments: oe.addMany,
+    setAssetTypeFieldValuesAttachment: oe.setOne,
+    setAssetTypeFieldValuesAttachments: oe.setMany,
+    updateAssetTypeFieldValuesAttachment: oe.updateOne,
+    updateAssetTypeFieldValuesAttachments: oe.updateMany,
+    deleteAssetTypeFieldValuesAttachment: oe.deleteOne,
+    deleteAssetTypeFieldValuesAttachments: oe.deleteMany
   }
 }), {
   initializeAssetTypeFieldValuesAttachments: _l,
@@ -1383,7 +1383,7 @@ const A = (
     [An, (t, s) => s],
     (t, s) => T(t.filter((e) => e.field_values === s))
   )
-), zl = mn.reducer, oe = R((t) => t.uuid), _s = {
+), zl = mn.reducer, ue = R((t) => t.uuid), _s = {
   instances: {}
 }, Tn = F({
   name: "assetTypeFieldValues",
@@ -1393,15 +1393,15 @@ const A = (
     (s) => Object.assign(s, _s)
   ),
   reducers: {
-    initializeAssetTypeFieldValues: oe.initialize,
-    addAssetTypeFieldValues: oe.addOne,
-    addAssetTypeFieldValuesMany: oe.addMany,
-    setAssetTypeFieldValues: oe.setOne,
-    setAssetTypeFieldValuesMany: oe.setMany,
-    updateAssetTypeFieldValues: oe.updateOne,
-    updateAssetTypeFieldValuesMany: oe.updateMany,
-    deleteAssetTypeFieldValues: oe.deleteOne,
-    deleteAssetTypeFieldValuesMany: oe.deleteMany
+    initializeAssetTypeFieldValues: ue.initialize,
+    addAssetTypeFieldValues: ue.addOne,
+    addAssetTypeFieldValuesMany: ue.addMany,
+    setAssetTypeFieldValues: ue.setOne,
+    setAssetTypeFieldValuesMany: ue.setMany,
+    updateAssetTypeFieldValues: ue.updateOne,
+    updateAssetTypeFieldValuesMany: ue.updateMany,
+    deleteAssetTypeFieldValues: ue.deleteOne,
+    deleteAssetTypeFieldValuesMany: ue.deleteMany
   }
 }), {
   initializeAssetTypeFieldValues: ql,
@@ -1433,7 +1433,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), Gl = Tn.reducer, ue = R((t) => t.uuid), bs = {
+), Gl = Tn.reducer, le = R((t) => t.uuid), bs = {
   instances: {}
 }, Sn = F({
   name: "assetTypeIdentifiers",
@@ -1443,15 +1443,15 @@ const A = (
     (s) => Object.assign(s, bs)
   ),
   reducers: {
-    initializeAssetTypeIdentifiers: ue.initialize,
-    addAssetTypeIdentifier: ue.addOne,
-    addAssetTypeIdentifiers: ue.addMany,
-    setAssetTypeIdentifier: ue.setOne,
-    setAssetTypeIdentifiers: ue.setMany,
-    updateAssetTypeIdentifier: ue.updateOne,
-    updateAssetTypeIdentifiers: ue.updateMany,
-    deleteAssetTypeIdentifier: ue.deleteOne,
-    deleteAssetTypeIdentifiers: ue.deleteMany
+    initializeAssetTypeIdentifiers: le.initialize,
+    addAssetTypeIdentifier: le.addOne,
+    addAssetTypeIdentifiers: le.addMany,
+    setAssetTypeIdentifier: le.setOne,
+    setAssetTypeIdentifiers: le.setMany,
+    updateAssetTypeIdentifier: le.updateOne,
+    updateAssetTypeIdentifiers: le.updateMany,
+    deleteAssetTypeIdentifier: le.deleteOne,
+    deleteAssetTypeIdentifiers: le.deleteMany
   }
 }), {
   initializeAssetTypeIdentifiers: Wl,
@@ -1476,7 +1476,7 @@ const A = (
   )
 ), fb = A(
   m([On, (t, s) => s], (t, s) => T(t.filter((e) => e.asset_type === s)))
-), ah = Sn.reducer, le = R((t) => t.uuid), Ps = {
+), ah = Sn.reducer, he = R((t) => t.uuid), Ps = {
   instances: {}
 }, In = F({
   name: "assetTypeIdentifierValues",
@@ -1486,15 +1486,15 @@ const A = (
     (s) => Object.assign(s, Ps)
   ),
   reducers: {
-    initializeAssetTypeIdentifierValues: le.initialize,
-    addAssetTypeIdentifierValue: le.addOne,
-    addAssetTypeIdentifierValues: le.addMany,
-    setAssetTypeIdentifierValue: le.setOne,
-    setAssetTypeIdentifierValues: le.setMany,
-    updateAssetTypeIdentifierValue: le.updateOne,
-    updateAssetTypeIdentifierValues: le.updateMany,
-    deleteAssetTypeIdentifierValue: le.deleteOne,
-    deleteAssetTypeIdentifierValues: le.deleteMany
+    initializeAssetTypeIdentifierValues: he.initialize,
+    addAssetTypeIdentifierValue: he.addOne,
+    addAssetTypeIdentifierValues: he.addMany,
+    setAssetTypeIdentifierValue: he.setOne,
+    setAssetTypeIdentifierValues: he.setMany,
+    updateAssetTypeIdentifierValue: he.updateOne,
+    updateAssetTypeIdentifierValues: he.updateMany,
+    deleteAssetTypeIdentifierValue: he.deleteOne,
+    deleteAssetTypeIdentifierValues: he.deleteMany
   }
 }), {
   initializeAssetTypeIdentifierValues: ch,
@@ -1526,7 +1526,7 @@ const A = (
       t.filter((e) => e.asset_type_identifier === s)
     )
   )
-), Th = In.reducer, he = R(
+), Th = In.reducer, pe = R(
   (t) => t.uuid
 ), gs = {
   instances: {}
@@ -1538,15 +1538,15 @@ const A = (
     (s) => Object.assign(s, gs)
   ),
   reducers: {
-    initializeAssetTypes: he.initialize,
-    setAssetType: he.setOne,
-    setAssetTypes: he.setMany,
-    addAssetType: he.addOne,
-    addAssetTypes: he.addMany,
-    updateAssetType: he.updateOne,
-    updateAssetTypes: he.updateMany,
-    deleteAssetType: he.deleteOne,
-    deleteAssetTypes: he.deleteMany
+    initializeAssetTypes: pe.initialize,
+    setAssetType: pe.setOne,
+    setAssetTypes: pe.setMany,
+    addAssetType: pe.addOne,
+    addAssetTypes: pe.addMany,
+    updateAssetType: pe.updateOne,
+    updateAssetTypes: pe.updateMany,
+    deleteAssetType: pe.deleteOne,
+    deleteAssetTypes: pe.deleteMany
   }
 }), {
   initializeAssetTypes: Sh,
@@ -1568,7 +1568,7 @@ const A = (
   })
 ), Sb = A(
   m([bn, (t, s) => s], (t, s) => T(t.filter((e) => e.organization === s)))
-), vh = _n.reducer, pe = R((t) => t.uuid), Fs = {
+), vh = _n.reducer, me = R((t) => t.uuid), Fs = {
   instances: {}
 }, Pn = F({
   name: "assetTypeStatuses",
@@ -1578,15 +1578,15 @@ const A = (
     (s) => Object.assign(s, Fs)
   ),
   reducers: {
-    initializeAssetTypeStatuses: pe.initialize,
-    addAssetTypeStatus: pe.addOne,
-    addAssetTypeStatuses: pe.addMany,
-    setAssetTypeStatus: pe.setOne,
-    setAssetTypeStatuses: pe.setMany,
-    updateAssetTypeStatus: pe.updateOne,
-    updateAssetTypeStatuses: pe.updateMany,
-    deleteAssetTypeStatus: pe.deleteOne,
-    deleteAssetTypeStatuses: pe.deleteMany
+    initializeAssetTypeStatuses: me.initialize,
+    addAssetTypeStatus: me.addOne,
+    addAssetTypeStatuses: me.addMany,
+    setAssetTypeStatus: me.setOne,
+    setAssetTypeStatuses: me.setMany,
+    updateAssetTypeStatus: me.updateOne,
+    updateAssetTypeStatuses: me.updateMany,
+    deleteAssetTypeStatus: me.deleteOne,
+    deleteAssetTypeStatuses: me.deleteMany
   }
 }), {
   initializeAssetTypeStatuses: kh,
@@ -1624,22 +1624,22 @@ const A = (
       s.payload || Bt.caseReducers.clearTokens(t), t.isLoggedIn = s.payload;
     }
   }
-}), { setTokens: Ib, clearTokens: _b, setLoggedIn: Hh } = Bt.actions, bb = (t) => t.authReducer.accessToken, Pb = (t) => t.authReducer.isLoggedIn, Gh = Bt.reducer, me = R((t) => t.uuid), Rs = {
+}), { setTokens: Ib, clearTokens: _b, setLoggedIn: Hh } = Bt.actions, bb = (t) => t.authReducer.accessToken, Pb = (t) => t.authReducer.isLoggedIn, Gh = Bt.reducer, ye = R((t) => t.uuid), Rs = {
   instances: {}
 }, Fn = F({
   name: "documentAttachments",
   initialState: Rs,
   extraReducers: (t) => t.addCase(g, (s) => Object.assign(s, Rs)),
   reducers: {
-    initializeDocumentAttachments: me.initialize,
-    addDocumentAttachment: me.addOne,
-    addDocumentAttachments: me.addMany,
-    setDocumentAttachment: me.setOne,
-    setDocumentAttachments: me.setMany,
-    updateDocumentAttachment: me.updateOne,
-    updateDocumentAttachments: me.updateMany,
-    deleteDocumentAttachment: me.deleteOne,
-    deleteDocumentAttachments: me.deleteMany
+    initializeDocumentAttachments: ye.initialize,
+    addDocumentAttachment: ye.addOne,
+    addDocumentAttachments: ye.addMany,
+    setDocumentAttachment: ye.setOne,
+    setDocumentAttachments: ye.setMany,
+    updateDocumentAttachment: ye.updateOne,
+    updateDocumentAttachments: ye.updateMany,
+    deleteDocumentAttachment: ye.deleteOne,
+    deleteDocumentAttachments: ye.deleteMany
   }
 }), {
   initializeDocumentAttachments: Wh,
@@ -1664,7 +1664,7 @@ const A = (
   )
 ), gb = A(
   m([Mn, (t, s) => s], (t, s) => T(t.filter(({ document: e }) => s === e)))
-), ap = Fn.reducer, ye = R(({ uuid: t }) => t), ws = {
+), ap = Fn.reducer, fe = R(({ uuid: t }) => t), ws = {
   instances: {}
 }, Rn = F({
   name: "documents",
@@ -1673,15 +1673,15 @@ const A = (
     Object.assign(s, ws);
   }),
   reducers: {
-    initializeDocuments: ye.initialize,
-    addDocument: ye.addOne,
-    addDocuments: ye.addMany,
-    setDocument: ye.setOne,
-    setDocuments: ye.setMany,
-    updateDocument: ye.updateOne,
-    updateDocuments: ye.updateMany,
-    deleteDocument: ye.deleteOne,
-    deleteDocuments: ye.deleteMany
+    initializeDocuments: fe.initialize,
+    addDocument: fe.addOne,
+    addDocuments: fe.addMany,
+    setDocument: fe.setOne,
+    setDocuments: fe.setMany,
+    updateDocument: fe.updateOne,
+    updateDocuments: fe.updateMany,
+    deleteDocument: fe.deleteOne,
+    deleteDocuments: fe.deleteMany
   }
 }), {
   initializeDocuments: cp,
@@ -1711,7 +1711,7 @@ const A = (
     const n = Hc(s, Object.values(t)).all().map(({ model: a }) => a);
     return T(n);
   })
-), fe = R(
+), Ae = R(
   (t) => t.uuid
 ), Es = {
   instances: {}
@@ -1723,15 +1723,15 @@ const A = (
     (s) => Object.assign(s, Es)
   ),
   reducers: {
-    initializeEmailDomains: fe.initialize,
-    addEmailDomain: fe.addOne,
-    addEmailDomains: fe.addMany,
-    setEmailDomain: fe.setOne,
-    setEmailDomains: fe.setMany,
-    updateEmailDomain: fe.updateOne,
-    updateEmailDomains: fe.updateMany,
-    deleteEmailDomain: fe.deleteOne,
-    deleteEmailDomains: fe.deleteMany
+    initializeEmailDomains: Ae.initialize,
+    addEmailDomain: Ae.addOne,
+    addEmailDomains: Ae.addMany,
+    setEmailDomain: Ae.setOne,
+    setEmailDomains: Ae.setMany,
+    updateEmailDomain: Ae.updateOne,
+    updateEmailDomains: Ae.updateMany,
+    deleteEmailDomain: Ae.deleteOne,
+    deleteEmailDomains: Ae.deleteMany
   }
 }), {
   initializeEmailDomains: Sp,
@@ -1773,7 +1773,7 @@ const A = (
   const i = (/* @__PURE__ */ new Date()).getTime();
   if (!((e.exp ?? i) - i < kn))
     return e;
-}, jp = zn.reducer, Ae = R(
+}, jp = zn.reducer, Te = R(
   (t) => t.uuid
 ), ks = {
   instances: {}
@@ -1785,15 +1785,15 @@ const A = (
     (s) => Object.assign(s, ks)
   ),
   reducers: {
-    initializeFormIdentifiers: Ae.initialize,
-    addFormIdentifier: Ae.addOne,
-    addFormIdentifiers: Ae.addMany,
-    setFormIdentifier: Ae.setOne,
-    setFormIdentifiers: Ae.setMany,
-    updateFormIdentifier: Ae.updateOne,
-    updateFormIdentifiers: Ae.updateMany,
-    deleteFormIdentifier: Ae.deleteOne,
-    deleteFormIdentifiers: Ae.deleteMany
+    initializeFormIdentifiers: Te.initialize,
+    addFormIdentifier: Te.addOne,
+    addFormIdentifiers: Te.addMany,
+    setFormIdentifier: Te.setOne,
+    setFormIdentifiers: Te.setMany,
+    updateFormIdentifier: Te.updateOne,
+    updateFormIdentifiers: Te.updateMany,
+    deleteFormIdentifier: Te.deleteOne,
+    deleteFormIdentifiers: Te.deleteMany
   }
 }), {
   initializeFormIdentifiers: Vp,
@@ -1815,7 +1815,7 @@ const A = (
   })
 ), wb = A(
   m([jn, (t, s) => s], (t, s) => T(t.filter((e) => e.form === s)))
-), Kp = qn.reducer, Te = R((t) => t.uuid), zs = {
+), Kp = qn.reducer, Se = R((t) => t.uuid), zs = {
   instances: {}
 }, Vn = F({
   name: "formIdentifierValues",
@@ -1825,15 +1825,15 @@ const A = (
     (s) => Object.assign(s, zs)
   ),
   reducers: {
-    initializeFormIdentifierValues: Te.initialize,
-    addFormIdentifierValue: Te.addOne,
-    addFormIdentifierValues: Te.addMany,
-    setFormIdentifierValue: Te.setOne,
-    setFormIdentifierValues: Te.setMany,
-    updateFormIdentifierValue: Te.updateOne,
-    updateFormIdentifierValues: Te.updateMany,
-    deleteFormIdentifierValue: Te.deleteOne,
-    deleteFormIdentifierValues: Te.deleteMany
+    initializeFormIdentifierValues: Se.initialize,
+    addFormIdentifierValue: Se.addOne,
+    addFormIdentifierValues: Se.addMany,
+    setFormIdentifierValue: Se.setOne,
+    setFormIdentifierValues: Se.setMany,
+    updateFormIdentifierValue: Se.updateOne,
+    updateFormIdentifierValues: Se.updateMany,
+    deleteFormIdentifierValue: Se.deleteOne,
+    deleteFormIdentifierValues: Se.deleteMany
   }
 }), {
   initializeFormIdentifierValues: Yp,
@@ -1870,7 +1870,7 @@ const A = (
       t.filter((e) => e.form_identifier === s)
     )
   )
-), rm = Vn.reducer, Se = R((t) => t.uuid), qs = {
+), rm = Vn.reducer, Oe = R((t) => t.uuid), qs = {
   instances: {}
 }, Bn = F({
   name: "formRevisionAttachments",
@@ -1880,15 +1880,15 @@ const A = (
     (s) => Object.assign(s, qs)
   ),
   reducers: {
-    initializeFormRevisionAttachments: Se.initialize,
-    addFormRevisionAttachment: Se.addOne,
-    addFormRevisionAttachments: Se.addMany,
-    setFormRevisionAttachment: Se.setOne,
-    setFormRevisionAttachments: Se.setMany,
-    updateFormRevisionAttachment: Se.updateOne,
-    updateFormRevisionAttachments: Se.updateMany,
-    deleteFormRevisionAttachment: Se.deleteOne,
-    deleteFormRevisionAttachments: Se.deleteMany
+    initializeFormRevisionAttachments: Oe.initialize,
+    addFormRevisionAttachment: Oe.addOne,
+    addFormRevisionAttachments: Oe.addMany,
+    setFormRevisionAttachment: Oe.setOne,
+    setFormRevisionAttachments: Oe.setMany,
+    updateFormRevisionAttachment: Oe.updateOne,
+    updateFormRevisionAttachments: Oe.updateMany,
+    deleteFormRevisionAttachment: Oe.deleteOne,
+    deleteFormRevisionAttachments: Oe.deleteMany
   }
 }), {
   initializeFormRevisionAttachments: dm,
@@ -1920,7 +1920,7 @@ const A = (
   m([Dt, (t, s) => s], (t, s) => T(
     Object.values(t).filter((e) => e.form_revision === s)
   ))
-), Om = Bn.reducer, Oe = R(
+), Om = Bn.reducer, Ie = R(
   (t) => t.uuid
 ), js = {
   instances: {}
@@ -1932,15 +1932,15 @@ const A = (
     (s) => Object.assign(s, js)
   ),
   reducers: {
-    initializeFormRevisions: Oe.initialize,
-    addFormRevision: Oe.addOne,
-    addFormRevisions: Oe.addMany,
-    setFormRevision: Oe.setOne,
-    setFormRevisions: Oe.setMany,
-    updateFormRevision: Oe.updateOne,
-    updateFormRevisions: Oe.updateMany,
-    deleteFormRevision: Oe.deleteOne,
-    deleteFormRevisions: Oe.deleteMany
+    initializeFormRevisions: Ie.initialize,
+    addFormRevision: Ie.addOne,
+    addFormRevisions: Ie.addMany,
+    setFormRevision: Ie.setOne,
+    setFormRevisions: Ie.setMany,
+    updateFormRevision: Ie.updateOne,
+    updateFormRevisions: Ie.updateMany,
+    deleteFormRevision: Ie.deleteOne,
+    deleteFormRevisions: Ie.deleteMany
   }
 }), {
   initializeFormRevisions: Im,
@@ -1967,7 +1967,7 @@ const A = (
     [Ut, (t, s) => s],
     (t, s) => T(t.filter((e) => e.form === s))
   )
-), wm = $n.reducer, Ie = R((t) => t.uuid), Vs = {
+), wm = $n.reducer, _e = R((t) => t.uuid), Vs = {
   instances: {}
 }, Nn = F({
   name: "forms",
@@ -1977,15 +1977,15 @@ const A = (
     (s) => Object.assign(s, Vs)
   ),
   reducers: {
-    initializeForms: Ie.initialize,
-    addForm: Ie.addOne,
-    addForms: Ie.addMany,
-    setForm: Ie.setOne,
-    setForms: Ie.setMany,
-    updateForm: Ie.updateOne,
-    updateForms: Ie.updateMany,
-    deleteForm: Ie.deleteOne,
-    deleteForms: Ie.deleteMany
+    initializeForms: _e.initialize,
+    addForm: _e.addOne,
+    addForms: _e.addMany,
+    setForm: _e.setOne,
+    setForms: _e.setMany,
+    updateForm: _e.updateOne,
+    updateForms: _e.updateMany,
+    deleteForm: _e.deleteOne,
+    deleteForms: _e.deleteMany
   }
 }), {
   initializeForms: Em,
@@ -2004,7 +2004,7 @@ const A = (
   })
 ), qb = A(
   m([Hn, (t, s) => s], (t, s) => T(t.filter((e) => e.organization === s)))
-), _e = R((t) => t.uuid), Bs = {
+), be = R((t) => t.uuid), Bs = {
   instances: {}
 }, Gn = F({
   name: "formSubmissionAttachments",
@@ -2014,15 +2014,15 @@ const A = (
     (s) => Object.assign(s, Bs)
   ),
   reducers: {
-    initializeFormSubmissionAttachments: _e.initialize,
-    addFormSubmissionAttachment: _e.addOne,
-    addFormSubmissionAttachments: _e.addMany,
-    setFormSubmissionAttachment: _e.setOne,
-    setFormSubmissionAttachments: _e.setMany,
-    updateFormSubmissionAttachment: _e.updateOne,
-    updateFormSubmissionAttachments: _e.updateMany,
-    deleteFormSubmissionAttachment: _e.deleteOne,
-    deleteFormSubmissionAttachments: _e.deleteMany
+    initializeFormSubmissionAttachments: be.initialize,
+    addFormSubmissionAttachment: be.addOne,
+    addFormSubmissionAttachments: be.addMany,
+    setFormSubmissionAttachment: be.setOne,
+    setFormSubmissionAttachments: be.setMany,
+    updateFormSubmissionAttachment: be.updateOne,
+    updateFormSubmissionAttachments: be.updateMany,
+    deleteFormSubmissionAttachment: be.deleteOne,
+    deleteFormSubmissionAttachments: be.deleteMany
   }
 }), {
   initializeFormSubmissionAttachments: Lm,
@@ -2059,7 +2059,7 @@ const A = (
       t.filter((e) => e.form_submission === s)
     )
   )
-), Qm = Gn.reducer, be = R(
+), Qm = Gn.reducer, Pe = R(
   (t) => t.uuid
 ), $s = {
   instances: {}
@@ -2071,15 +2071,15 @@ const A = (
     (s) => Object.assign(s, $s)
   ),
   reducers: {
-    initializeFormSubmissions: be.initialize,
-    setFormSubmission: be.setOne,
-    setFormSubmissions: be.setMany,
-    addFormSubmission: be.addOne,
-    addFormSubmissions: be.addMany,
-    updateFormSubmission: be.updateOne,
-    updateFormSubmissions: be.updateMany,
-    deleteFormSubmission: be.deleteOne,
-    deleteFormSubmissions: be.deleteMany
+    initializeFormSubmissions: Pe.initialize,
+    setFormSubmission: Pe.setOne,
+    setFormSubmissions: Pe.setMany,
+    addFormSubmission: Pe.addOne,
+    addFormSubmissions: Pe.addMany,
+    updateFormSubmission: Pe.updateOne,
+    updateFormSubmissions: Pe.updateMany,
+    deleteFormSubmission: Pe.deleteOne,
+    deleteFormSubmissions: Pe.deleteMany
   }
 }), {
   initializeFormSubmissions: ey,
@@ -2111,7 +2111,7 @@ const A = (
       );
     }
   )
-), ly = Xn.reducer, Pe = R(
+), ly = Xn.reducer, ge = R(
   (t) => t.uuid
 ), xs = {
   instances: {}
@@ -2123,15 +2123,15 @@ const A = (
     (s) => Object.assign(s, xs)
   ),
   reducers: {
-    initializeGeoImages: Pe.initialize,
-    setGeoImage: Pe.setOne,
-    setGeoImages: Pe.setMany,
-    addGeoImage: Pe.addOne,
-    addGeoImages: Pe.addMany,
-    updateGeoImage: Pe.updateOne,
-    updateGeoImages: Pe.updateMany,
-    deleteGeoImage: Pe.deleteOne,
-    deleteGeoImages: Pe.deleteMany
+    initializeGeoImages: ge.initialize,
+    setGeoImage: ge.setOne,
+    setGeoImages: ge.setMany,
+    addGeoImage: ge.addOne,
+    addGeoImages: ge.addMany,
+    updateGeoImage: ge.updateOne,
+    updateGeoImages: ge.updateMany,
+    deleteGeoImage: ge.deleteOne,
+    deleteGeoImages: ge.deleteMany
   }
 }), {
   initializeGeoImages: hy,
@@ -2150,7 +2150,7 @@ const A = (
   })
 ), jb = A(
   m([ia, (t, s) => s], (t, s) => T(t.filter((e) => e.project === s)))
-), Py = sa.reducer, ge = R((t) => t.uuid), Ds = {
+), Py = sa.reducer, Fe = R((t) => t.uuid), Ds = {
   instances: {}
 }, na = F({
   name: "issueAssociations",
@@ -2160,15 +2160,15 @@ const A = (
     (s) => Object.assign(s, Ds)
   ),
   reducers: {
-    initializeIssueAssociations: ge.initialize,
-    addIssueAssociation: ge.addOne,
-    addIssueAssociations: ge.addMany,
-    setIssueAssociation: ge.setOne,
-    setIssueAssociations: ge.setMany,
-    updateIssueAssociation: ge.updateOne,
-    updateIssueAssociations: ge.updateMany,
-    deleteIssueAssociation: ge.deleteOne,
-    deleteIssueAssociations: ge.deleteMany
+    initializeIssueAssociations: Fe.initialize,
+    addIssueAssociation: Fe.addOne,
+    addIssueAssociations: Fe.addMany,
+    setIssueAssociation: Fe.setOne,
+    setIssueAssociations: Fe.setMany,
+    updateIssueAssociation: Fe.updateOne,
+    updateIssueAssociations: Fe.updateMany,
+    deleteIssueAssociation: Fe.deleteOne,
+    deleteIssueAssociations: Fe.deleteMany
   }
 }), {
   initializeIssueAssociations: gy,
@@ -2209,7 +2209,7 @@ const A = (
   m([at, (t, s) => s], (t, s) => T(t.filter(({ issue: e }) => e === s)))
 ), xy = A(
   m([at, (t, s) => s], (t, s) => T(t.filter(({ asset: e }) => e === s)))
-), Dy = na.reducer, Fe = R((t) => t.uuid), Us = {
+), Dy = na.reducer, Me = R((t) => t.uuid), Us = {
   instances: {}
 }, aa = F({
   name: "issueAttachments",
@@ -2219,15 +2219,15 @@ const A = (
     (s) => Object.assign(s, Us)
   ),
   reducers: {
-    initializeIssueAttachments: Fe.initialize,
-    addIssueAttachment: Fe.addOne,
-    addIssueAttachments: Fe.addMany,
-    setIssueAttachment: Fe.setOne,
-    setIssueAttachments: Fe.setMany,
-    updateIssueAttachment: Fe.updateOne,
-    updateIssueAttachments: Fe.updateMany,
-    deleteIssueAttachment: Fe.deleteOne,
-    deleteIssueAttachments: Fe.deleteMany
+    initializeIssueAttachments: Me.initialize,
+    addIssueAttachment: Me.addOne,
+    addIssueAttachments: Me.addMany,
+    setIssueAttachment: Me.setOne,
+    setIssueAttachments: Me.setMany,
+    updateIssueAttachment: Me.updateOne,
+    updateIssueAttachments: Me.updateMany,
+    deleteIssueAttachment: Me.deleteOne,
+    deleteIssueAttachments: Me.deleteMany
   }
 }), {
   initializeIssueAttachments: Uy,
@@ -2252,7 +2252,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), Xy = aa.reducer, Me = R((t) => t.uuid), Cs = {
+), Xy = aa.reducer, Re = R((t) => t.uuid), Cs = {
   instances: {}
 }, oa = F({
   name: "issueCommentAttachments",
@@ -2262,15 +2262,15 @@ const A = (
     (s) => Object.assign(s, Cs)
   ),
   reducers: {
-    initializeIssueCommentAttachments: Me.initialize,
-    addIssueCommentAttachment: Me.addOne,
-    addIssueCommentAttachments: Me.addMany,
-    setIssueCommentAttachment: Me.setOne,
-    setIssueCommentAttachments: Me.setMany,
-    updateIssueCommentAttachment: Me.updateOne,
-    updateIssueCommentAttachments: Me.updateMany,
-    deleteIssueCommentAttachment: Me.deleteOne,
-    deleteIssueCommentAttachments: Me.deleteMany
+    initializeIssueCommentAttachments: Re.initialize,
+    addIssueCommentAttachment: Re.addOne,
+    addIssueCommentAttachments: Re.addMany,
+    setIssueCommentAttachment: Re.setOne,
+    setIssueCommentAttachments: Re.setMany,
+    updateIssueCommentAttachment: Re.updateOne,
+    updateIssueCommentAttachments: Re.updateMany,
+    deleteIssueCommentAttachment: Re.deleteOne,
+    deleteIssueCommentAttachments: Re.deleteMany
   }
 }), {
   initializeIssueCommentAttachments: Qy,
@@ -2295,7 +2295,7 @@ const A = (
   )
 ), Vb = A(
   m([ua, (t, s) => s], (t, s) => T(t.filter(({ issue_comment: e }) => s === e)))
-), hf = oa.reducer, Re = R(
+), hf = oa.reducer, we = R(
   (t) => t.uuid
 ), Ls = {
   instances: {}
@@ -2307,15 +2307,15 @@ const A = (
     (s) => Object.assign(s, Ls)
   ),
   reducers: {
-    initializeIssueComments: Re.initialize,
-    addIssueComment: Re.addOne,
-    addIssueComments: Re.addMany,
-    setIssueComment: Re.setOne,
-    setIssueComments: Re.setMany,
-    updateIssueComment: Re.updateOne,
-    updateIssueComments: Re.updateMany,
-    deleteIssueComment: Re.deleteOne,
-    deleteIssueComments: Re.deleteMany
+    initializeIssueComments: we.initialize,
+    addIssueComment: we.addOne,
+    addIssueComments: we.addMany,
+    setIssueComment: we.setOne,
+    setIssueComments: we.setMany,
+    updateIssueComment: we.updateOne,
+    updateIssueComments: we.updateMany,
+    deleteIssueComment: we.deleteOne,
+    deleteIssueComments: we.deleteMany
   }
 }), {
   initializeIssueComments: pf,
@@ -2339,7 +2339,7 @@ const A = (
       Object.values(t).filter((e) => e.issue === s)
     )
   )
-), Pf = la.reducer, we = R((t) => t.uuid), Ns = {
+), Pf = la.reducer, Ee = R((t) => t.uuid), Ns = {
   instances: {}
 }, pa = F({
   name: "issues",
@@ -2349,15 +2349,15 @@ const A = (
     (s) => Object.assign(s, Ns)
   ),
   reducers: {
-    initializeIssues: we.initialize,
-    addIssue: we.addOne,
-    addIssues: we.addMany,
-    setIssue: we.setOne,
-    setIssues: we.setMany,
-    updateIssue: we.updateOne,
-    updateIssues: we.updateMany,
-    deleteIssue: we.deleteOne,
-    deleteIssues: we.deleteMany
+    initializeIssues: Ee.initialize,
+    addIssue: Ee.addOne,
+    addIssues: Ee.addMany,
+    setIssue: Ee.setOne,
+    setIssues: Ee.setMany,
+    updateIssue: Ee.updateOne,
+    updateIssues: Ee.updateMany,
+    deleteIssue: Ee.deleteOne,
+    deleteIssues: Ee.deleteMany
   }
 }), {
   initializeIssues: gf,
@@ -2381,7 +2381,7 @@ const A = (
   m([Ct, (t, s) => s], (t, s) => t.filter((e) => e.project === s))
 ), jf = A(
   m([Ct, (t, s) => s], (t, s) => t.filter((e) => e.issue_type === s))
-), Vf = pa.reducer, Ee = R((t) => t.uuid), Hs = {
+), Vf = pa.reducer, ve = R((t) => t.uuid), Hs = {
   instances: {}
 }, fa = F({
   name: "issueTypeAttachments",
@@ -2391,15 +2391,15 @@ const A = (
     (s) => Object.assign(s, Hs)
   ),
   reducers: {
-    initializeIssueTypeAttachments: Ee.initialize,
-    addIssueTypeAttachment: Ee.addOne,
-    addIssueTypeAttachments: Ee.addMany,
-    setIssueTypeAttachment: Ee.setOne,
-    setIssueTypeAttachments: Ee.setMany,
-    updateIssueTypeAttachment: Ee.updateOne,
-    updateIssueTypeAttachments: Ee.updateMany,
-    deleteIssueTypeAttachment: Ee.deleteOne,
-    deleteIssueTypeAttachments: Ee.deleteMany
+    initializeIssueTypeAttachments: ve.initialize,
+    addIssueTypeAttachment: ve.addOne,
+    addIssueTypeAttachments: ve.addMany,
+    setIssueTypeAttachment: ve.setOne,
+    setIssueTypeAttachments: ve.setMany,
+    updateIssueTypeAttachment: ve.updateOne,
+    updateIssueTypeAttachments: ve.updateMany,
+    deleteIssueTypeAttachment: ve.deleteOne,
+    deleteIssueTypeAttachments: ve.deleteMany
   }
 }), {
   initializeIssueTypeAttachments: Bf,
@@ -2424,7 +2424,7 @@ const A = (
   )
 ), xb = A(
   m([Aa, (t, s) => s], (t, s) => T(t.filter(({ issue_type: e }) => s === e)))
-), Yf = fa.reducer, ve = R((t) => t.uuid), Gs = {
+), Yf = fa.reducer, ke = R((t) => t.uuid), Gs = {
   instances: {}
 }, Ta = F({
   name: "issueTypeFieldsAttachments",
@@ -2434,15 +2434,15 @@ const A = (
     (s) => Object.assign(s, Gs)
   ),
   reducers: {
-    initializeIssueTypeFieldsAttachments: ve.initialize,
-    addIssueTypeFieldsAttachment: ve.addOne,
-    addIssueTypeFieldsAttachments: ve.addMany,
-    setIssueTypeFieldsAttachment: ve.setOne,
-    setIssueTypeFieldsAttachments: ve.setMany,
-    updateIssueTypeFieldsAttachment: ve.updateOne,
-    updateIssueTypeFieldsAttachments: ve.updateMany,
-    deleteIssueTypeFieldsAttachment: ve.deleteOne,
-    deleteIssueTypeFieldsAttachments: ve.deleteMany
+    initializeIssueTypeFieldsAttachments: ke.initialize,
+    addIssueTypeFieldsAttachment: ke.addOne,
+    addIssueTypeFieldsAttachments: ke.addMany,
+    setIssueTypeFieldsAttachment: ke.setOne,
+    setIssueTypeFieldsAttachments: ke.setMany,
+    updateIssueTypeFieldsAttachment: ke.updateOne,
+    updateIssueTypeFieldsAttachments: ke.updateMany,
+    deleteIssueTypeFieldsAttachment: ke.deleteOne,
+    deleteIssueTypeFieldsAttachments: ke.deleteMany
   }
 }), {
   initializeIssueTypeFieldsAttachments: Zf,
@@ -2470,7 +2470,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), dA = Ta.reducer, ke = R((t) => t.uuid), Ws = {
+), dA = Ta.reducer, ze = R((t) => t.uuid), Ws = {
   instances: {}
 }, Oa = F({
   name: "issueTypeFieldValues",
@@ -2480,15 +2480,15 @@ const A = (
     (s) => Object.assign(s, Ws)
   ),
   reducers: {
-    initializeIssueTypeFieldValues: ke.initialize,
-    addIssueTypeFieldValues: ke.addOne,
-    addIssueTypeFieldValuesMany: ke.addMany,
-    setIssueTypeFieldValues: ke.setOne,
-    setIssueTypeFieldValuesMany: ke.setMany,
-    updateIssueTypeFieldValues: ke.updateOne,
-    updateIssueTypeFieldValuesMany: ke.updateMany,
-    deleteIssueTypeFieldValues: ke.deleteOne,
-    deleteIssueTypeFieldValuesMany: ke.deleteMany
+    initializeIssueTypeFieldValues: ze.initialize,
+    addIssueTypeFieldValues: ze.addOne,
+    addIssueTypeFieldValuesMany: ze.addMany,
+    setIssueTypeFieldValues: ze.setOne,
+    setIssueTypeFieldValuesMany: ze.setMany,
+    updateIssueTypeFieldValues: ze.updateOne,
+    updateIssueTypeFieldValuesMany: ze.updateMany,
+    deleteIssueTypeFieldValues: ze.deleteOne,
+    deleteIssueTypeFieldValuesMany: ze.deleteMany
   }
 }), {
   initializeIssueTypeFieldValues: oA,
@@ -2510,7 +2510,7 @@ const A = (
       return T(t.filter(({ uuid: i }) => e.has(i)));
     }
   )
-), IA = Oa.reducer, ze = R((t) => t.uuid), Ks = {
+), IA = Oa.reducer, qe = R((t) => t.uuid), Ks = {
   instances: {}
 }, Ia = F({
   name: "issueTypeFields",
@@ -2520,15 +2520,15 @@ const A = (
     (s) => Object.assign(s, Ks)
   ),
   reducers: {
-    initializeIssueTypeFields: ze.initialize,
-    addIssueTypeFields: ze.addOne,
-    addIssueTypeFieldsMany: ze.addMany,
-    setIssueTypeFields: ze.setOne,
-    setIssueTypeFieldsMany: ze.setMany,
-    updateIssueTypeFields: ze.updateOne,
-    updateIssueTypeFieldsMany: ze.updateMany,
-    deleteIssueTypeFields: ze.deleteOne,
-    deleteIssueTypeFieldsMany: ze.deleteMany
+    initializeIssueTypeFields: qe.initialize,
+    addIssueTypeFields: qe.addOne,
+    addIssueTypeFieldsMany: qe.addMany,
+    setIssueTypeFields: qe.setOne,
+    setIssueTypeFieldsMany: qe.setMany,
+    updateIssueTypeFields: qe.updateOne,
+    updateIssueTypeFieldsMany: qe.updateMany,
+    deleteIssueTypeFields: qe.deleteOne,
+    deleteIssueTypeFieldsMany: qe.deleteMany
   }
 }), {
   initializeIssueTypeFields: _A,
@@ -2559,7 +2559,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), qA = Ia.reducer, qe = R((t) => t.uuid), Ys = {
+), qA = Ia.reducer, je = R((t) => t.uuid), Ys = {
   instances: {}
 }, _a = F({
   name: "issueTypeFieldValuesAttachments",
@@ -2569,15 +2569,15 @@ const A = (
     (s) => Object.assign(s, Ys)
   ),
   reducers: {
-    initializeIssueTypeFieldValuesAttachments: qe.initialize,
-    addIssueTypeFieldValuesAttachment: qe.addOne,
-    addIssueTypeFieldValuesAttachments: qe.addMany,
-    setIssueTypeFieldValuesAttachment: qe.setOne,
-    setIssueTypeFieldValuesAttachments: qe.setMany,
-    updateIssueTypeFieldValuesAttachment: qe.updateOne,
-    updateIssueTypeFieldValuesAttachments: qe.updateMany,
-    deleteIssueTypeFieldValuesAttachment: qe.deleteOne,
-    deleteIssueTypeFieldValuesAttachments: qe.deleteMany
+    initializeIssueTypeFieldValuesAttachments: je.initialize,
+    addIssueTypeFieldValuesAttachment: je.addOne,
+    addIssueTypeFieldValuesAttachments: je.addMany,
+    setIssueTypeFieldValuesAttachment: je.setOne,
+    setIssueTypeFieldValuesAttachments: je.setMany,
+    updateIssueTypeFieldValuesAttachment: je.updateOne,
+    updateIssueTypeFieldValuesAttachments: je.updateMany,
+    deleteIssueTypeFieldValuesAttachment: je.deleteOne,
+    deleteIssueTypeFieldValuesAttachments: je.deleteMany
   }
 }), {
   initializeIssueTypeFieldValuesAttachments: jA,
@@ -2605,7 +2605,7 @@ const A = (
     [ga, (t, s) => s],
     (t, s) => T(t.filter((e) => e.field_values === s))
   )
-), GA = _a.reducer, je = R((t) => t.uuid), Zs = {
+), GA = _a.reducer, Ve = R((t) => t.uuid), Zs = {
   instances: {}
 }, Fa = F({
   name: "issueTypeIdentifiers",
@@ -2615,15 +2615,15 @@ const A = (
     (s) => Object.assign(s, Zs)
   ),
   reducers: {
-    initializeIssueTypeIdentifiers: je.initialize,
-    addIssueTypeIdentifier: je.addOne,
-    addIssueTypeIdentifiers: je.addMany,
-    setIssueTypeIdentifier: je.setOne,
-    setIssueTypeIdentifiers: je.setMany,
-    updateIssueTypeIdentifier: je.updateOne,
-    updateIssueTypeIdentifiers: je.updateMany,
-    deleteIssueTypeIdentifier: je.deleteOne,
-    deleteIssueTypeIdentifiers: je.deleteMany
+    initializeIssueTypeIdentifiers: Ve.initialize,
+    addIssueTypeIdentifier: Ve.addOne,
+    addIssueTypeIdentifiers: Ve.addMany,
+    setIssueTypeIdentifier: Ve.setOne,
+    setIssueTypeIdentifiers: Ve.setMany,
+    updateIssueTypeIdentifier: Ve.updateOne,
+    updateIssueTypeIdentifiers: Ve.updateMany,
+    deleteIssueTypeIdentifier: Ve.deleteOne,
+    deleteIssueTypeIdentifiers: Ve.deleteMany
   }
 }), {
   initializeIssueTypeIdentifiers: WA,
@@ -2648,7 +2648,7 @@ const A = (
   )
 ), Hb = A(
   m([Ma, (t, s) => s], (t, s) => T(t.filter((e) => e.issue_type === s)))
-), aT = Fa.reducer, Ve = R((t) => t.uuid), Js = {
+), aT = Fa.reducer, Be = R((t) => t.uuid), Js = {
   instances: {}
 }, Ra = F({
   name: "issueTypeIdentifierValues",
@@ -2658,15 +2658,15 @@ const A = (
     (s) => Object.assign(s, Js)
   ),
   reducers: {
-    initializeIssueTypeIdentifierValues: Ve.initialize,
-    addIssueTypeIdentifierValue: Ve.addOne,
-    addIssueTypeIdentifierValues: Ve.addMany,
-    setIssueTypeIdentifierValue: Ve.setOne,
-    setIssueTypeIdentifierValues: Ve.setMany,
-    updateIssueTypeIdentifierValue: Ve.updateOne,
-    updateIssueTypeIdentifierValues: Ve.updateMany,
-    deleteIssueTypeIdentifierValue: Ve.deleteOne,
-    deleteIssueTypeIdentifierValues: Ve.deleteMany
+    initializeIssueTypeIdentifierValues: Be.initialize,
+    addIssueTypeIdentifierValue: Be.addOne,
+    addIssueTypeIdentifierValues: Be.addMany,
+    setIssueTypeIdentifierValue: Be.setOne,
+    setIssueTypeIdentifierValues: Be.setMany,
+    updateIssueTypeIdentifierValue: Be.updateOne,
+    updateIssueTypeIdentifierValues: Be.updateMany,
+    deleteIssueTypeIdentifierValue: Be.deleteOne,
+    deleteIssueTypeIdentifierValues: Be.deleteMany
   }
 }), {
   initializeIssueTypeIdentifierValues: cT,
@@ -2698,7 +2698,7 @@ const A = (
       t.filter((e) => e.issue_type_identifier === s)
     )
   )
-), TT = Ra.reducer, Be = R(
+), TT = Ra.reducer, $e = R(
   (t) => t.uuid
 ), Xs = {
   instances: {}
@@ -2710,15 +2710,15 @@ const A = (
     (s) => Object.assign(s, Xs)
   ),
   reducers: {
-    initializeIssueTypes: Be.initialize,
-    addIssueType: Be.addOne,
-    addIssueTypes: Be.addMany,
-    setIssueType: Be.setOne,
-    setIssueTypes: Be.setMany,
-    updateIssueType: Be.updateOne,
-    updateIssueTypes: Be.updateMany,
-    deleteIssueType: Be.deleteOne,
-    deleteIssueTypes: Be.deleteMany
+    initializeIssueTypes: $e.initialize,
+    addIssueType: $e.addOne,
+    addIssueTypes: $e.addMany,
+    setIssueType: $e.setOne,
+    setIssueTypes: $e.setMany,
+    updateIssueType: $e.updateOne,
+    updateIssueTypes: $e.updateMany,
+    deleteIssueType: $e.deleteOne,
+    deleteIssueTypes: $e.deleteMany
   }
 }), {
   initializeIssueTypes: ST,
@@ -2740,7 +2740,7 @@ const A = (
   })
 ), Kb = A(
   m([Ea, (t, s) => s], (t, s) => T(t.filter((e) => e.organization === s)))
-), vT = wa.reducer, $e = R((t) => t.uuid), Qs = {
+), vT = wa.reducer, xe = R((t) => t.uuid), Qs = {
   instances: {}
 }, va = F({
   name: "issueTypeStatuses",
@@ -2750,15 +2750,15 @@ const A = (
     (s) => Object.assign(s, Qs)
   ),
   reducers: {
-    initializeIssueTypeStatuses: $e.initialize,
-    addIssueTypeStatus: $e.addOne,
-    addIssueTypeStatuses: $e.addMany,
-    setIssueTypeStatus: $e.setOne,
-    setIssueTypeStatuses: $e.setMany,
-    updateIssueTypeStatus: $e.updateOne,
-    updateIssueTypeStatuses: $e.updateMany,
-    deleteIssueTypeStatus: $e.deleteOne,
-    deleteIssueTypeStatuses: $e.deleteMany
+    initializeIssueTypeStatuses: xe.initialize,
+    addIssueTypeStatus: xe.addOne,
+    addIssueTypeStatuses: xe.addMany,
+    setIssueTypeStatus: xe.setOne,
+    setIssueTypeStatuses: xe.setMany,
+    updateIssueTypeStatus: xe.updateOne,
+    updateIssueTypeStatuses: xe.updateMany,
+    deleteIssueTypeStatus: xe.deleteOne,
+    deleteIssueTypeStatuses: xe.deleteMany
   }
 }), {
   initializeIssueTypeStatuses: kT,
@@ -2777,7 +2777,7 @@ const A = (
   })
 ), Yb = A(
   m([ka, (t, s) => s], (t, s) => T(t.filter((e) => e.issue_type === s)))
-), LT = va.reducer, xe = R(
+), LT = va.reducer, De = R(
   (t) => t.uuid
 ), ei = {
   instances: {}
@@ -2789,15 +2789,15 @@ const A = (
     (s) => Object.assign(s, ei)
   ),
   reducers: {
-    initializeIssueUpdates: xe.initialize,
-    addIssueUpdate: xe.addOne,
-    addIssueUpdates: xe.addMany,
-    setIssueUpdate: xe.setOne,
-    setIssueUpdates: xe.setMany,
-    updateIssueUpdate: xe.updateOne,
-    updateIssueUpdates: xe.updateMany,
-    deleteIssueUpdate: xe.deleteOne,
-    deleteIssueUpdates: xe.deleteMany
+    initializeIssueUpdates: De.initialize,
+    addIssueUpdate: De.addOne,
+    addIssueUpdates: De.addMany,
+    setIssueUpdate: De.setOne,
+    setIssueUpdates: De.setMany,
+    updateIssueUpdate: De.updateOne,
+    updateIssueUpdates: De.updateMany,
+    deleteIssueUpdate: De.deleteOne,
+    deleteIssueUpdates: De.deleteMany
   }
 }), {
   initializeIssueUpdates: NT,
@@ -2827,7 +2827,7 @@ const A = (
   )
 ), JT = A(
   m([Da, (t, s) => s], (t, s) => T(t.filter((e) => e.issue === s)))
-), XT = qa.reducer, De = R((t) => t.id), ti = {
+), XT = qa.reducer, Ue = R((t) => t.id), ti = {
   instances: {},
   currentUser: null
 }, Ua = F({
@@ -2838,15 +2838,15 @@ const A = (
     (s) => Object.assign(s, ti)
   ),
   reducers: {
-    initializeUsers: De.initialize,
-    setUsers: De.setMany,
-    setUser: De.setOne,
-    addUsers: De.addMany,
-    addUser: De.addOne,
-    updateUsers: De.updateMany,
-    updateUser: De.updateOne,
-    deleteUser: De.deleteOne,
-    deleteUsers: De.deleteMany,
+    initializeUsers: Ue.initialize,
+    setUsers: Ue.setMany,
+    setUser: Ue.setOne,
+    addUsers: Ue.addMany,
+    addUser: Ue.addOne,
+    updateUsers: Ue.updateMany,
+    updateUser: Ue.updateOne,
+    deleteUser: Ue.deleteOne,
+    deleteUsers: Ue.deleteMany,
     setCurrentUser: (t, s) => {
       t.currentUser = s.payload;
     },
@@ -2876,7 +2876,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ id: i }) => e.has(i)));
   })
-), Ue = R((t) => t.uuid), si = {
+), Ce = R((t) => t.uuid), si = {
   instances: {}
 }, Ha = F({
   name: "organizationAccess",
@@ -2886,15 +2886,15 @@ const A = (
     (s) => Object.assign(s, si)
   ),
   reducers: {
-    initializeOrganizationAccesses: Ue.initialize,
-    addOrganizationAccess: Ue.addOne,
-    addOrganizationAccesses: Ue.addMany,
-    setOrganizationAccess: Ue.setOne,
-    setOrganizationAccesses: Ue.setMany,
-    updateOrganizationAccess: Ue.updateOne,
-    updateOrganizationAccesses: Ue.updateMany,
-    deleteOrganizationAccess: Ue.deleteOne,
-    deleteOrganizationAccesses: Ue.deleteMany
+    initializeOrganizationAccesses: Ce.initialize,
+    addOrganizationAccess: Ce.addOne,
+    addOrganizationAccesses: Ce.addMany,
+    setOrganizationAccess: Ce.setOne,
+    setOrganizationAccesses: Ce.setMany,
+    updateOrganizationAccess: Ce.updateOne,
+    updateOrganizationAccesses: Ce.updateMany,
+    deleteOrganizationAccess: Ce.deleteOne,
+    deleteOrganizationAccesses: Ce.deleteMany
   }
 }), {
   initializeOrganizationAccesses: oS,
@@ -2934,7 +2934,7 @@ const A = (
       })
     )
   )
-), Ce = R((t) => t.uuid), ii = {
+), Le = R((t) => t.uuid), ii = {
   instances: {}
 }, Ga = F({
   name: "organizations",
@@ -2944,15 +2944,15 @@ const A = (
     (s) => Object.assign(s, ii)
   ),
   reducers: {
-    initializeOrganizations: Ce.initialize,
-    setOrganizations: Ce.setMany,
-    setOrganization: Ce.setOne,
-    addOrganizations: Ce.addMany,
-    addOrganization: Ce.addOne,
-    updateOrganizations: Ce.updateMany,
-    updateOrganization: Ce.updateOne,
-    deleteOrganization: Ce.deleteOne,
-    deleteOrganizations: Ce.deleteMany
+    initializeOrganizations: Le.initialize,
+    setOrganizations: Le.setMany,
+    setOrganization: Le.setOne,
+    addOrganizations: Le.addMany,
+    addOrganization: Le.addOne,
+    updateOrganizations: Le.updateMany,
+    updateOrganization: Le.updateOne,
+    deleteOrganization: Le.deleteOne,
+    deleteOrganizations: Le.deleteMany
   }
 }), {
   initializeOrganizations: _S,
@@ -3015,7 +3015,7 @@ const A = (
       t.latestRetryTime = s.payload;
     }
   }
-}), eP = (t) => t.outboxReducer.deletedRequests, tP = (t) => t.outboxReducer.latestRetryTime, { enqueueRequest: BS, markForDeletion: sP, markAsDeleted: $S, _setLatestRetryTime: xS } = Wa.actions, DS = Wa.reducer, Le = R(
+}), eP = (t) => t.outboxReducer.deletedRequests, tP = (t) => t.outboxReducer.latestRetryTime, { enqueueRequest: BS, markForDeletion: sP, markAsDeleted: $S, _setLatestRetryTime: xS } = Wa.actions, DS = Wa.reducer, Ne = R(
   (t) => t.uuid
 ), ai = {
   instances: {}
@@ -3027,15 +3027,15 @@ const A = (
     (s) => Object.assign(s, ai)
   ),
   reducers: {
-    initializeProjectAccesses: Le.initialize,
-    addProjectAccess: Le.addOne,
-    addProjectAccesses: Le.addMany,
-    setProjectAccess: Le.setOne,
-    setProjectAccesses: Le.setMany,
-    updateProjectAccess: Le.updateOne,
-    updateProjectAccesses: Le.updateMany,
-    deleteProjectAccess: Le.deleteOne,
-    deleteProjectAccesses: Le.deleteMany
+    initializeProjectAccesses: Ne.initialize,
+    addProjectAccess: Ne.addOne,
+    addProjectAccesses: Ne.addMany,
+    setProjectAccess: Ne.setOne,
+    setProjectAccesses: Ne.setMany,
+    updateProjectAccess: Ne.updateOne,
+    updateProjectAccesses: Ne.updateMany,
+    deleteProjectAccess: Ne.deleteOne,
+    deleteProjectAccesses: Ne.deleteMany
   }
 }), {
   initializeProjectAccesses: US,
@@ -3077,7 +3077,7 @@ const A = (
       return T(t.filter((n) => i.has(n.id)));
     }
   )
-), Ne = R((t) => t.uuid), ci = {
+), He = R((t) => t.uuid), ci = {
   instances: {}
 }, Za = F({
   name: "projectAttachments",
@@ -3087,15 +3087,15 @@ const A = (
     (s) => Object.assign(s, ci)
   ),
   reducers: {
-    initializeProjectAttachments: Ne.initialize,
-    addProjectAttachment: Ne.addOne,
-    addProjectAttachments: Ne.addMany,
-    setProjectAttachment: Ne.setOne,
-    setProjectAttachments: Ne.setMany,
-    updateProjectAttachment: Ne.updateOne,
-    updateProjectAttachments: Ne.updateMany,
-    deleteProjectAttachment: Ne.deleteOne,
-    deleteProjectAttachments: Ne.deleteMany
+    initializeProjectAttachments: He.initialize,
+    addProjectAttachment: He.addOne,
+    addProjectAttachments: He.addMany,
+    setProjectAttachment: He.setOne,
+    setProjectAttachments: He.setMany,
+    updateProjectAttachment: He.updateOne,
+    updateProjectAttachments: He.updateMany,
+    deleteProjectAttachment: He.deleteOne,
+    deleteProjectAttachments: He.deleteMany
   }
 }), {
   initializeProjectAttachments: QS,
@@ -3117,7 +3117,7 @@ const A = (
   })
 ), cP = A(
   m([Ja, (t, s) => s], (t, s) => T(t.filter(({ project: e }) => s === e)))
-), lO = Za.reducer, He = R(
+), lO = Za.reducer, Ge = R(
   (t) => t.uuid
 ), ri = {
   instances: {},
@@ -3131,15 +3131,15 @@ const A = (
     (s) => Object.assign(s, ri)
   ),
   reducers: {
-    initializeProjectFiles: He.initialize,
-    setProjectFile: He.setOne,
-    setProjectFiles: He.setMany,
-    addProjectFile: He.addOne,
-    addProjectFiles: He.addMany,
-    updateProjectFile: He.updateOne,
-    updateProjectFiles: He.updateMany,
-    deleteProjectFile: He.deleteOne,
-    deleteProjectFiles: He.deleteMany,
+    initializeProjectFiles: Ge.initialize,
+    setProjectFile: Ge.setOne,
+    setProjectFiles: Ge.setMany,
+    addProjectFile: Ge.addOne,
+    addProjectFiles: Ge.addMany,
+    updateProjectFile: Ge.updateOne,
+    updateProjectFiles: Ge.updateMany,
+    deleteProjectFile: Ge.deleteOne,
+    deleteProjectFiles: Ge.deleteMany,
     // TODO: move following to /web
     setIsImportingProjectFile: (t, s) => {
       t.isImportingProjectFile = s.payload;
@@ -3178,7 +3178,7 @@ const A = (
     const e = new Set(s);
     return T(t.filter(({ uuid: i }) => e.has(i)));
   })
-), rP = (t) => t.projectFileReducer.activeProjectFileId, dP = (t) => t.projectFileReducer.isImportingProjectFile, RO = Xa.reducer, Ge = R((t) => t.uuid), di = {
+), rP = (t) => t.projectFileReducer.activeProjectFileId, dP = (t) => t.projectFileReducer.isImportingProjectFile, RO = Xa.reducer, We = R((t) => t.uuid), di = {
   instances: {}
 }, Qa = F({
   name: "projects",
@@ -3188,15 +3188,15 @@ const A = (
     (s) => Object.assign(s, di)
   ),
   reducers: {
-    initializeProjects: Ge.initialize,
-    setProjects: Ge.setMany,
-    setProject: Ge.setOne,
-    addProjects: Ge.addMany,
-    addProject: Ge.addOne,
-    updateProjects: Ge.updateMany,
-    updateProject: Ge.updateOne,
-    deleteProject: Ge.deleteOne,
-    deleteProjects: Ge.deleteMany
+    initializeProjects: We.initialize,
+    setProjects: We.setMany,
+    setProject: We.setOne,
+    addProjects: We.addMany,
+    addProject: We.addOne,
+    updateProjects: We.updateMany,
+    updateProject: We.updateOne,
+    deleteProject: We.deleteOne,
+    deleteProjects: We.deleteMany
   }
 }), {
   initializeProjects: wO,
@@ -3231,7 +3231,7 @@ const A = (
       t.isRehydrated = s.payload;
     }
   }
-}), { setRehydrated: lP } = ec.actions, hP = (t) => t.rehydratedReducer.isRehydrated, LO = ec.reducer, We = R(
+}), { setRehydrated: lP } = ec.actions, hP = (t) => t.rehydratedReducer.isRehydrated, LO = ec.reducer, Ke = R(
   (t) => t.uuid
 ), oi = {
   instances: {}
@@ -3243,15 +3243,15 @@ const A = (
     (s) => Object.assign(s, oi)
   ),
   reducers: {
-    initializeTeamMemberships: We.initialize,
-    addTeamMembership: We.addOne,
-    addTeamMemberships: We.addMany,
-    setTeamMembership: We.setOne,
-    setTeamMemberships: We.setMany,
-    updateTeamMembership: We.updateOne,
-    updateTeamMemberships: We.updateMany,
-    deleteTeamMembership: We.deleteOne,
-    deleteTeamMemberships: We.deleteMany
+    initializeTeamMemberships: Ke.initialize,
+    addTeamMembership: Ke.addOne,
+    addTeamMemberships: Ke.addMany,
+    setTeamMembership: Ke.setOne,
+    setTeamMemberships: Ke.setMany,
+    updateTeamMembership: Ke.updateOne,
+    updateTeamMemberships: Ke.updateMany,
+    deleteTeamMembership: Ke.deleteOne,
+    deleteTeamMemberships: Ke.deleteMany
   }
 }), {
   initializeTeamMemberships: NO,
@@ -3286,7 +3286,7 @@ const A = (
       return T(t.filter((n) => i.has(n.id)));
     }
   )
-), Ke = R((t) => t.uuid), ui = {
+), Ye = R((t) => t.uuid), ui = {
   instances: {}
 }, sc = F({
   name: "teams",
@@ -3296,15 +3296,15 @@ const A = (
     (s) => Object.assign(s, ui)
   ),
   reducers: {
-    initializeTeams: Ke.initialize,
-    addTeam: Ke.addOne,
-    addTeams: Ke.addMany,
-    setTeam: Ke.setOne,
-    setTeams: Ke.setMany,
-    updateTeam: Ke.updateOne,
-    updateTeams: Ke.updateMany,
-    deleteTeam: Ke.deleteOne,
-    deleteTeams: Ke.deleteMany
+    initializeTeams: Ye.initialize,
+    addTeam: Ye.addOne,
+    addTeams: Ye.addMany,
+    setTeam: Ye.setOne,
+    setTeams: Ye.setMany,
+    updateTeam: Ye.updateOne,
+    updateTeams: Ye.updateMany,
+    deleteTeam: Ye.deleteOne,
+    deleteTeams: Ye.deleteMany
   }
 }), {
   initializeTeams: iI,
@@ -3398,7 +3398,7 @@ const A = (
   assetProcedureStepFieldValuesReducer: Do,
   assetProcedureStepReducer: Zo,
   teamMembershipReducer: QO
-}, AP = mi(SI), OI = 1e4, II = 200, ac = [400, 409, 403, 404, 405, 500], Ye = 1e4, cc = {};
+}, AP = mi(SI), OI = 1e4, II = 200, ac = [400, 409, 403, 404, 405, 500], Ze = 1e4, cc = {};
 class rc {
   constructor(s) {
     h(this, "client");
@@ -3787,7 +3787,7 @@ class OP extends et {
     return M({
       file_url: URL.createObjectURL(e.file),
       file_sha1: e.file_sha1,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       file_name: e.file.name,
       file_type: e.file.type,
@@ -3850,7 +3850,7 @@ class IP extends et {
     return M({
       file_url: URL.createObjectURL(e.file),
       file_sha1: e.file_sha1,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       file_name: e.file.name,
       file_type: e.file.type,
       created_by: e.created_by,
@@ -4022,7 +4022,7 @@ class bP extends k {
     return this.dispatch(n(a)), a;
   }
 }
-function Ze(t, s) {
+function Je(t, s) {
   const e = [];
   let i = 0;
   const n = t.length;
@@ -4053,7 +4053,7 @@ class PP extends k {
   }
   async bulkAdd(e, i) {
     var f;
-    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Ze(e, Math.min(i ?? e.length, Ye)), u = [], p = [];
+    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Je(e, Math.min(i ?? e.length, Ze)), u = [], p = [];
     for (const S of c) {
       const b = {}, I = [];
       for (const _ of S) {
@@ -4181,7 +4181,7 @@ class gP extends k {
   }
   bulkAdd(e, i) {
     var b;
-    const { values: n, payloads: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = ((b = this.client.store.getState().userReducer.currentUser) == null ? void 0 : b.id) ?? null, p = [], y = Ze(a, Math.min(i ?? a.length, Ye)), f = [];
+    const { values: n, payloads: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = ((b = this.client.store.getState().userReducer.currentUser) == null ? void 0 : b.id) ?? null, p = [], y = Je(a, Math.min(i ?? a.length, Ze)), f = [];
     for (const I of y) {
       const _ = [];
       for (const P of I) {
@@ -4674,7 +4674,7 @@ class EP extends k {
   }
   async bulkAdd(e, i) {
     var f;
-    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Ze(e, Math.min(i ?? e.length, Ye)), u = [], p = [];
+    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Je(e, Math.min(i ?? e.length, Ze)), u = [], p = [];
     for (const S of c) {
       const b = {}, I = [];
       for (const _ of S) {
@@ -4802,7 +4802,7 @@ class vP extends k {
   }
   bulkAdd(e, i) {
     var b;
-    const { payloads: n, values: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = ((b = this.client.store.getState().userReducer.currentUser) == null ? void 0 : b.id) ?? null, p = [], y = Ze(n, Math.min(i ?? n.length, Ye)), f = [];
+    const { payloads: n, values: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = ((b = this.client.store.getState().userReducer.currentUser) == null ? void 0 : b.id) ?? null, p = [], y = Je(n, Math.min(i ?? n.length, Ze)), f = [];
     for (const I of y) {
       const _ = [];
       for (const P of I) {
@@ -5090,9 +5090,9 @@ class zP extends k {
     }
   }
   bulkAdd(e, i) {
-    const { addMany: n } = this.actions, a = (/* @__PURE__ */ new Date()).toISOString(), r = Qe(), o = Ze(
+    const { addMany: n } = this.actions, a = (/* @__PURE__ */ new Date()).toISOString(), r = Qe(), o = Je(
       e,
-      Math.min(i ?? e.length, Ye)
+      Math.min(i ?? e.length, Ze)
     ).map((u) => {
       const p = u.map((y) => M(y));
       return {
@@ -5137,7 +5137,7 @@ class zP extends k {
         ...e[f]
       });
     this.dispatch(a(c));
-    const u = Ze(e, Math.min(i ?? e.length, Ye)), p = [];
+    const u = Je(e, Math.min(i ?? e.length, Ze)), p = [];
     let y = null;
     for (const f of u) {
       const S = Qe(), b = B(f), I = f.map(({ status: P }) => P).filter(Boolean), _ = this.enqueueRequest({
@@ -5426,7 +5426,7 @@ class VP extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       asset_type: e.modelUuid
@@ -5617,7 +5617,7 @@ class xP extends k {
   }
   async bulkAdd(e, i) {
     var f;
-    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Ze(e, Math.min(i ?? e.length, Ye)), u = [], p = [];
+    const { addMany: n, setMany: a, deleteMany: r } = this.actions, o = (/* @__PURE__ */ new Date()).toISOString(), d = ((f = this.client.store.getState().userReducer.currentUser) == null ? void 0 : f.id) ?? null, c = Je(e, Math.min(i ?? e.length, Ze)), u = [], p = [];
     for (const S of c) {
       const b = {}, I = [];
       for (const _ of S) {
@@ -5743,7 +5743,7 @@ class DP extends k {
   }
   bulkAdd(e, i) {
     var S;
-    const { payloads: n, values: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = [], p = Ze(n, Math.min(i ?? n.length, Ye)), y = [];
+    const { payloads: n, values: a } = e, { addMany: r, setMany: o, deleteMany: d } = this.actions, c = (/* @__PURE__ */ new Date()).toISOString(), u = [], p = Je(n, Math.min(i ?? n.length, Ze)), y = [];
     for (const b of p) {
       const I = [];
       for (const _ of b) {
@@ -6230,7 +6230,7 @@ class HP extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       document: e.modelUuid
@@ -6715,7 +6715,7 @@ class YP extends ct {
     const i = await rt(e), n = {
       sha1: i,
       file_type: e.type,
-      extension: Je(e),
+      extension: C(e),
       size: e.size
     };
     return await this.client.files.addCache(e, i), n;
@@ -7329,7 +7329,8 @@ class ig extends k {
       file_name: o.name,
       file_sha1: y.sha1,
       file_type: o.type,
-      file: URL.createObjectURL(o),
+      file_url: URL.createObjectURL(o),
+      file_extension: C(o),
       submitted_at: c,
       created_by: u
     });
@@ -7372,7 +7373,8 @@ class ig extends k {
         file_name: _.name,
         file_sha1: v.sha1,
         file_type: _.type,
-        file: URL.createObjectURL(_),
+        file_url: URL.createObjectURL(_),
+        file_extension: C(_),
         submitted_at: d,
         created_by: c,
         project: i
@@ -7564,7 +7566,7 @@ class ag extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       issue: e.modelUuid
@@ -7627,7 +7629,7 @@ class cg extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       issue_comment: e.modelUuid
@@ -7891,7 +7893,7 @@ class dg extends k {
         ...e[f]
       });
     this.dispatch(a(c));
-    const u = Ze(e, Math.min(i ?? e.length, Ye)), p = [];
+    const u = Je(e, Math.min(i ?? e.length, Ze)), p = [];
     let y = null;
     for (const f of u) {
       const S = Qe(), b = B(f), I = f.map(({ status: P }) => P).filter(Boolean), _ = this.enqueueRequest({
@@ -7988,7 +7990,7 @@ class og extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       issue_type: e.modelUuid
@@ -9124,7 +9126,7 @@ class bg extends et {
       file_sha1: e.file_sha1,
       file_name: e.file.name,
       file_type: e.file.type,
-      file_extension: Je(e.file),
+      file_extension: C(e.file),
       created_by: e.created_by,
       submitted_at: e.submitted_at,
       project: e.modelUuid
@@ -10013,7 +10015,7 @@ export {
   D as IssueUpdateChange,
   Tg as IssueUpdateService,
   Sg as JWTService,
-  Ye as MAX_SERVICE_BATCH_SIZE,
+  Ze as MAX_SERVICE_BATCH_SIZE,
   kc as OUTBOX_RETRY_DELAY,
   GI as OfflineAnalyticsMiddleware,
   mc as OfflineMiddleware,
@@ -10387,7 +10389,7 @@ export {
   lt as getClientStore,
   Hc as getDocumentSubTree,
   V_ as getDocumentTrees,
-  Je as getFileExtension,
+  C as getFileExtension,
   b_ as getFileIdentifier,
   Qt as getFileS3Key,
   qc as getLocalDateString,