@gelabs/ovr 0.1.1 → 0.2.1

package/dist/data-prisma-store.js

@@ -1,5 +1,5 @@
 import { prisma } from './chunk-MKALJTAU.js';
-import { round2, computeCharges, makePaymentRef, fullName, makeOvrTicketNo, addDays, makeBillNo, makeOrderOfPaymentNo, enrich } from './chunk-B634JHKZ.js';
+import { round2, computeCharges, makePaymentRef, fullName, addDays, makeBillNo, makeOrderOfPaymentNo, makeOvrTicketNo, enrich } from './chunk-B634JHKZ.js';
 import 'server-only';
 
 var norm = (s) => s.trim().toLowerCase();
@@ -158,6 +158,89 @@ function createPrismaStore(rules) {
       });
       return enrichRec(toRecord(row), now);
     },
+    async leaseSeqs(count) {
+      const n = Math.max(1, Math.min(500, count));
+      const rows = await prisma.$queryRaw`
+        SELECT nextval('ovr_ticket_seq') AS nextval FROM generate_series(1, ${n})`;
+      return {
+        year: (/* @__PURE__ */ new Date()).getFullYear(),
+        seqs: rows.map((r) => Number(r.nextval))
+      };
+    },
+    async pushTicket(input) {
+      const existing = await prisma.ticket.findFirst({
+        where: {
+          ovrTicketNo: { equals: input.ovrTicketNo, mode: "insensitive" }
+        },
+        include: ticketInclude
+      });
+      if (existing) return enrichRec(toRecord(existing), /* @__PURE__ */ new Date());
+      const created = new Date(input.createdAt);
+      const v = input.violator;
+      const row = await prisma.$transaction(async (tx) => {
+        const officer = await tx.officer.findUnique({
+          where: { id: input.officerId }
+        });
+        if (!officer) throw new Error("Apprehending officer not found.");
+        const codes = input.violations.map((x) => x.catalogCode);
+        const catalog = await tx.violationCatalog.findMany({
+          where: { code: { in: codes } }
+        });
+        const byCode = new Map(catalog.map((c) => [c.code, c]));
+        const violations = input.violations.map((x) => {
+          const c = byCode.get(x.catalogCode);
+          if (!c) throw new Error(`Unknown violation code: ${x.catalogCode}`);
+          return {
+            catalogCode: c.code,
+            title: c.title,
+            basicFine: c.basicFine,
+            details: x.details?.trim() || null
+          };
+        });
+        if (violations.length === 0) {
+          throw new Error("A ticket must include at least one violation.");
+        }
+        const basicFinesTotal = violations.reduce(
+          (s, x) => s + x.basicFine.toNumber(),
+          0
+        );
+        const seq = parseInt(input.ovrTicketNo.split("-").pop() ?? "", 10) || 0;
+        return tx.ticket.create({
+          data: {
+            ovrTicketNo: input.ovrTicketNo,
+            orderOfPaymentNo: makeOrderOfPaymentNo(input.ovrTicketNo),
+            billNo: makeBillNo(
+              created,
+              officer.office,
+              officer.badgeNo ?? "X000",
+              seq
+            ),
+            violatorFirstName: v.firstName,
+            violatorMiddleName: v.middleName?.trim() || null,
+            violatorLastName: v.lastName,
+            violatorStreet: v.street,
+            violatorBarangay: v.barangay?.trim() || null,
+            violatorCityMunicipality: v.cityMunicipality,
+            violatorProvince: v.province,
+            violatorLicenseNumber: v.licenseNumber,
+            violatorPlateNumber: v.plateNumber?.trim() || null,
+            violatorContactNo: v.contactNo?.trim() || null,
+            apprehendedAt: new Date(input.apprehendedAt),
+            placeOfViolation: input.placeOfViolation?.trim() || null,
+            remarks: input.remarks?.trim() || null,
+            officerId: officer.id,
+            assessedAt: created,
+            dueDate: addDays(created, rules.dueWindowDays),
+            basicFinesTotal,
+            paymentStatus: "UNPAID",
+            createdAt: created,
+            violations: { create: violations }
+          },
+          include: ticketInclude
+        });
+      });
+      return enrichRec(toRecord(row), /* @__PURE__ */ new Date());
+    },
     async searchTicket(ovrTicketNo, lastName) {
       const row = await prisma.ticket.findFirst({
         where: {

package/dist/data-seed-runner.d.ts

@@ -1 +1,2 @@
-export * from '@gelabs/ovr-data/seed-runner';
+import type { SeedData } from "./data.js";
+export declare function seedRunner(prisma: import("./generated/client").PrismaClient, data: SeedData): Promise<void>;

package/dist/data.d.ts

@@ -19,6 +19,11 @@ interface NewTicketInput {
     }[];
     remarks?: string;
 }
+/** An offline-issued ticket pushed to the server (client-assigned number + time). */
+interface PushTicketInput extends NewTicketInput {
+    ovrTicketNo: string;
+    createdAt: string;
+}
 interface NewPaymentInput {
     method: PaymentMethod;
 }
@@ -40,6 +45,13 @@ interface DataStore {
     listOfficers(): Promise<Officer[]>;
     getOfficer(id: string): Promise<Officer | null>;
     createTicket(input: NewTicketInput): Promise<Ticket>;
+    /** Reserve a block of global ticket-sequence numbers (offline ID leasing). */
+    leaseSeqs(count: number): Promise<{
+        year: number;
+        seqs: number[];
+    }>;
+    /** Idempotent insert of an offline-issued ticket (client-assigned number). */
+    pushTicket(input: PushTicketInput): Promise<Ticket>;
     searchTicket(ovrTicketNo: string, lastName: string): Promise<Ticket | null>;
     getTicketByNo(ovrTicketNo: string): Promise<Ticket | null>;
     listTickets(filter?: TicketFilter): Promise<Ticket[]>;
@@ -68,4 +80,4 @@ interface SeedData {
     passwordHash: string;
 }
 
-export type { DataStore, MockSeed, NewPaymentInput, NewTicketInput, SeedData, SeedUser, TicketFilter, TicketStats };
+export type { DataStore, MockSeed, NewPaymentInput, NewTicketInput, PushTicketInput, SeedData, SeedUser, TicketFilter, TicketStats };

package/dist/offline.d.ts

@@ -0,0 +1,126 @@
+import Dexie, { EntityTable } from 'dexie';
+import { Violator, Ticket, ViolationCatalogItem, Officer } from './types.js';
+import { R as RulesConfig } from './schema-CdsFQxIg.js';
+import { NewTicketInput, TicketStats } from './data.js';
+import 'zod';
+
+/**
+ * Client-side offline store (IndexedDB via Dexie) — offline-first.
+ *
+ * A local mirror of the data the admin/enforcer needs offline: tickets, the
+ * violation catalog, officers, plus an OUTBOX of tickets issued offline that
+ * still need to be pushed to the API. The admin pages read from HERE (not SSR) so
+ * they work with no internet; a sync loop keeps it fresh (see `sync.ts`).
+ *
+ * Browser-only (Dexie/IndexedDB) — import only from Client Components.
+ */
+
+interface MetaRow {
+    key: string;
+    value: unknown;
+}
+/** A ticket issued offline, queued for an idempotent push. PK = ovrTicketNo. */
+interface OutboxRow {
+    ovrTicketNo: string;
+    createdAt: string;
+    payload: {
+        ovrTicketNo: string;
+        createdAt: string;
+        violator: Violator;
+        apprehendedAt: string;
+        placeOfViolation?: string;
+        officerId: string;
+        violations: {
+            catalogCode: string;
+            details?: string;
+        }[];
+        remarks?: string;
+    };
+    status: "pending" | "error";
+    error?: string;
+}
+declare const db: Dexie & {
+    tickets: EntityTable<Ticket, "ovrTicketNo">;
+    catalog: EntityTable<ViolationCatalogItem, "code">;
+    officers: EntityTable<Officer, "id">;
+    meta: EntityTable<MetaRow, "key">;
+    outbox: EntityTable<OutboxRow, "ovrTicketNo">;
+};
+declare function getMeta<T>(key: string): Promise<T | undefined>;
+declare function setMeta(key: string, value: unknown): Promise<void>;
+
+/** Point the sync client at a different API base (default same-origin `/api`). */
+declare function setOfflineApiBase(base: string): void;
+/** The configured API base — so the auth client targets the same backend. */
+declare function offlineApiBase(): string;
+/** Thrown when an online request hits a dead session — caller must prompt re-login. */
+declare class SessionExpired extends Error {
+    constructor();
+}
+declare function isOnline(): boolean;
+/** Reserve more ticket numbers so offline issuance can keep minting real numbers. */
+declare function ensureLease(min?: number): Promise<void>;
+interface PushResult {
+    ovrTicketNo: string;
+    ok: boolean;
+    ticket?: Ticket;
+    error?: string;
+}
+/** Push queued offline-issued tickets. Idempotent server-side; safe to retry. */
+declare function pushOutbox(): Promise<void>;
+/** Pull server data into the local store — UPSERTS tickets (never clears them). */
+declare function pullAll(): Promise<void>;
+/** Full sync: push local writes, top up the lease, then pull fresh data. */
+declare function sync(): Promise<void>;
+
+/** Issue a ticket from the device. Returns the enriched ticket (shown inline). */
+declare function issueTicketOffline(input: NewTicketInput, rules: RulesConfig): Promise<Ticket>;
+
+/** All locally-stored tickets, newest first. `undefined` while loading. */
+declare function useTickets(): Ticket[] | undefined;
+declare function useCatalog(): ViolationCatalogItem[] | undefined;
+declare function useOfficers(): Officer[] | undefined;
+/** Cached dashboard stats (as-of last sync). `undefined` until first sync. */
+declare function useStats(): TicketStats | undefined;
+/** A single ticket by number: `undefined` while loading, `null` if not stored. */
+declare function useTicket(ovrTicketNo: string): Ticket | undefined | null;
+/** ovrTicketNos still waiting to sync (present in the outbox). Reactive. */
+declare function usePendingSync(): Set<string>;
+interface SyncState {
+    syncing: boolean;
+    online: boolean;
+    error: string | null;
+}
+/** Pull from the API on mount (if online) and whenever connectivity returns. */
+declare function useSync(): SyncState;
+
+interface AdminIdentity {
+    userId: string;
+    username: string;
+    role: string;
+    officerId: string | null;
+}
+type AuthState = {
+    status: "loading";
+} | {
+    status: "authed";
+    user: AdminIdentity;
+} | {
+    status: "unauthed";
+};
+/** The cached admin identity, or undefined. */
+declare function getIdentity(): Promise<AdminIdentity | undefined>;
+/** Drop the cached identity (NOT the offline credential) — used on session expiry
+ *  and logout so a signed-out device can't pass the offline gate. */
+declare function clearIdentity(): Promise<void>;
+/** Client auth gate for the admin shell. Online: validate the cookie via
+ *  /api/auth/me and refresh the cached identity. Offline: trust the cache. */
+declare function useAdminAuth(): AuthState;
+/** Cache an offline-login verifier after a successful ONLINE login (overwrites,
+ *  so a server-side password change self-heals on the next online login). */
+declare function cacheCredential(username: string, password: string, identity: AdminIdentity): Promise<void>;
+/** OFFLINE login: verify the password against the cached verifier. On success it
+ *  sets the active identity and returns it; otherwise null. */
+declare function verifyOffline(username: string, password: string): Promise<AdminIdentity | null>;
+
+export { type AdminIdentity, type AuthState, type MetaRow, type OutboxRow, type PushResult, SessionExpired, type SyncState, cacheCredential, clearIdentity, db, ensureLease, getIdentity, getMeta, isOnline, issueTicketOffline, offlineApiBase, pullAll, pushOutbox, setMeta, setOfflineApiBase, sync, useAdminAuth, useCatalog, useOfficers, usePendingSync, useStats, useSync, useTicket, useTickets, verifyOffline };

package/dist/offline.js

@@ -0,0 +1,376 @@
+"use client";
+import { makeOvrTicketNo, addDays, makeBillNo, makeOrderOfPaymentNo, enrich } from './chunk-B634JHKZ.js';
+import Dexie from 'dexie';
+import { useLiveQuery } from 'dexie-react-hooks';
+import { useState, useEffect } from 'react';
+
+var db = new Dexie("eovr-offline");
+db.version(1).stores({
+  tickets: "ovrTicketNo, paymentStatus, createdAt",
+  catalog: "code, category",
+  officers: "id",
+  meta: "key"
+});
+db.version(2).stores({
+  outbox: "ovrTicketNo, status, createdAt"
+});
+async function getMeta(key) {
+  const row = await db.meta.get(key);
+  return row?.value;
+}
+async function setMeta(key, value) {
+  await db.meta.put({ key, value });
+}
+
+// ../ovr-offline/src/sync.ts
+var API = "/api";
+var LEASE_MIN = 10;
+var LEASE_BATCH = 50;
+function setOfflineApiBase(base) {
+  API = base.replace(/\/$/, "");
+}
+function offlineApiBase() {
+  return API;
+}
+var SessionExpired = class extends Error {
+  constructor() {
+    super("session_expired");
+    this.name = "SessionExpired";
+  }
+};
+function isOnline() {
+  return typeof navigator !== "undefined" ? navigator.onLine : true;
+}
+async function call(path, init) {
+  let res;
+  try {
+    res = await fetch(`${API}${path}`, { credentials: "include", ...init });
+  } catch {
+    return null;
+  }
+  if (res.status === 401) throw new SessionExpired();
+  return res;
+}
+var postInit = (body) => ({
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body)
+});
+async function ensureLease(min = LEASE_MIN) {
+  if (!isOnline()) return;
+  const seqs = await getMeta("leaseSeqs") ?? [];
+  if (seqs.length >= min) return;
+  const res = await call("/sync/lease", postInit({ count: LEASE_BATCH }));
+  if (!res || !res.ok) return;
+  const { seqs: fresh } = await res.json();
+  await setMeta("leaseSeqs", [...seqs, ...fresh]);
+}
+async function pushOutbox() {
+  const pending = await db.outbox.toArray();
+  if (!pending.length) return;
+  const res = await call(
+    "/sync/push",
+    postInit({ tickets: pending.map((p) => p.payload) })
+  );
+  if (!res || !res.ok) return;
+  const { results } = await res.json();
+  await db.transaction("rw", db.outbox, db.tickets, async () => {
+    for (const r of results) {
+      if (r.ok) {
+        await db.outbox.delete(r.ovrTicketNo);
+        if (r.ticket) await db.tickets.put(r.ticket);
+      } else {
+        await db.outbox.update(r.ovrTicketNo, { status: "error", error: r.error });
+      }
+    }
+  });
+}
+async function pullAll() {
+  const [t, c, o, s] = await Promise.all([
+    call("/tickets"),
+    call("/violations"),
+    call("/officers"),
+    call("/tickets/stats")
+  ]);
+  if (!t || !c || !o || !s) return;
+  if (!t.ok || !c.ok || !o.ok || !s.ok) {
+    throw new Error(
+      `sync.pullAll failed: tickets=${t.status} catalog=${c.status} officers=${o.status} stats=${s.status}`
+    );
+  }
+  const tickets = await t.json();
+  const catalog = await c.json();
+  const officers = await o.json();
+  const stats = await s.json();
+  await db.transaction(
+    "rw",
+    db.tickets,
+    db.catalog,
+    db.officers,
+    db.meta,
+    async () => {
+      await db.tickets.bulkPut(tickets);
+      await db.catalog.clear();
+      await db.catalog.bulkPut(catalog);
+      await db.officers.clear();
+      await db.officers.bulkPut(officers);
+      await db.meta.put({ key: "stats", value: stats });
+    }
+  );
+  await setMeta("lastSyncedAt", (/* @__PURE__ */ new Date()).toISOString());
+}
+async function sync() {
+  if (!isOnline()) return;
+  await pushOutbox();
+  await ensureLease();
+  await pullAll();
+}
+
+// ../ovr-offline/src/issue.ts
+async function popSeq() {
+  return db.transaction("rw", db.meta, async () => {
+    const row = await db.meta.get("leaseSeqs");
+    const seqs = row?.value ?? [];
+    if (seqs.length === 0) return null;
+    await db.meta.put({ key: "leaseSeqs", value: seqs.slice(1) });
+    return seqs[0];
+  });
+}
+async function issueTicketOffline(input, rules) {
+  let seq = await popSeq();
+  if (seq === null && isOnline()) {
+    await ensureLease(50);
+    seq = await popSeq();
+  }
+  if (seq === null) {
+    throw new Error(
+      isOnline() ? "Couldn't reserve ticket numbers \u2014 please try again." : "No offline ticket numbers left. Reconnect to the internet to reserve more."
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ovrTicketNo = makeOvrTicketNo(rules.idPrefix, now.getFullYear(), seq);
+  const officer = await db.officers.get(input.officerId);
+  if (!officer) {
+    const cur = await getMeta("leaseSeqs") ?? [];
+    await setMeta("leaseSeqs", [seq, ...cur]);
+    throw new Error("That officer isn't available offline. Sync and try again.");
+  }
+  const catalog = await db.catalog.toArray();
+  const byCode = new Map(catalog.map((c) => [c.code, c]));
+  const violations = input.violations.map((x) => {
+    const c = byCode.get(x.catalogCode);
+    if (!c) throw new Error(`Unknown violation: ${x.catalogCode}`);
+    const v = {
+      catalogCode: c.code,
+      title: c.title,
+      basicFine: c.basicFine
+    };
+    if (x.details?.trim()) v.details = x.details.trim();
+    return v;
+  });
+  const basicFinesTotal = violations.reduce((s, v) => s + v.basicFine, 0);
+  const record = {
+    ovrTicketNo,
+    orderOfPaymentNo: makeOrderOfPaymentNo(ovrTicketNo),
+    billNo: makeBillNo(now, officer.office, officer.badgeNo ?? "X000", seq),
+    violator: input.violator,
+    apprehendedAt: input.apprehendedAt,
+    officer,
+    violations,
+    assessedAt: now.toISOString(),
+    dueDate: addDays(now, rules.dueWindowDays).toISOString(),
+    basicFinesTotal,
+    paymentStatus: "UNPAID",
+    createdAt: now.toISOString()
+  };
+  if (input.placeOfViolation?.trim())
+    record.placeOfViolation = input.placeOfViolation.trim();
+  if (input.remarks?.trim()) record.remarks = input.remarks.trim();
+  const ticket = enrich(record, now, rules.surchargeRatePerMonth);
+  await db.transaction("rw", db.tickets, db.outbox, async () => {
+    await db.tickets.put(ticket);
+    await db.outbox.put({
+      ovrTicketNo,
+      createdAt: record.createdAt,
+      status: "pending",
+      payload: {
+        ovrTicketNo,
+        createdAt: record.createdAt,
+        violator: input.violator,
+        apprehendedAt: input.apprehendedAt,
+        ...record.placeOfViolation ? { placeOfViolation: record.placeOfViolation } : {},
+        officerId: input.officerId,
+        violations: input.violations,
+        ...record.remarks ? { remarks: record.remarks } : {}
+      }
+    });
+  });
+  if (isOnline()) void pushOutbox().catch(() => {
+  });
+  return ticket;
+}
+async function getIdentity() {
+  return await getMeta("identity") ?? void 0;
+}
+async function clearIdentity() {
+  await setMeta("identity", null);
+}
+function useAdminAuth() {
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      const cached = await getMeta("identity");
+      if (isOnline()) {
+        try {
+          const res = await fetch(`${offlineApiBase()}/auth/me`, {
+            credentials: "include"
+          });
+          if (res.ok) {
+            const { user } = await res.json();
+            await setMeta("identity", user);
+            if (!cancelled) setState({ status: "authed", user });
+            return;
+          }
+          await setMeta("identity", null);
+          if (!cancelled) setState({ status: "unauthed" });
+          return;
+        } catch {
+        }
+      }
+      if (!cancelled) {
+        setState(
+          cached ? { status: "authed", user: cached } : { status: "unauthed" }
+        );
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return state;
+}
+var PBKDF2_ITERATIONS = 21e4;
+function subtle() {
+  return typeof crypto !== "undefined" && crypto.subtle ? crypto.subtle : null;
+}
+var toHex = (buf) => Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, "0")).join(
+  ""
+);
+function fromHex(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++)
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+async function deriveHashHex(password, salt, iterations) {
+  const s = subtle();
+  if (!s) return null;
+  const keyMaterial = await s.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const bits = await s.deriveBits(
+    { name: "PBKDF2", salt, iterations, hash: "SHA-256" },
+    keyMaterial,
+    256
+  );
+  return toHex(bits);
+}
+async function cacheCredential(username, password, identity) {
+  if (!subtle()) return;
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const hashHex = await deriveHashHex(password, salt, PBKDF2_ITERATIONS);
+  if (!hashHex) return;
+  const cred = {
+    username: username.trim(),
+    saltHex: toHex(salt.buffer),
+    hashHex,
+    iterations: PBKDF2_ITERATIONS,
+    identity
+  };
+  await setMeta("credential", cred);
+}
+async function verifyOffline(username, password) {
+  const cred = await getMeta("credential");
+  if (!cred || cred.username !== username.trim()) return null;
+  const hashHex = await deriveHashHex(
+    password,
+    fromHex(cred.saltHex),
+    cred.iterations
+  );
+  if (!hashHex || hashHex !== cred.hashHex) return null;
+  await setMeta("identity", cred.identity);
+  return cred.identity;
+}
+
+// ../ovr-offline/src/hooks.ts
+function useTickets() {
+  return useLiveQuery(() => db.tickets.orderBy("createdAt").reverse().toArray());
+}
+function useCatalog() {
+  return useLiveQuery(() => db.catalog.orderBy("category").toArray());
+}
+function useOfficers() {
+  return useLiveQuery(() => db.officers.toArray());
+}
+function useStats() {
+  return useLiveQuery(
+    async () => (await db.meta.get("stats"))?.value
+  );
+}
+function useTicket(ovrTicketNo) {
+  return useLiveQuery(
+    async () => await db.tickets.get(ovrTicketNo) ?? null,
+    [ovrTicketNo]
+  );
+}
+function usePendingSync() {
+  const rows = useLiveQuery(() => db.outbox.toArray());
+  return new Set((rows ?? []).map((r) => r.ovrTicketNo));
+}
+function useSync() {
+  const [syncing, setSyncing] = useState(false);
+  const [online, setOnline] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    setOnline(isOnline());
+    async function runSyncCycle() {
+      if (!isOnline()) return;
+      setSyncing(true);
+      setError(null);
+      try {
+        await sync();
+      } catch (e) {
+        if (e instanceof SessionExpired) {
+          await clearIdentity();
+          window.location.assign("/admin/login");
+          return;
+        }
+        if (!cancelled) setError(e instanceof Error ? e.message : "sync failed");
+      } finally {
+        if (!cancelled) setSyncing(false);
+      }
+    }
+    const onOnline = () => {
+      setOnline(true);
+      void runSyncCycle();
+    };
+    const onOffline = () => setOnline(false);
+    void runSyncCycle();
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("online", onOnline);
+      window.removeEventListener("offline", onOffline);
+    };
+  }, []);
+  return { syncing, online, error };
+}
+
+export { SessionExpired, cacheCredential, clearIdentity, db, ensureLease, getIdentity, getMeta, isOnline, issueTicketOffline, offlineApiBase, pullAll, pushOutbox, setMeta, setOfflineApiBase, sync, useAdminAuth, useCatalog, useOfficers, usePendingSync, useStats, useSync, useTicket, useTickets, verifyOffline };

package/dist/{types-DrrNO_Ak.d.ts → types-CtBC5-TW.d.ts}

@@ -102,6 +102,14 @@ declare const baseCopy: {
         readonly tickets: "Tickets";
         readonly issueTicket: "Issue ticket";
         readonly newTicketTitle: "Issue Violation Ticket";
+        readonly sync: {
+            readonly offline: "Offline";
+            readonly syncing: "Syncing…";
+            readonly synced: "Synced";
+            readonly pending: "pending sync";
+            readonly notSynced: "Not synced";
+            readonly willSync: "Saved on this device — will sync when back online.";
+        };
     };
 };
 

package/dist/ui-components-admin/admin-nav.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+
+declare function AdminNav({ signOutAction, }: {
+    signOutAction: () => Promise<void>;
+}): React.JSX.Element;
+
+export { AdminNav };