@7365admin1/core 3.42.3 → 3.43.0

package/dist/index.d.ts

@@ -2561,6 +2561,1001 @@ declare function useSiteCameraController(): {
     deleteById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };
 
+/**
+ * Camera-view rules, as pure functions.
+ *
+ * Everything in this file is decidable without a network, a database or an
+ * Express request, which is the point: the access rules and the Dahua protocol
+ * details below are the parts that must not silently rot, and they are the parts
+ * that are otherwise impossible to test without a camera on a desk.
+ *
+ * Endpoint and page references are to Dahua HTTP API V3.37.
+ */
+/** Dahua `site.cameras.type` values. Only `ip` units serve pictures — see below. */
+declare const CAMERA_TYPE_IP = "ip";
+declare const CAMERA_TYPE_ANPR = "anpr";
+/**
+ * The domain rule, and it is a product decision, not a technical workaround
+ * (owner, 2026-08-07): **ANPR is a different estate from Virtual Patrol and
+ * CCTV.** ANPR units belong to visitor management and vehicle management, where
+ * they already work; they are not patrol checkpoints and they are not monitoring
+ * cameras. So Patrol and CCTV see `type: "ip"` cameras and nothing else.
+ *
+ * That is why an ANPR record is REFUSED here rather than carried through as a
+ * special case with a "cannot serve a picture" label: it is not a camera this
+ * feature is allowed to touch at all. Nothing in the visitor or vehicle path
+ * reads this file, so the working ANPR flows are untouched.
+ *
+ * The vendor spec agrees, incidentally — V3.37 §10.4.4 (p.538), verbatim: *"For
+ * intelligent traffic device, it should use this method to take a snapshot. But,
+ * the response is not image data."* — but the reason we refuse is the domain
+ * rule, and it would still hold if a future firmware returned a JPEG.
+ */
+declare const CAMERA_NOT_PATROL_OR_CCTV = "This is an ANPR unit. ANPR belongs to visitor and vehicle management; Virtual Patrol and CCTV use IP cameras only.";
+/**
+ * Is this a camera Virtual Patrol or CCTV may use at all?
+ *
+ * The single gate for every per-camera request, so a new endpoint cannot forget
+ * it — and the reason it is a predicate rather than an inline `!==` is that the
+ * rule now has a name a reviewer can look up.
+ */
+declare function isPatrolCctvCamera(camera: {
+    type?: string;
+} | null): boolean;
+/**
+ * The same rule as a database filter, for the listing paths.
+ *
+ * A wall that renders ANPR tiles as "unsupported" is still showing a supervisor
+ * cameras from a module they are not looking at. They are excluded by the query,
+ * so they cost neither a tile nor a probe.
+ */
+declare const PATROL_CCTV_CAMERA_FILTER: {
+    type: string;
+};
+/**
+ * Permission strings that may VIEW a camera.
+ *
+ * Measured, not chosen: these are the catalogued Virtual Patrol read strings, and
+ * their union reaches 25 of 36 security members on staging once wildcards are
+ * counted (the same union the client-side read gate uses). Spelling is verbatim
+ * production spelling — never "corrected".
+ */
+declare const CAMERA_VIEW_PERMISSIONS: string[];
+/**
+ * Permission strings that may MOVE a camera.
+ *
+ * Stricter on purpose: viewing a picture is a read, PTZ turns a motor. Only a
+ * role that may actually start a patrol may steer a camera during one.
+ */
+declare const CAMERA_PTZ_PERMISSIONS: string[];
+/** `*` is the estate's wildcard permission and is honoured everywhere else too. */
+declare function hasAnyPermission(permissions: unknown, allowed: Array<string>): boolean;
+/** One row of `members`, as much of it as an entitlement decision needs. */
+type CameraMembership = {
+    siteId?: unknown;
+    org?: unknown;
+    /**
+     * The role this membership carries. Returned with the grant so permissions
+     * are read off the role that actually granted access — see
+     * `permissionsForGrant` in the service.
+     */
+    role?: unknown;
+};
+/**
+ * WHICH membership lets this caller reach this site, or `null` for none.
+ *
+ * Three sources, in order of how directly they say "this person works here":
+ *
+ * 1. **A membership at the site itself** (`members.siteId`). 277 of the 367 live
+ *    membership rows are recorded this way.
+ * 2. **A membership at the site's OWNING organisation, with no site on it** —
+ *    an org-wide role. 90 rows, 56 people, are recorded this way.
+ * 3. **An engagement** — an ACTIVE `customer.sites` row saying one of the
+ *    caller's organisations is contracted to serve this site, AND a membership
+ *    that is not pinned to some other site. This is how the product routes a
+ *    security agency to a property manager's site, and it is the list the web
+ *    apps' own site switcher is built from (`useCustomerSite().getAll()` in the
+ *    Security app's layout). Nothing in the camera path read it before, so a
+ *    guard whose agency is engaged at a site was refused a camera the switcher
+ *    had just offered them.
+ *
+ * ## Why the engagement branch requires an ORG-LEVEL membership
+ *
+ * **Product decision, owner, 2026-08-10, settled:** an agency engaged at several
+ * sites gives its staff access to **the site each person is assigned to, and no
+ * other**. It matches how the rest of the product is described — modules are set
+ * up per site.
+ *
+ * So `!idOf(membership.siteId)` is required here exactly as branch 2 requires
+ * it. Before, this branch matched on organisation alone, which made a person
+ * pinned to site X reach every site their agency serves — while somebody pinned
+ * to site X of the site's OWNING organisation could not reach its other sites.
+ * The two branches now say the same thing: **a membership pinned to a site never
+ * grants a different site**, and a membership with no site is an org-wide role
+ * within whichever organisation holds it.
+ *
+ * Measured on staging before the change: this removes 68 (user, camera-site)
+ * grants, all of them cross-organisation engagements held by a membership pinned
+ * elsewhere; every one of those 68 belongs to somebody whose organisation is
+ * engaged at the site they ARE pinned to, so nobody is left without their own
+ * site. 0 grants through branch 2 are affected — **estate-side org-level access
+ * is a different path and is untouched.**
+ *
+ * The membership is RETURNED, not just a yes/no, because the caller's
+ * permissions must then be resolved against the organisation that actually
+ * granted access — see `getUserPermissions` in the service. Resolving them
+ * against an arbitrary row (`memberships[0]`) is wrong for the 22 people who
+ * belong to more than one organisation.
+ *
+ * Ids are compared as strings so an ObjectId and its hex form match.
+ */
+declare function cameraGrant(params: {
+    cameraSite?: unknown;
+    cameraOrg?: unknown;
+    memberships: Array<CameraMembership>;
+    /**
+     * The caller's organisations that hold an ACTIVE engagement to THIS site.
+     * The query that fills it is already scoped to the site, so membership of one
+     * of these organisations is the whole test here.
+     */
+    engagedOrgs?: Set<string>;
+}): CameraMembership | null;
+/** `cameraGrant` as a yes/no, for the places that do not need to know which. */
+declare function isCameraEntitled(params: {
+    cameraSite?: unknown;
+    cameraOrg?: unknown;
+    memberships: Array<CameraMembership>;
+    engagedOrgs?: Set<string>;
+}): boolean;
+/**
+ * Why this camera cannot serve a picture, or `null` when it can.
+ *
+ * Returned rather than thrown so the caller decides the HTTP status, and so the
+ * whole rule set is one assertion in a test.
+ */
+declare function snapshotRefusalReason(camera: {
+    type?: string;
+    status?: string;
+    host?: string;
+} | null, devices?: Record<string, CameraDevice>): string | null;
+/**
+ * `site.cameras.host` is stored with or without a scheme depending on who added
+ * the record. Default to `http://` rather than `https://`: 9 of the 17 hosts in
+ * the estate are cleartext today (integration audit R8), and silently upgrading
+ * them would turn a working camera into a TLS error.
+ *
+ * ponytail: no URL library. Trailing-slash trim + scheme default is the whole
+ * job; swap in `new URL()` if hosts ever carry paths or ports we must rewrite.
+ */
+declare function cameraBaseUrl(host: string): string;
+/**
+ * **`site.cameras.host` is not a device address for an `ip` camera.** Measured
+ * across the whole estate, 2026-08-09: every active `ip` record stores the CCTV
+ * relay's *page* URL — `https://<relay-authority>/<channel>` — and the numeric
+ * last path segment is the **stream channel** on the recorder the relay reads.
+ *
+ * So a camera resolves in two parts:
+ *
+ * | Part | Comes from |
+ * |---|---|
+ * | which device | server configuration, keyed by the relay authority |
+ * | which stream on it | the stored host's last path segment |
+ *
+ * The device address and its credential live in deployment configuration and
+ * **never in the database and never in the client** — the same rule as every
+ * other secret in this estate, and the reason this file only ever returns a
+ * resolved device to server-side callers.
+ */
+type CameraDevice = {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+};
+/**
+ * `CAMERA_RTSP_DEVICES` — a JSON object keyed by relay authority:
+ *
+ * ```
+ * {"<relay-authority>":{"host":"…","port":554,"username":"…","password":"…"}}
+ * ```
+ *
+ * One variable rather than a per-authority naming scheme, because the estate has
+ * exactly one relay today and an unknown number tomorrow; adding the second one
+ * is a config edit, not a code change. Malformed JSON yields no devices — every
+ * camera then refuses with a reason, which is the correct failure for a
+ * misconfigured server and is far better than a half-parsed device map.
+ */
+declare function cameraDevices(env?: Record<string, string | undefined>): Record<string, CameraDevice>;
+/**
+ * The relay authority and the channel a stored host stands for.
+ *
+ * `null` channel means the host carries no numeric last segment — one record in
+ * the estate is like that, and it is genuinely unresolvable rather than a
+ * defaulted channel 1, which would silently show the wrong camera.
+ */
+declare function parseCameraHost(host: string): {
+    authority: string;
+    channel: number | null;
+} | null;
+/** The device + channel a camera record stands for, or `null` if it does not. */
+declare function resolveCamera(host: string | undefined, devices?: Record<string, CameraDevice>): {
+    device: CameraDevice;
+    channel: number;
+} | null;
+/**
+ * Why a stored host cannot be resolved to a device, or `null` when it can.
+ *
+ * Three distinct reasons on purpose — a lead reading a tile must be able to tell
+ * "nobody configured this relay" (a deployment fix) from "this record is a
+ * placeholder" (a data fix). The estate has all three today: 12 cameras resolve,
+ * two are `example.com` placeholders and one host carries no channel.
+ */
+declare function resolutionRefusalReason(host: string | undefined, devices?: Record<string, CameraDevice>): string | null;
+/**
+ * The highest channel number worth accepting from a form.
+ *
+ * A bound, not a claim about any unit: a recorder answers for the channels it
+ * has, and asking for 900 is a typo rather than a camera. 256 is comfortably
+ * above the largest Dahua NVR channel count.
+ */
+declare const MAX_CAMERA_CHANNEL = 256;
+/** A channel number a person typed, or `null` if it is not one. */
+declare function parseCameraChannel(value: unknown): number | null;
+/**
+ * Which relay serves a given recorder — the configured map, read backwards.
+ *
+ * `cameraDevices()` answers "given a relay, which recorder?", because that is
+ * the question a stored record asks. Setting a camera UP asks the opposite: the
+ * person has the recorder in front of them and no idea what a relay is. Same
+ * single source of truth either way; there is deliberately no second map to
+ * keep in step.
+ *
+ * ponytail: linear scan over the configured recorders. The estate has one; if
+ * it ever has hundreds, build the reverse index once at module load.
+ */
+declare function relayForRecorder(recorderHost: string | undefined, recorderPort: number | undefined, devices?: Record<string, CameraDevice>): string | null;
+/**
+ * Permission strings that may SET UP a camera.
+ *
+ * Verbatim production spelling, and the same string the web form already gates
+ * the CCTV panel on (`useSettingsPermission.ts`), so the server enforces what
+ * the client has always drawn rather than a second opinion invented here.
+ */
+declare const CAMERA_SETUP_PERMISSIONS: string[];
+/**
+ * The ANPR half of the same panel.
+ *
+ * `POST`/`PATCH`/`DELETE /site-cameras` is ONE endpoint serving two panels, and
+ * the Settings page draws them on two different strings: the CCTV panel on
+ * `manage-cctv-camera`, the ANPR panel on `manage-anpr-camera`
+ * (`SiteSettings.vue:79` and `:121`). Enforcing only the CCTV string would
+ * refuse a role provisioned to manage ANPR and nothing else — so the server
+ * asks the same question the client asked before it drew the button.
+ */
+declare const CAMERA_ANPR_PERMISSIONS: string[];
+/**
+ * Which of the two a write needs, from the camera's own `type`.
+ *
+ * Anything that is not ANPR is treated as CCTV: `type` is validated to
+ * `ip | anpr` by the model, and defaulting an unrecognised value to the CCTV
+ * string fails towards asking for a permission rather than towards asking for
+ * none.
+ */
+declare function cameraManagePermissions(type: unknown): Array<string>;
+/**
+ * A "Test this camera" button is exactly the thing that locks a recorder: press
+ * it four times with a wrong credential and V3.37 §4.7.x takes the account away
+ * for half an hour — on a unit that in this estate also runs ANPR and a barrier.
+ *
+ * So a test is rationed twice over, before it can be attempted at all: not the
+ * same camera twice inside `MIN_INTERVAL`, and not more than `ROUND_LIMIT`
+ * against one recorder inside `ROUND_SECONDS`. Both sit far below the device's
+ * own 3-in-30-seconds trigger, and they are checked BEFORE the shared
+ * authentication budget is touched — so an impatient user runs out of tests
+ * long before the recorder runs out of patience.
+ */
+declare const CAMERA_TEST_MIN_INTERVAL_SECONDS = 15;
+declare const CAMERA_TEST_ROUND_LIMIT = 4;
+declare const CAMERA_TEST_ROUND_SECONDS = 300;
+/** What a test can conclude. One of these, always, and never a stack trace. */
+type CameraTestStatus = "working" | "no-video" | "credential-refused" | "unreachable" | "cannot-test";
+/** What the setup form was asked for, before anything is derived from it. */
+type CameraAddressInput = {
+    recorderHost?: string;
+    recorderPort?: number | string;
+    channel?: number | string;
+};
+/**
+ * Turn what a person can read off a recorder into the address the product
+ * stores — or say, in their words, why it cannot be done.
+ *
+ * This is the whole point of the guided form. The stored address is a relay
+ * player page (`https://<relay-authority>/<channel>`), which nothing printed on
+ * a camera will ever tell you; the server knows which relay carries which
+ * recorder, so the server builds it. The person supplies the recorder and the
+ * channel, which are on a label and in the recorder's own channel list.
+ *
+ * A refusal is a sentence for the person at the form, never a code and never an
+ * address: an unrecognised recorder means somebody has to connect it to the
+ * video service, and that is a request to their technical team, not a retry.
+ */
+declare function deriveCameraHost(input: CameraAddressInput, devices?: Record<string, CameraDevice>): {
+    host: string;
+} | {
+    refusal: string;
+};
+/**
+ * The RTSP URL for one channel. **Carries the credential — never log it, never
+ * return it, never put it in an error message.**
+ *
+ * The path is the recorder's own (`/cam/realmonitor`), which is what the CCTV
+ * relay has always used; `subtype=1` is the low-bitrate substream and is what a
+ * wall tile wants, `subtype=0` is the full-resolution main stream and is what an
+ * evidence capture wants.
+ */
+declare function rtspUrl(device: CameraDevice, channel: number, subtype?: 0 | 1): string;
+/**
+ * ffmpeg arguments for "one frame, as JPEG, on stdout".
+ *
+ * Separated from the spawn so the arguments are testable without a camera, and
+ * kept deliberately small: TCP transport (the relay uses it and UDP loses frames
+ * across the internet), a single frame, no audio, and nothing that could write
+ * to the device — RTSP `PLAY` is a read.
+ */
+declare function ffmpegFrameArgs(url: string): Array<string>;
+/**
+ * Measured against the live recorder on 2026-08-10: a substream frame arrives in
+ * 7–9 s (RTSP setup plus the wait for a keyframe), three concurrent pulls showed
+ * no degradation. The old 8 s HTTP budget would have timed out most frames, so
+ * this is a separate, larger budget rather than a reuse of it.
+ */
+declare const CAMERA_RTSP_TIMEOUT_MS = 15000;
+/** `ffmpeg` on PATH by default; overridable where the host keeps it elsewhere. */
+declare function ffmpegPath(env?: Record<string, string | undefined>): string;
+/** §4.4.2, p.63 — `type=0` is "from the front end", i.e. the live picture. */
+declare function snapshotEndpoint(channel?: number): string;
+/** §4.6.14, p.114 — the cheapest call that completes a full digest handshake. */
+declare const SOFTWARE_VERSION_ENDPOINT = "/cgi-bin/magicBox.cgi?action=getSoftwareVersion";
+/** §4.6.2, p.106 — read-only. `setCurrentTime` (§4.6.3) is a write and is not ours. */
+declare const CURRENT_TIME_ENDPOINT = "/cgi-bin/global.cgi?action=getCurrentTime";
+/**
+ * PTZ movement codes we are willing to send (§8.1.5, p.297).
+ *
+ * An allow-list, not a pass-through. The full `code` set in §8.1 also covers
+ * presets, tours and patterns — those WRITE device configuration, and this
+ * integration issues no configuration writes to any device.
+ */
+declare const PTZ_ALLOWED_CODES: string[];
+declare const PTZ_ALLOWED_ACTIONS: string[];
+/**
+ * §8.1.5, p.297. Every value is percent-encoded — the same class of defect
+ * `iservice365-core` #1803 fixed on the plate endpoints, where an unencoded
+ * value silently changed the request the device saw.
+ */
+declare function ptzEndpoint(params: {
+    action: string;
+    channel?: number;
+    code: string;
+    speed?: number;
+}): string;
+/** §8.1.5 speeds run 1..8. Anything else is coerced, never passed through. */
+declare function clampPtzSpeed(speed: unknown): number;
+/** `version=3.140.0000000.0\nBuildDate=...` → `3.140.0000000.0`. */
+declare function parseSoftwareVersion(body: string): string | null;
+/** `result=2026-08-09 21:30:00` → the same string. */
+declare function parseDeviceTime(body: string): string | null;
+/**
+ * How far the camera's clock is from ours, in seconds.
+ *
+ * The device reports LOCAL time with no offset, and the estate runs on Singapore
+ * time (the product-wide rule), so it is compared against a fixed +8h — never
+ * against the API host's own timezone, which is how the patrol-log day windows
+ * went wrong in the first place.
+ *
+ * `null` when the device did not give a parseable time; a drifted clock and an
+ * unreadable one are different facts and must not collapse into "0".
+ */
+declare function clockDriftSeconds(deviceTime: string | null, now: Date): number | null;
+/**
+ * A camera is "healthy" when it answered at all. Firmware and clock are extra
+ * detail; reachability is the signal the guardhouse actually needs, because
+ * today `site.cameras.status` is OUR field and never the device's.
+ *
+ * A drift beyond a minute is called out separately: ANPR transactions are
+ * timestamped from the device, so a drifted clock puts events in the wrong place
+ * in the timeline and nothing currently notices.
+ */
+declare const CLOCK_DRIFT_WARN_SECONDS = 60;
+declare function cameraHealthSummary(params: {
+    reachable: boolean;
+    driftSeconds: number | null;
+}): "ok" | "drifted" | "unreachable";
+/**
+ * Hard ceiling on a proxied picture.
+ *
+ * The device sits on the public internet, so an unbounded read is a way to hang
+ * an API worker. 8 MB clears a 4K JPEG with room to spare and stops well short of
+ * anything that could only be a fault or a hostile response.
+ *
+ * ponytail: checked after the response is buffered, not streamed with a running
+ * counter — the request timeout already bounds how long a body can arrive for.
+ * Move to a streaming counter if a device is ever found that trickles.
+ */
+declare const CAMERA_SNAPSHOT_MAX_BYTES: number;
+/** Short, because this call sits on a guard's screen and a camera may be down. */
+declare const CAMERA_REQUEST_TIMEOUT_MS = 8000;
+/**
+ * Server-side snapshot cache, in seconds.
+ *
+ * The single most important number here. V3.37 does not document how many
+ * concurrent pulls a unit tolerates (searched — it is simply absent), so N guards
+ * watching one camera must cost ONE device request, not N.
+ */
+declare const CAMERA_SNAPSHOT_CACHE_SECONDS = 2;
+/**
+ * Fields of a camera record that may cross the wire.
+ *
+ * Still an allow-list, not a delete-list: `username` and `password` must never
+ * reach a client or a log, and a future field added to the model must be opted
+ * IN rather than remembered about.
+ *
+ * ## Why `host` is now in it, for `ip` cameras only
+ *
+ * For a `type: "ip"` camera the stored `host` is **not** a device address and
+ * **not** a credential — it is the video relay's own player-page URL, and
+ * putting it in a WebView is how the live security app has shown motion video
+ * for months (traced end to end, 2026-08-10). Stripping it here is what stops a
+ * client from rendering the one path that demonstrably works.
+ *
+ * **It is not a new disclosure.** `GET /site-cameras` already returns `host` to
+ * every authenticated caller — `site-camera.repo.ts` projects `{ password: 0 }`
+ * and nothing else — which is exactly where the legacy app reads it from. This
+ * makes the wall consistent with the endpoint next to it rather than widening
+ * anything.
+ *
+ * **`anpr` is excluded and that is the whole reason this is conditional.** An
+ * ANPR record's `host` IS a real device endpoint, on a unit that also has a real
+ * `username` beside it, so handing one to a client would be a genuine leak. No
+ * patrol or CCTV path ever loads an ANPR record — but the allow-list must hold
+ * on its own, not because of a filter somewhere else.
+ */
+declare function publicCameraFields(camera: Record<string, any>): Record<string, any>;
+/**
+ * Tuning for a multi-camera wall, read from the environment.
+ *
+ * **Every number here is a guess that must be measured against a real device**,
+ * which is exactly why the client is not allowed to hold its own copy: the wall
+ * endpoint hands these to the app, so an environment that finds its cameras
+ * cannot take nine simultaneous pulls is retuned by a deployment variable and not
+ * by an app-store release.
+ *
+ * V3.37 documents no concurrent-connection limit for any unit — it is absent, not
+ * generous — so the defaults are deliberately slow and small.
+ */
+declare function wallConfig(env?: Record<string, string | undefined>): {
+    /** A wall is situational awareness, not evidence. 5 s per tile is watchable. */
+    snapshotPollMs: number;
+    /**
+     * Single-camera view. Matches `CAMERA_SNAPSHOT_CACHE_SECONDS` exactly —
+     * polling faster than the cache costs round trips and never device requests,
+     * so there is no point going below it and real harm in going far below it.
+     */
+    singlePollMs: number;
+    /** The 3x3 ceiling, enforced here as well as in the client's layout list. */
+    maxTiles: number;
+    /** How many cameras a health sweep probes at once. */
+    maxConcurrentProbes: number;
+    /** Health changes slowly; N supervisors on one wall should be one probe. */
+    healthCacheSeconds: number;
+};
+/**
+ * Runs `worker` over `items`, at most `limit` at a time.
+ *
+ * The whole reason the wall has a backend change at all. Nine tiles asking for
+ * health separately is eighteen device requests fired at once; this makes it four
+ * in flight regardless of how many tiles the supervisor opens.
+ *
+ * ponytail: index-cursor over N workers rather than a queue library — the input is
+ * bounded by `maxTiles` and this is the entire semantics needed.
+ */
+declare function mapWithLimit<T, R>(items: Array<T>, limit: number, worker: (item: T) => Promise<R>): Promise<Array<R>>;
+
+/**
+ * What a camera can actually do RIGHT NOW, and which transport would do it.
+ *
+ * ## Why this file exists
+ *
+ * The estate has three different ways to reach a camera and they do not overlap:
+ *
+ * | Transport | What it carries | Proven today? |
+ * |---|---|---|
+ * | `RELAY_PLAYER` | the stored player-page URL, rendered in a WebView — one-way MPEG1 over a WebSocket | **YES** — this is how the live product has shown CCTV for months |
+ * | `RTSP_FRAME` | one `ffmpeg` still off the recorder's RTSP stream | **YES** — measured against the live recorder, 2026-08-10 |
+ * | `DEVICE_HTTP` | the camera's own CGI API — PTZ, presets, recordings, events, device info | **NO** — written, disabled, and unreachable from our hosts today (80/443/37777 time out; only 554 answers) |
+ *
+ * A client cannot be expected to know any of that. So the server computes it,
+ * per camera, per capability, and hands back a descriptor the UI renders itself
+ * from — with a machine-readable reason whenever the answer is no. **That
+ * descriptor is the contract that lets a capability light up later by
+ * configuration instead of by a code change.**
+ *
+ * ## Three states, never two
+ *
+ * `supported` / `unsupported` / `unknown`. `unknown` is load-bearing: a camera
+ * whose control interface we have never been allowed to ask is NOT the same as a
+ * camera that has told us it cannot pan. Collapsing the two is how a UI ends up
+ * hiding a feature that works, or offering one that does not.
+ *
+ * Nothing in this file performs I/O, so the whole rule set is assertable in a
+ * test without a camera, a recorder, a network or a database.
+ *
+ * Section references are to Dahua HTTP API V3.37.
+ */
+
+/**
+ * Every capability the UI may ask about.
+ *
+ * A fixed list rather than an open string, because a client that renders itself
+ * from this descriptor has to be able to exhaust it. Adding one is a deliberate
+ * change here plus a transport that declares it.
+ */
+declare const CAMERA_CAPABILITIES: readonly ["liveVideo", "stillFrame", "digitalZoom", "ptz", "presets", "playback", "events", "audio", "deviceInfo"];
+type CameraCapability = (typeof CAMERA_CAPABILITIES)[number];
+type CameraCapabilityState = "supported" | "unsupported" | "unknown";
+/** Transport ids. Strings, not an enum, so a new one can be registered. */
+declare const TRANSPORT_RELAY_PLAYER = "RELAY_PLAYER";
+declare const TRANSPORT_RTSP_FRAME = "RTSP_FRAME";
+declare const TRANSPORT_DEVICE_HTTP = "DEVICE_HTTP";
+/**
+ * Machine-readable reasons, each with the one sentence a UI may show.
+ *
+ * The CODE is the contract — a client switches on it and never parses prose.
+ * The sentence is here so that a client which has nothing better to show has
+ * something honest to show, and so the same wording cannot drift between two
+ * screens.
+ *
+ * Four of these are worded identically to `camera-view.util`'s refusal
+ * sentences, on purpose: the mobile app already displays those strings, and a
+ * camera must not explain itself two different ways depending on which field
+ * was read. A test pins them equal.
+ */
+declare const CAMERA_CAPABILITY_REASONS: {
+    readonly "not-patrol-cctv-camera": "This is an ANPR unit. ANPR belongs to visitor and vehicle management; Virtual Patrol and CCTV use IP cameras only.";
+    readonly "camera-inactive": "This camera is not active.";
+    readonly "no-address": "This camera has no address configured.";
+    readonly "invalid-address": "This camera's address is not a valid address.";
+    readonly "not-a-relay-player-url": "This camera's address is not a live-video page address.";
+    readonly "no-recorder-configured": "No recorder is configured for this camera's relay.";
+    readonly "no-channel-in-address": "This camera's address has no channel, so we cannot tell which stream it is.";
+    readonly "device-http-not-configured": "No direct connection to this camera's recorder is configured on this server.";
+    readonly "device-http-disabled": "Direct camera access is switched off on this server.";
+    readonly "device-http-unreachable": "The camera's own control interface did not answer.";
+    readonly "device-http-locked-out": "Too many rejected sign-ins: further attempts are being held back so the recorder's account is not locked.";
+    readonly "device-not-probed": "This camera has not been asked what it can do yet.";
+    readonly "device-no-ptz": "This camera does not move.";
+    readonly "control-not-enabled": "Camera control is switched off on this server.";
+    readonly "no-transport": "Nothing on this server can do that yet.";
+};
+type CameraCapabilityReason = keyof typeof CAMERA_CAPABILITY_REASONS;
+/** One capability's answer. `transport` is `null` whenever nothing can serve it. */
+type CameraCapabilityEntry = {
+    state: CameraCapabilityState;
+    transport: string | null;
+    reason: CameraCapabilityReason | null;
+    /** The sentence for `reason`, so a client never has to hold the table. */
+    detail: string | null;
+};
+type CameraCapabilityDescriptor = Record<CameraCapability, CameraCapabilityEntry>;
+/**
+ * A recorder's own HTTP interface, resolved from configuration.
+ *
+ * **Keyed by the same relay authority as `CAMERA_RTSP_DEVICES`**, because that
+ * is the only stable identifier a camera record carries (`site.cameras.host` is
+ * the relay's player page; its authority names the deployment and its last path
+ * segment is the channel — see `camera-view.util`).
+ *
+ * The credential is **referenced, never embedded**: `credentialRef` names an
+ * environment variable holding `username:password`. So the configuration that
+ * enables device access can be reviewed, diffed and pasted into a PR
+ * description without carrying a secret, and the secret itself lives where
+ * every other secret on the host lives.
+ */
+type DeviceHttpTarget = {
+    authority: string;
+    /** Origin only — scheme, host, optional port. No path, no query. */
+    baseUrl: string;
+    username: string;
+    password: string;
+    /** `CAMERA_DEVICE_HTTP_ENABLED`. Nothing contacts a device while this is off. */
+    enabled: boolean;
+    /** `CAMERA_DEVICE_CONTROL_ENABLED`. Mutating operations only. */
+    controlEnabled: boolean;
+    timeoutMs: number;
+    probeTtlSeconds: number;
+};
+type Env = Record<string, string | undefined>;
+/** Both flags are opt-IN. An unset or misspelt value is OFF, never on. */
+declare function deviceHttpEnabled(source?: Env): boolean;
+/**
+ * The mutating switch, and it is deliberately separate from the one above.
+ *
+ * Reading a device (version, snapshot, recording list, events) and moving a
+ * device (PTZ, preset recall) are different decisions with different blast
+ * radii, so they are different variables. Turning reads on must not arm motors.
+ *
+ * It also cannot be on by itself: control requires device access as well.
+ */
+declare function deviceControlEnabled(source?: Env): boolean;
+declare function deviceHttpTimeoutMs(source?: Env): number;
+/**
+ * How long a capability probe is trusted for.
+ *
+ * Long by the standards of this file — 15 minutes — because what it answers
+ * ("is this a PTZ unit, what firmware, does it answer at all") changes when an
+ * installer visits, not when a guard looks at a screen. A short TTL here buys
+ * nothing and spends requests against a device with a 3-failures lockout.
+ */
+declare function deviceProbeTtlSeconds(source?: Env): number;
+/**
+ * `CAMERA_DEVICE_HTTP` — a JSON object keyed by relay authority:
+ *
+ * ```
+ * {"<relay-authority>":{"baseUrl":"https://<recorder-host>:443",
+ *                       "credentialRef":"CAMERA_DEVICE_CRED_MAIN"}}
+ * ```
+ *
+ * …plus `CAMERA_DEVICE_CRED_MAIN=<user>:<password>` set separately.
+ *
+ * Returns the valid entries AND the reasons any entry was rejected, because a
+ * silently-dropped recorder is the failure mode that costs an afternoon: the
+ * caller logs the errors once at startup, and every camera on a rejected entry
+ * then reports `device-http-not-configured` truthfully rather than hanging.
+ *
+ * A malformed variable yields no targets at all — the same posture as
+ * `cameraDevices()`, and far better than a half-parsed device map.
+ */
+declare function deviceHttpTargets(source?: Env): {
+    targets: Record<string, DeviceHttpTarget>;
+    errors: Array<string>;
+};
+/** The device-HTTP target for one camera record, or `null` when there is none. */
+declare function resolveDeviceHttp(host: string | undefined, targets?: Record<string, DeviceHttpTarget>): DeviceHttpTarget | null;
+/**
+ * The cached answer to "we asked the device what it is".
+ *
+ * `ptz: null` and `reachable` are separate facts on purpose — a device can
+ * answer while refusing to say whether it pans (older firmware, or a protocol
+ * with no capability query), and that is an `unknown`, not a `no`.
+ */
+type DeviceProbeResult = {
+    reachable: boolean;
+    /** True when the failure budget is spent; nothing was sent. */
+    lockedOut?: boolean;
+    ptz?: boolean | null;
+    presets?: boolean | null;
+    softwareVersion?: string | null;
+    deviceType?: string | null;
+    probedAt?: string;
+};
+type CameraCapabilityContext = {
+    camera: {
+        type?: string;
+        status?: string;
+        host?: string;
+    } | null;
+    /** RTSP recorders, from `CAMERA_RTSP_DEVICES`. */
+    rtspDevices?: Record<string, CameraDevice>;
+    /** Resolved device-HTTP target for this camera, or `null`. */
+    deviceHttp?: DeviceHttpTarget | null;
+    /** A CACHED probe. `null`/absent means "never asked" → `unknown`, not `no`. */
+    probe?: DeviceProbeResult | null;
+};
+type Decision = {
+    state: CameraCapabilityState;
+    reason: CameraCapabilityReason | null;
+};
+/**
+ * A way of reaching a camera, and what it can do through that way.
+ *
+ * `evaluate` is asked once per capability it declares. Registration order is
+ * preference order, so the first transport that says `supported` wins — which
+ * is how one camera ends up serving live video over `RELAY_PLAYER` and evidence
+ * stills over `RTSP_FRAME` at the same time, with nothing choosing between them
+ * by hand.
+ */
+type CameraTransport = {
+    id: string;
+    provides: ReadonlyArray<CameraCapability>;
+    evaluate: (capability: CameraCapability, ctx: CameraCapabilityContext) => Decision;
+};
+/**
+ * Is this stored address a video-relay player page?
+ *
+ * The admin form ENFORCES `https://<domain>/<one segment>` for a CCTV camera
+ * (`layer-common` `CameraForm.vue`), and all twelve real records match it. The
+ * three that do not are two `example.com` placeholders and one bare authority
+ * with no channel — so this predicate separates "a URL a WebView can render"
+ * from "a record somebody has not finished", without contacting anything.
+ */
+declare function isRelayPlayerUrl(host: string | undefined): boolean;
+/** The registry, read-only to callers. */
+declare function cameraTransports(): ReadonlyArray<CameraTransport>;
+/**
+ * Add or replace a transport.
+ *
+ * The point of the registry: an HLS relay, a MediaMTX playback URL or an audio
+ * path is a new entry here and a new `provides` list. **No service, controller
+ * or client changes to add one** — a capability that no transport declares
+ * already answers `no-transport`, and starts answering `supported` the moment
+ * something claims it.
+ */
+declare function registerCameraTransport(transport: CameraTransport): void;
+/** Test seam: restore the built-in registry. */
+declare function resetCameraTransports(): void;
+type CameraCapabilityTrace = Array<{
+    capability: CameraCapability;
+    transport: string | null;
+    state: CameraCapabilityState;
+    reason: CameraCapabilityReason | null;
+}>;
+/**
+ * The descriptor for one camera, plus the trace of how each answer was reached.
+ *
+ * Selection per capability: ask every transport that declares it, in
+ * registration order, and take the first `supported`. Failing that the first
+ * `unknown` — because "we have not asked" outranks "this way cannot" when
+ * telling someone what to do next. Failing that the first `unsupported`, whose
+ * reason belongs to the most-preferred transport and is therefore the most
+ * actionable one. A capability no transport declares is `no-transport`.
+ *
+ * The trace is for the server's log. It names capabilities, transport ids and
+ * reason codes only — **no host, no credential, no address** — so it is safe to
+ * write down, which is the point of having it at all: "why is PTZ off on this
+ * camera" becomes one grep instead of an afternoon.
+ */
+declare function describeCameraCapabilities(ctx: CameraCapabilityContext, registry?: ReadonlyArray<CameraTransport>): {
+    capabilities: CameraCapabilityDescriptor;
+    trace: CameraCapabilityTrace;
+};
+/**
+ * The descriptor for a camera record, reading configuration from the
+ * environment. The convenience the service actually calls.
+ *
+ * **`probe` is passed IN, never fetched here.** Nothing in this file may cause
+ * a device request, so a list endpoint cannot start probing by accident — the
+ * single rule that keeps a wall of nine tiles from becoming a burst of
+ * authenticated requests against a device with a lockout policy.
+ */
+declare function cameraCapabilitiesFor(params: {
+    camera: {
+        type?: string;
+        status?: string;
+        host?: string;
+    } | null;
+    probe?: DeviceProbeResult | null;
+    rtspDevices?: Record<string, CameraDevice>;
+    deviceHttpTargets?: Record<string, DeviceHttpTarget>;
+}): {
+    capabilities: CameraCapabilityDescriptor;
+    trace: CameraCapabilityTrace;
+};
+/** `true` when a camera has at least one capability that works right now. */
+declare function hasAnyCapability(descriptor: CameraCapabilityDescriptor): boolean;
+/** Kept for the wall's log line: `liveVideo=RELAY_PLAYER stillFrame=RTSP_FRAME …`. */
+declare function formatCapabilityTrace(trace: CameraCapabilityTrace): string;
+
+/**
+ * Camera functions for Virtual Patrol, proxied.
+ *
+ * ## Why this exists at all
+ *
+ * Dahua devices authenticate with digest and the cleartext password on EVERY
+ * request (V3.37 §3.4). The specification offers no session, no API key and no
+ * usable token — §4.1.5 mints one and never documents how to redeem it. So there
+ * is no version of this feature in which the phone talks to the camera: the
+ * credential would have to ship with the app.
+ *
+ * Everything here therefore runs server-side. The guard's ordinary session
+ * authenticates them to US; we hold the camera credential and speak digest to the
+ * device. The credential is never returned, never logged, and never appears in an
+ * error message — `publicCameraFields` is an allow-list for exactly that reason.
+ *
+ * ## What is deliberately absent
+ *
+ * **No retry.** A failed camera call fails. The device locks an account for
+ * 1800 s after 3 failures in 30 s (§4.7.x), and a retry loop on a user-facing
+ * screen is precisely the defect `iservice365-core` #1803 fixed on the ANPR
+ * listener. A snapshot that fails costs a guard one blank panel; a lockout costs
+ * a site its ANPR and its barrier for half an hour.
+ *
+ * **No configuration write, no reboot, no barrier command.** The only
+ * device-mutating call in this file is PTZ, and it is off unless explicitly
+ * enabled.
+ *
+ * ## How a picture is actually fetched — measured, 2026-08-10
+ *
+ * The recorder these cameras live on is reachable on **RTSP (554) only**: its
+ * HTTP interface (80/443) and the Dahua native port (37777) are not exposed,
+ * verified by TCP connect from this workstation AND from the staging API host.
+ * So `snapshot.cgi`, `magicBox.cgi`, `global.cgi` and PTZ — all HTTP CGI — cannot
+ * be reached at all, and a snapshot has to come off the video stream.
+ *
+ * It therefore runs one `ffmpeg` per picture: connect, take a single frame,
+ * encode JPEG, exit. Measured against the live recorder: a substream frame is
+ * ~17–19 KB and arrives in 7–9 s; three concurrent pulls showed no degradation.
+ * That latency is why the snapshot cache matters and why the RTSP budget is its
+ * own, larger number.
+ *
+ * **ffmpeg's stderr is discarded, not piped** — the RTSP URL it echoes on failure
+ * contains the recorder's credential, so the safest handling is for those bytes
+ * never to exist in this process.
+ */
+declare function useCameraViewService(): {
+    authorizeCamera: (params: {
+        cameraId: string;
+        userId?: string;
+        permissions: Array<string>;
+    }) => Promise<bson.Document>;
+    entitleSite: (params: {
+        siteId: string;
+        userId?: string;
+    }) => Promise<{
+        site: mongodb.WithId<bson.Document> | null;
+        siteObjectId: ObjectId;
+        db: Db;
+        memberships: (CameraMembership & {
+            org?: ObjectId | undefined;
+        })[];
+        grant: CameraMembership;
+    }>;
+    authorizeSite: (params: {
+        siteId: string;
+        userId?: string;
+        /**
+         * Which permission this particular use of a site needs. Viewing is the
+         * default because every existing caller views; setting a camera up is a
+         * different, narrower right and passes its own list.
+         */
+        permissions?: Array<string>;
+    }) => Promise<{
+        site: mongodb.WithId<bson.Document> | null;
+        siteObjectId: ObjectId;
+        db: Db;
+    }>;
+    testCameraAddress: (params: {
+        siteId: string;
+        userId?: string;
+        host?: string;
+        recorderHost?: string;
+        recorderPort?: number | string;
+        channel?: number | string;
+    }) => Promise<{
+        ok: boolean;
+        status: CameraTestStatus;
+        message: string;
+    }>;
+    getSnapshot: (params: {
+        cameraId: string;
+        userId?: string;
+        /** Full-resolution main stream. For an evidence capture, not for a tile. */
+        hd?: boolean;
+    }) => Promise<{
+        buffer: Buffer;
+        cached: boolean;
+    }>;
+    captureSnapshot: (params: {
+        cameraId: string;
+        userId?: string;
+    }) => Promise<{
+        id: string;
+        size: number;
+    }>;
+    getStatus: (params: {
+        cameraId: string;
+        userId?: string;
+    }) => Promise<{
+        reachable: boolean;
+        health: "unsupported";
+        reason: string;
+        camera: Record<string, any>;
+        snapshotSupported: boolean;
+        capabilities: CameraCapabilityDescriptor;
+        firmwareVersion: string | null;
+        deviceTime: null;
+        driftSeconds: null;
+        detailUnavailableReason: string | null;
+    } | {
+        reachable: boolean;
+        health: "unreachable" | "ok" | "drifted";
+        reason: string | null;
+        camera: Record<string, any>;
+        snapshotSupported: boolean;
+        capabilities: CameraCapabilityDescriptor;
+        firmwareVersion: string | null;
+        deviceTime: null;
+        driftSeconds: null;
+        detailUnavailableReason: string | null;
+    }>;
+    getSiteWall: (params: {
+        siteId: string;
+        userId?: string;
+    }) => Promise<{
+        site: {
+            _id: ObjectId;
+            name: any;
+        };
+        config: {
+            snapshotPollMs: number;
+            singlePollMs: number;
+            maxTiles: number;
+            maxConcurrentProbes: number;
+            healthCacheSeconds: number;
+        };
+        cameras: {
+            unavailableReason: string | null;
+            capabilities: CameraCapabilityDescriptor;
+        }[];
+    }>;
+    getSiteHealth: (params: {
+        siteId: string;
+        userId?: string;
+        cameraIds: Array<string>;
+    }) => Promise<{
+        cameras: ({
+            reachable: boolean;
+            health: "unsupported";
+            reason: string;
+            capabilities: CameraCapabilityDescriptor;
+            firmwareVersion: null;
+            deviceTime: null;
+            driftSeconds: null;
+            detailUnavailableReason: string;
+            lastFrameAt: string | null;
+            unavailableReason: string | null;
+        } | {
+            reachable: boolean;
+            health: "unreachable" | "ok" | "drifted";
+            reason: string | null;
+            capabilities: CameraCapabilityDescriptor;
+            firmwareVersion: null;
+            deviceTime: null;
+            driftSeconds: null;
+            detailUnavailableReason: string;
+            lastFrameAt: string | null;
+            unavailableReason: string | null;
+        })[];
+    }>;
+    movePtz: (params: {
+        cameraId: string;
+        userId?: string;
+        action: string;
+        code: string;
+        speed?: number;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+    ptzEnabled: boolean;
+};
+
+/**
+ * Camera functions for Virtual Patrol.
+ *
+ * Every handler is mounted behind `requireAuth` and every one re-derives the
+ * caller from the session — `req.user`, never a body or query field. The camera
+ * id in the path selects a record; the service decides whether the caller may
+ * have it.
+ */
+declare function useCameraViewController(): {
+    snapshot: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    capture: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    status: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    ptz: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    capabilities: (_req: Request, res: Response) => Promise<void>;
+    wall: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    health: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    test: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
 type TCustomerSite = {
     _id?: ObjectId;
     name: string;
@@ -8187,4 +9182,4 @@ declare function useHidAmicoController(): {
     finalizeIntercomCall: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };
 
-export { ANPRMode, AccessTypeProps, AppServiceType, AssignCardConfig, BidStatus, BidType, BuildingLevelStatus, BuildingStatus, BulkCardUpdate, BulletinOrder, BulletinRecipient, BulletinSort, BulletinStatus, BulletinVideoOrder, BulletinVideoSort, Camera, CameraType, DEVICE_STATUS, DOBStatus, DayOfWeek, DynamicFormFields, EAccessCardTypes, EAccessCardUserTypes, EmailSender, EntryOrder, EntrySort, EventOrder, EventSort, EventStatus, EventType, FacilitySort, FacilityStatus, FormEntryStatus, GuestSort, GuestStatus, IAccessCard, IAccessCardTransaction, MAccessCard, MAccessCardTransaction, MAddress, MAttendance, MAttendanceSettings, MBidPreloved, MBillingConfiguration, MBillingItem, MBuilding, MBuildingLevel, MBuildingUnit, MBulletinBoard, MBulletinVideo, MCategoryPreloved, MChannelPreloved, MChat, MChatPreloved, MCustomer, MCustomerSite, MDocumentManagement, MEntryPassSettings, MEventManagement, MFeedback, MFile, MFormEntry, MGuestManagement, MHidAmicoEvent, MHidAmicoIdentity, MHidAmicoReader, MIncidentReport, MManpowerDesignations, MManpowerMonitoring, MManpowerRemarks, MManpowerSites, MMember, MNfcPatrolLog, MNfcPatrolRoute, MNfcPatrolSettings, MNfcPatrolSettingsUpdate, MNfcPatrolTag, MOccurrenceBook, MOccurrenceEntry, MOccurrenceSubject, MOnlineForm, MOrg, MOvernightParkingApprovalHours, MOvernightParkingRequest, MPatrolLog, MPatrolQuestion, MPatrolRoute, MPerson, MPost, MPostFavorite, MPromoCode, MRobot, MRole, MRoleV2, MServiceProvider, MServiceProviderBilling, MSession, MSite, MSiteCamera, MSiteFacility, MSiteFacilityBooking, MStatementOfAccount, MSubcategoryPreloved, MSubscription, MUnitBilling, MUser, MVehicle, MVehicleTransaction, MVerification, MVerificationV2, MVisitorTransaction, MWorkOrder, OrgNature, OvernightParkingRequestSort, OvernightParkingRequestStatus, PERSON_TYPES, PStatus, Period, PersonStatus, PersonType, PersonTypes, PostOrder, PostSort, PostStatus, QrTagProps, ResidentAppModuleKey, SiteAddress, SiteCategories, SiteStatus, SortFields, SortOrder, Status, SubjectOrder, SubjectSort, SubscriptionType, TAccessMngmntSettings, TActionStatus, TAddress, TAffectedEntities, TAffectedInjured, TAppServiceType, TApprovedBy, TApprover, TAttendance, TAttendanceCheckIn, TAttendanceCheckOut, TAttendanceCheckTime, TAttendanceLocation, TAttendanceSettings, TAttendanceSettingsGetBySite, TAuthorities, TAuthoritiesCalled, TBidPreloved, TBilling, TBillingConfiguration, TBillingItem, TBuilding, TBuildingLevel, TBuildingUnit, TBulletinBoard, TBulletinVideo, TCamera, TCategoryPreloved, TChannelPreloved, TChat, TChatPreloved, TCheckPoint$1 as TCheckPoint, TComplaintInfo, TComplaintReceivedTo, TCounter, TCreateNfcPatrolLog, TCustomer, TCustomerSite, TDayNumber, TDaySchedule, TDefaultAccessCard, TDesignations, TDocs, TDocumentCreate, TDocumentManagement, TEntryPassSettings, TEventManagement, TFeedback, TFeedbackMetadata, TFeedbackUpdate, TFeedbackUpdateCategory, TFeedbackUpdateServiceProvider, TFeedbackUpdateStatus, TFeedbackUpdateToCompleted, TFile, TFiles, TFolderUpdate, TFormEntry, TGetAttendancesByUserQuery, TGetAttendancesQuery, TGuestManagement, THidAmicoEvent, THidAmicoIdentity, THidAmicoReader, TIncidentInformation, TIncidentReport, TIncidentTypeAndTime, TInvoice, TKeyRef, TManpowerDesignations, TManpowerDesignationsUpdate, TManpowerMonitoring, TManpowerMonitoringUpdate, TManpowerRemarks, TManpowerRemarksStatusUpdate, TManpowerRemarksUpdate, TManpowerSearchFilter, TManpowerSites, TMember, TMemberUpdateStatus, TMessagePreloved, TMiniRole, TNfcPatrolLog, TNfcPatrolRoute, TNfcPatrolRouteEdit, TNfcPatrolSettings, TNfcPatrolSettingsGetBySite, TNfcPatrolSettingsUpdate, TNfcPatrolTag, TNfcPatrolTagConfigureReset, TNfcPatrolTagEdit, TNfcPatrolTagUpdateData, TOccurrenceBook, TOccurrenceEntry, TOccurrenceSubject, TOnlineForm, TOrg, TOvernightParkingApprovalHours, TOvernightParkingRequest, TPatrolLog, TPatrolQuestion, TPatrolRoute, TPerson, TPlaceOfIncident, TPlates, TPost, TPostFavorite, TPrice, TPriceType, TPromoCode, TPromoTier, TRecipientOfComplaint, TRemarks, TResident, TResidentAppModules, TRobot, TRobotMetadata, TRole, TRoleV2, TRoute, TSOABillingItem, TSOAStatus, TServiceProvider, TServiceProviderBilling, TSession, TSessionCreate, TShifts, TSignNfcPatrolLog, TSite, TSiteCamera, TSiteFacility, TSiteFacilityBooking, TSiteInfo, TSiteInformation, TSiteMetadata, TSiteUpdateBlock, TStatementOfAccount, TSubcategoryPreloved, TSubmissionForm, TSubscription, TUnitBilling, TUnits, TUpdateFormEntry, TUpdateName, TUser, TUserCreate, TVehicle, TVehicleTransaction, TVehicleUpdate, TVerification, TVerificationMetadata, TVerificationMetadataV2, TVerificationV2, TVisitorTransaction, TWorkOrder, TWorkOrderMetadata, TWorkOrderUpdate, TWorkOrderUpdateStatus, TWorkOrderUpdateToCompleted, TanyoneDamageToProperty, UseAccessManagementRepo, UserStatus, VehicleCategory, VehicleOrder, VehicleSort, VehicleStatus, VehicleType, VerificationLinkType, VerificationStatus, VerificationSubjectType, VerificationType, VisitorSort, VisitorStatus, addressSchema, allowedFieldsSite, allowedNatures, attendanceSchema, attendanceSettingsSchema, building_level_namespace_collection, building_units_namespace_collection, buildings_namespace_collection, bulletin_boards_namespace_collection, chatPrelovedEvents, chatSchema, createManpowerRemarksDaily, customerSchema, designationsSchema, events_namespace_collection, facility_bookings_namespace_collection, feedbackSchema, feedbacks2_namespace_collection, feedbacks_namespace_collection, formatDahuaDate, guests_namespace_collection, incidentReport, incidentReportLog, incidents_namespace_collection, logCamera, manpowerDesignationsSchema, manpowerEvents, manpowerMonitoringSchema, manpowerRemarksSchema, manpowerSitesSchema, nfcPatrolSettingsSchema, nfcPatrolSettingsSchemaUpdate, occurrence_book_namespace_collection, online_forms_namespace_collection, orgSchema, overnight_parking_requests_namespace_collection, parseDahuaFind, promoCodeSchema, remarksSchema, residentAppModuleKeys, residentFormEntry, robotSchema, schema, schemaApprovedBy, schemaApprover, schemaBidPreloved, schemaBilling, schemaBillingConfiguration, schemaBillingItem, schemaBuilding, schemaBuildingLevel, schemaBuildingUnit, schemaBuildingUpdateOptions, schemaBulletinBoard, schemaBulletinVideo, schemaCategoryPreloved, schemaChannelPreloved, schemaChatPreloved, schemaCreateHidAmicoIdentity, schemaCreateNfcPatrolLog, schemaCustomerSite, schemaDocumentManagement, schemaEntryPassSettings, schemaEventManagement, schemaFiles, schemaFormEntry, schemaGuestManagement, schemaHidAmicoConfiguration, schemaHidAmicoEvent, schemaHidAmicoExecuteActions, schemaHidAmicoIdentity, schemaHidAmicoIdentityIdParams, schemaHidAmicoIdentityQuery, schemaHidAmicoIntercomCall, schemaHidAmicoLogQuery, schemaHidAmicoNotificationParams, schemaHidAmicoObjectOperation, schemaHidAmicoReader, schemaHidAmicoReaderIdParams, schemaHidAmicoReaderListQuery, schemaHidAmicoSetConfiguration, schemaHidAmicoSync, schemaHidAmicoUserImageParams, schemaIncidentReport, schemaMultipleDocumentManagement, schemaNfcPatrolLog, schemaNfcPatrolRoute, schemaNfcPatrolTag, schemaNfcPatrolTagUpdateData, schemaOccurrenceBook, schemaOccurrenceEntry, schemaOccurrenceSubject, schemaOnlineForm, schemaOvernightParkingApprovalHours, schemaOvernightParkingRequest, schemaPatrolLog, schemaPatrolQuestion, schemaPatrolRoute, schemaPerson, schemaPlate, schemaPost, schemaPostFavorite, schemaServiceProvider, schemaServiceProviderBilling, schemaSignNfcPatrolLog, schemaSiteCamera, schemaSiteFacility, schemaSiteFacilityBooking, schemaStatementOfAccount, schemaSubcategoryPreloved, schemaUnitBilling, schemaUpdateBidPreloved, schemaUpdateBuildingLevel, schemaUpdateBulletinBoard, schemaUpdateBulletinVideo, schemaUpdateCategoryPreloved, schemaUpdateChatPreloved, schemaUpdateDocumentManagement, schemaUpdateEntryPassSettings, schemaUpdateEventManagement, schemaUpdateFolderManagement, schemaUpdateFormEntry, schemaUpdateGuestManagement, schemaUpdateHidAmicoIdentity, schemaUpdateHidAmicoReader, schemaUpdateIncidentReport, schemaUpdateOccurrenceBook, schemaUpdateOccurrenceEntry, schemaUpdateOccurrenceSubject, schemaUpdateOnlineForm, schemaUpdateOptions, schemaUpdateOvernightParkingRequest, schemaUpdatePatrolLog, schemaUpdatePatrolQuestion, schemaUpdatePatrolRoute, schemaUpdatePerson, schemaUpdatePost, schemaUpdatePostFavorite, schemaUpdateServiceProviderBilling, schemaUpdateSiteBillingConfiguration, schemaUpdateSiteBillingItem, schemaUpdateSiteCamera, schemaUpdateSiteFacility, schemaUpdateSiteFacilityBooking, schemaUpdateSiteUnitBilling, schemaUpdateStatementOfAccount, schemaUpdateSubcategoryPreloved, schemaUpdateVisTrans, schemaVehicleTransaction, schemaVisitorTransaction, schemeCamera, schemeLogCamera, sessionSchema, shiftSchema, siteSchema, site_people_namespace_collection, updateRemarksStatusEod, updateRemarksisAcknowledged, updateSiteSchema, useAccessManagementController, useAddressRepo, useAttendanceController, useAttendanceRepository, useAttendanceSettingsController, useAttendanceSettingsRepository, useAttendanceSettingsService, useAuthController, useAuthControllerV2, useAuthService, useAuthServiceV2, useBidPrelovedController, useBidPrelovedRepo, useBidPrelovedService, useBuildingController, useBuildingLevelController, useBuildingLevelRepo, useBuildingLevelService, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useBulletinBoardController, useBulletinBoardRepo, useBulletinBoardService, useBulletinVideoController, useBulletinVideoRepo, useBulletinVideoService, useCategoryPrelovedController, useCategoryPrelovedRepo, useChannelPrelovedController, useChannelPrelovedRepo, useChatController, useChatPrelovedController, useChatPrelovedRepo, useChatPrelovedService, useChatRepo, useCounterModel, useCounterRepo, useCustomerController, useCustomerRepo, useCustomerSiteController, useCustomerSiteRepo, useCustomerSiteService, useDahuaService, useDashboardController, useDashboardRepo, useDocumentManagementController, useDocumentManagementRepo, useDocumentManagementService, useEntryPassSettingsController, useEntryPassSettingsRepo, useEventManagementController, useEventManagementRepo, useEventManagementService, useFeedbackController, useFeedbackRepo, useFeedbackService, useFileController, useFileRepo, useFileService, useFormEntryController, useFormEntryRepo, useGuestManagementController, useGuestManagementRepo, useGuestManagementService, useHidAmicoController, useHidAmicoRepo, useHidAmicoService, useHrmLabsAttendanceCtrl, useHrmLabsAttendanceSrvc, useIncidentReportController, useIncidentReportRepo, useIncidentReportService, useInvoiceController, useInvoiceModel, useInvoiceRepo, useManpowerDesignationCtrl, useManpowerDesignationRepo, useManpowerMonitoringCtrl, useManpowerMonitoringRepo, useManpowerMonitoringSrvc, useManpowerRemarkCtrl, useManpowerRemarksRepo, useManpowerSitesCtrl, useManpowerSitesRepo, useManpowerSitesSrvc, useMemberController, useMemberRepo, useMemberService, useNewDashboardController, useNewDashboardRepo, useNfcPatrolLogController, useNfcPatrolLogRepo, useNfcPatrolLogService, useNfcPatrolRouteController, useNfcPatrolRouteRepo, useNfcPatrolRouteService, useNfcPatrolSettingsController, useNfcPatrolSettingsRepository, useNfcPatrolSettingsService, useNfcPatrolTagController, useNfcPatrolTagRepo, useNfcPatrolTagService, useOccurrenceBookController, useOccurrenceBookRepo, useOccurrenceBookService, useOccurrenceEntryController, useOccurrenceEntryRepo, useOccurrenceEntryService, useOccurrenceSubjectController, useOccurrenceSubjectRepo, useOccurrenceSubjectService, useOnlineFormController, useOnlineFormRepo, useOrgController, useOrgControllerV2, useOrgRepo, useOvernightParkingController, useOvernightParkingRepo, useOvernightParkingRequestController, useOvernightParkingRequestRepo, useOvernightParkingRequestService, usePatrolLogController, usePatrolLogRepo, usePatrolQuestionController, usePatrolQuestionRepo, usePatrolRouteController, usePatrolRouteRepo, usePersonController, usePersonRepo, usePostFavoriteController, usePostFavoriteRepo, usePostFavoriteService, usePostPrelovedController, usePostPrelovedRepo, usePriceController, usePriceModel, usePriceRepo, usePromoCodeController, usePromoCodeRepo, useRedDotPaymentController, useRedDotPaymentRepo, useRedDotPaymentSvc, useRobotController, useRobotRepo, useRobotService, useRoleController, useRoleControllerV2, useRoleRepo, useRoleRepoV2, useRoleServiceV2, useServiceProviderBillingController, useServiceProviderBillingRepo, useServiceProviderBillingService, useServiceProviderController, useServiceProviderRepo, useSessionRepo, useSiteBillingConfigurationController, useSiteBillingConfigurationRepo, useSiteBillingItemController, useSiteBillingItemRepo, useSiteCameraController, useSiteCameraRepo, useSiteCameraService, useSiteController, useSiteFacilityBookingController, useSiteFacilityBookingRepo, useSiteFacilityBookingService, useSiteFacilityController, useSiteFacilityRepo, useSiteFacilityService, useSiteRepo, useSiteService, useSiteUnitBillingController, useSiteUnitBillingRepo, useSiteUnitBillingService, useStatementOfAccountController, useStatementOfAccountRepo, useSubcategoryPrelovedController, useSubcategoryPrelovedRepo, useSubscriptionController, useSubscriptionRepo, useSubscriptionService, useUserController, useUserControllerV2, useUserRepo, useUserRepoV2, useUserService, useUserServiceV2, useVehicleController, useVehicleRepo, useVehicleService, useVerificationController, useVerificationControllerV2, useVerificationRepo, useVerificationRepoV2, useVerificationService, useVerificationServiceV2, useVisitorTransactionController, useVisitorTransactionRepo, useVisitorTransactionService, useWorkOrderController, useWorkOrderRepo, useWorkOrderService, userSchema, vehicleSchema, vehicles_namespace_collection, visitorPersonRepo, visitorPersonService, visitorType, visitors_namespace_collection, workOrderSchema, work_orders2_namespace_collection, work_orders_namespace_collection };
+export { ANPRMode, AccessTypeProps, AppServiceType, AssignCardConfig, BidStatus, BidType, BuildingLevelStatus, BuildingStatus, BulkCardUpdate, BulletinOrder, BulletinRecipient, BulletinSort, BulletinStatus, BulletinVideoOrder, BulletinVideoSort, CAMERA_ANPR_PERMISSIONS, CAMERA_CAPABILITIES, CAMERA_CAPABILITY_REASONS, CAMERA_NOT_PATROL_OR_CCTV, CAMERA_PTZ_PERMISSIONS, CAMERA_REQUEST_TIMEOUT_MS, CAMERA_RTSP_TIMEOUT_MS, CAMERA_SETUP_PERMISSIONS, CAMERA_SNAPSHOT_CACHE_SECONDS, CAMERA_SNAPSHOT_MAX_BYTES, CAMERA_TEST_MIN_INTERVAL_SECONDS, CAMERA_TEST_ROUND_LIMIT, CAMERA_TEST_ROUND_SECONDS, CAMERA_TYPE_ANPR, CAMERA_TYPE_IP, CAMERA_VIEW_PERMISSIONS, CLOCK_DRIFT_WARN_SECONDS, CURRENT_TIME_ENDPOINT, Camera, CameraAddressInput, CameraCapability, CameraCapabilityContext, CameraCapabilityDescriptor, CameraCapabilityEntry, CameraCapabilityReason, CameraCapabilityState, CameraCapabilityTrace, CameraDevice, CameraMembership, CameraTestStatus, CameraTransport, CameraType, DEVICE_STATUS, DOBStatus, DayOfWeek, DeviceHttpTarget, DeviceProbeResult, DynamicFormFields, EAccessCardTypes, EAccessCardUserTypes, EmailSender, EntryOrder, EntrySort, EventOrder, EventSort, EventStatus, EventType, FacilitySort, FacilityStatus, FormEntryStatus, GuestSort, GuestStatus, IAccessCard, IAccessCardTransaction, MAX_CAMERA_CHANNEL, MAccessCard, MAccessCardTransaction, MAddress, MAttendance, MAttendanceSettings, MBidPreloved, MBillingConfiguration, MBillingItem, MBuilding, MBuildingLevel, MBuildingUnit, MBulletinBoard, MBulletinVideo, MCategoryPreloved, MChannelPreloved, MChat, MChatPreloved, MCustomer, MCustomerSite, MDocumentManagement, MEntryPassSettings, MEventManagement, MFeedback, MFile, MFormEntry, MGuestManagement, MHidAmicoEvent, MHidAmicoIdentity, MHidAmicoReader, MIncidentReport, MManpowerDesignations, MManpowerMonitoring, MManpowerRemarks, MManpowerSites, MMember, MNfcPatrolLog, MNfcPatrolRoute, MNfcPatrolSettings, MNfcPatrolSettingsUpdate, MNfcPatrolTag, MOccurrenceBook, MOccurrenceEntry, MOccurrenceSubject, MOnlineForm, MOrg, MOvernightParkingApprovalHours, MOvernightParkingRequest, MPatrolLog, MPatrolQuestion, MPatrolRoute, MPerson, MPost, MPostFavorite, MPromoCode, MRobot, MRole, MRoleV2, MServiceProvider, MServiceProviderBilling, MSession, MSite, MSiteCamera, MSiteFacility, MSiteFacilityBooking, MStatementOfAccount, MSubcategoryPreloved, MSubscription, MUnitBilling, MUser, MVehicle, MVehicleTransaction, MVerification, MVerificationV2, MVisitorTransaction, MWorkOrder, OrgNature, OvernightParkingRequestSort, OvernightParkingRequestStatus, PATROL_CCTV_CAMERA_FILTER, PERSON_TYPES, PStatus, PTZ_ALLOWED_ACTIONS, PTZ_ALLOWED_CODES, Period, PersonStatus, PersonType, PersonTypes, PostOrder, PostSort, PostStatus, QrTagProps, ResidentAppModuleKey, SOFTWARE_VERSION_ENDPOINT, SiteAddress, SiteCategories, SiteStatus, SortFields, SortOrder, Status, SubjectOrder, SubjectSort, SubscriptionType, TAccessMngmntSettings, TActionStatus, TAddress, TAffectedEntities, TAffectedInjured, TAppServiceType, TApprovedBy, TApprover, TAttendance, TAttendanceCheckIn, TAttendanceCheckOut, TAttendanceCheckTime, TAttendanceLocation, TAttendanceSettings, TAttendanceSettingsGetBySite, TAuthorities, TAuthoritiesCalled, TBidPreloved, TBilling, TBillingConfiguration, TBillingItem, TBuilding, TBuildingLevel, TBuildingUnit, TBulletinBoard, TBulletinVideo, TCamera, TCategoryPreloved, TChannelPreloved, TChat, TChatPreloved, TCheckPoint$1 as TCheckPoint, TComplaintInfo, TComplaintReceivedTo, TCounter, TCreateNfcPatrolLog, TCustomer, TCustomerSite, TDayNumber, TDaySchedule, TDefaultAccessCard, TDesignations, TDocs, TDocumentCreate, TDocumentManagement, TEntryPassSettings, TEventManagement, TFeedback, TFeedbackMetadata, TFeedbackUpdate, TFeedbackUpdateCategory, TFeedbackUpdateServiceProvider, TFeedbackUpdateStatus, TFeedbackUpdateToCompleted, TFile, TFiles, TFolderUpdate, TFormEntry, TGetAttendancesByUserQuery, TGetAttendancesQuery, TGuestManagement, THidAmicoEvent, THidAmicoIdentity, THidAmicoReader, TIncidentInformation, TIncidentReport, TIncidentTypeAndTime, TInvoice, TKeyRef, TManpowerDesignations, TManpowerDesignationsUpdate, TManpowerMonitoring, TManpowerMonitoringUpdate, TManpowerRemarks, TManpowerRemarksStatusUpdate, TManpowerRemarksUpdate, TManpowerSearchFilter, TManpowerSites, TMember, TMemberUpdateStatus, TMessagePreloved, TMiniRole, TNfcPatrolLog, TNfcPatrolRoute, TNfcPatrolRouteEdit, TNfcPatrolSettings, TNfcPatrolSettingsGetBySite, TNfcPatrolSettingsUpdate, TNfcPatrolTag, TNfcPatrolTagConfigureReset, TNfcPatrolTagEdit, TNfcPatrolTagUpdateData, TOccurrenceBook, TOccurrenceEntry, TOccurrenceSubject, TOnlineForm, TOrg, TOvernightParkingApprovalHours, TOvernightParkingRequest, TPatrolLog, TPatrolQuestion, TPatrolRoute, TPerson, TPlaceOfIncident, TPlates, TPost, TPostFavorite, TPrice, TPriceType, TPromoCode, TPromoTier, TRANSPORT_DEVICE_HTTP, TRANSPORT_RELAY_PLAYER, TRANSPORT_RTSP_FRAME, TRecipientOfComplaint, TRemarks, TResident, TResidentAppModules, TRobot, TRobotMetadata, TRole, TRoleV2, TRoute, TSOABillingItem, TSOAStatus, TServiceProvider, TServiceProviderBilling, TSession, TSessionCreate, TShifts, TSignNfcPatrolLog, TSite, TSiteCamera, TSiteFacility, TSiteFacilityBooking, TSiteInfo, TSiteInformation, TSiteMetadata, TSiteUpdateBlock, TStatementOfAccount, TSubcategoryPreloved, TSubmissionForm, TSubscription, TUnitBilling, TUnits, TUpdateFormEntry, TUpdateName, TUser, TUserCreate, TVehicle, TVehicleTransaction, TVehicleUpdate, TVerification, TVerificationMetadata, TVerificationMetadataV2, TVerificationV2, TVisitorTransaction, TWorkOrder, TWorkOrderMetadata, TWorkOrderUpdate, TWorkOrderUpdateStatus, TWorkOrderUpdateToCompleted, TanyoneDamageToProperty, UseAccessManagementRepo, UserStatus, VehicleCategory, VehicleOrder, VehicleSort, VehicleStatus, VehicleType, VerificationLinkType, VerificationStatus, VerificationSubjectType, VerificationType, VisitorSort, VisitorStatus, addressSchema, allowedFieldsSite, allowedNatures, attendanceSchema, attendanceSettingsSchema, building_level_namespace_collection, building_units_namespace_collection, buildings_namespace_collection, bulletin_boards_namespace_collection, cameraBaseUrl, cameraCapabilitiesFor, cameraDevices, cameraGrant, cameraHealthSummary, cameraManagePermissions, cameraTransports, chatPrelovedEvents, chatSchema, clampPtzSpeed, clockDriftSeconds, createManpowerRemarksDaily, customerSchema, deriveCameraHost, describeCameraCapabilities, designationsSchema, deviceControlEnabled, deviceHttpEnabled, deviceHttpTargets, deviceHttpTimeoutMs, deviceProbeTtlSeconds, events_namespace_collection, facility_bookings_namespace_collection, feedbackSchema, feedbacks2_namespace_collection, feedbacks_namespace_collection, ffmpegFrameArgs, ffmpegPath, formatCapabilityTrace, formatDahuaDate, guests_namespace_collection, hasAnyCapability, hasAnyPermission, incidentReport, incidentReportLog, incidents_namespace_collection, isCameraEntitled, isPatrolCctvCamera, isRelayPlayerUrl, logCamera, manpowerDesignationsSchema, manpowerEvents, manpowerMonitoringSchema, manpowerRemarksSchema, manpowerSitesSchema, mapWithLimit, nfcPatrolSettingsSchema, nfcPatrolSettingsSchemaUpdate, occurrence_book_namespace_collection, online_forms_namespace_collection, orgSchema, overnight_parking_requests_namespace_collection, parseCameraChannel, parseCameraHost, parseDahuaFind, parseDeviceTime, parseSoftwareVersion, promoCodeSchema, ptzEndpoint, publicCameraFields, registerCameraTransport, relayForRecorder, remarksSchema, resetCameraTransports, residentAppModuleKeys, residentFormEntry, resolutionRefusalReason, resolveCamera, resolveDeviceHttp, robotSchema, rtspUrl, schema, schemaApprovedBy, schemaApprover, schemaBidPreloved, schemaBilling, schemaBillingConfiguration, schemaBillingItem, schemaBuilding, schemaBuildingLevel, schemaBuildingUnit, schemaBuildingUpdateOptions, schemaBulletinBoard, schemaBulletinVideo, schemaCategoryPreloved, schemaChannelPreloved, schemaChatPreloved, schemaCreateHidAmicoIdentity, schemaCreateNfcPatrolLog, schemaCustomerSite, schemaDocumentManagement, schemaEntryPassSettings, schemaEventManagement, schemaFiles, schemaFormEntry, schemaGuestManagement, schemaHidAmicoConfiguration, schemaHidAmicoEvent, schemaHidAmicoExecuteActions, schemaHidAmicoIdentity, schemaHidAmicoIdentityIdParams, schemaHidAmicoIdentityQuery, schemaHidAmicoIntercomCall, schemaHidAmicoLogQuery, schemaHidAmicoNotificationParams, schemaHidAmicoObjectOperation, schemaHidAmicoReader, schemaHidAmicoReaderIdParams, schemaHidAmicoReaderListQuery, schemaHidAmicoSetConfiguration, schemaHidAmicoSync, schemaHidAmicoUserImageParams, schemaIncidentReport, schemaMultipleDocumentManagement, schemaNfcPatrolLog, schemaNfcPatrolRoute, schemaNfcPatrolTag, schemaNfcPatrolTagUpdateData, schemaOccurrenceBook, schemaOccurrenceEntry, schemaOccurrenceSubject, schemaOnlineForm, schemaOvernightParkingApprovalHours, schemaOvernightParkingRequest, schemaPatrolLog, schemaPatrolQuestion, schemaPatrolRoute, schemaPerson, schemaPlate, schemaPost, schemaPostFavorite, schemaServiceProvider, schemaServiceProviderBilling, schemaSignNfcPatrolLog, schemaSiteCamera, schemaSiteFacility, schemaSiteFacilityBooking, schemaStatementOfAccount, schemaSubcategoryPreloved, schemaUnitBilling, schemaUpdateBidPreloved, schemaUpdateBuildingLevel, schemaUpdateBulletinBoard, schemaUpdateBulletinVideo, schemaUpdateCategoryPreloved, schemaUpdateChatPreloved, schemaUpdateDocumentManagement, schemaUpdateEntryPassSettings, schemaUpdateEventManagement, schemaUpdateFolderManagement, schemaUpdateFormEntry, schemaUpdateGuestManagement, schemaUpdateHidAmicoIdentity, schemaUpdateHidAmicoReader, schemaUpdateIncidentReport, schemaUpdateOccurrenceBook, schemaUpdateOccurrenceEntry, schemaUpdateOccurrenceSubject, schemaUpdateOnlineForm, schemaUpdateOptions, schemaUpdateOvernightParkingRequest, schemaUpdatePatrolLog, schemaUpdatePatrolQuestion, schemaUpdatePatrolRoute, schemaUpdatePerson, schemaUpdatePost, schemaUpdatePostFavorite, schemaUpdateServiceProviderBilling, schemaUpdateSiteBillingConfiguration, schemaUpdateSiteBillingItem, schemaUpdateSiteCamera, schemaUpdateSiteFacility, schemaUpdateSiteFacilityBooking, schemaUpdateSiteUnitBilling, schemaUpdateStatementOfAccount, schemaUpdateSubcategoryPreloved, schemaUpdateVisTrans, schemaVehicleTransaction, schemaVisitorTransaction, schemeCamera, schemeLogCamera, sessionSchema, shiftSchema, siteSchema, site_people_namespace_collection, snapshotEndpoint, snapshotRefusalReason, updateRemarksStatusEod, updateRemarksisAcknowledged, updateSiteSchema, useAccessManagementController, useAddressRepo, useAttendanceController, useAttendanceRepository, useAttendanceSettingsController, useAttendanceSettingsRepository, useAttendanceSettingsService, useAuthController, useAuthControllerV2, useAuthService, useAuthServiceV2, useBidPrelovedController, useBidPrelovedRepo, useBidPrelovedService, useBuildingController, useBuildingLevelController, useBuildingLevelRepo, useBuildingLevelService, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useBulletinBoardController, useBulletinBoardRepo, useBulletinBoardService, useBulletinVideoController, useBulletinVideoRepo, useBulletinVideoService, useCameraViewController, useCameraViewService, useCategoryPrelovedController, useCategoryPrelovedRepo, useChannelPrelovedController, useChannelPrelovedRepo, useChatController, useChatPrelovedController, useChatPrelovedRepo, useChatPrelovedService, useChatRepo, useCounterModel, useCounterRepo, useCustomerController, useCustomerRepo, useCustomerSiteController, useCustomerSiteRepo, useCustomerSiteService, useDahuaService, useDashboardController, useDashboardRepo, useDocumentManagementController, useDocumentManagementRepo, useDocumentManagementService, useEntryPassSettingsController, useEntryPassSettingsRepo, useEventManagementController, useEventManagementRepo, useEventManagementService, useFeedbackController, useFeedbackRepo, useFeedbackService, useFileController, useFileRepo, useFileService, useFormEntryController, useFormEntryRepo, useGuestManagementController, useGuestManagementRepo, useGuestManagementService, useHidAmicoController, useHidAmicoRepo, useHidAmicoService, useHrmLabsAttendanceCtrl, useHrmLabsAttendanceSrvc, useIncidentReportController, useIncidentReportRepo, useIncidentReportService, useInvoiceController, useInvoiceModel, useInvoiceRepo, useManpowerDesignationCtrl, useManpowerDesignationRepo, useManpowerMonitoringCtrl, useManpowerMonitoringRepo, useManpowerMonitoringSrvc, useManpowerRemarkCtrl, useManpowerRemarksRepo, useManpowerSitesCtrl, useManpowerSitesRepo, useManpowerSitesSrvc, useMemberController, useMemberRepo, useMemberService, useNewDashboardController, useNewDashboardRepo, useNfcPatrolLogController, useNfcPatrolLogRepo, useNfcPatrolLogService, useNfcPatrolRouteController, useNfcPatrolRouteRepo, useNfcPatrolRouteService, useNfcPatrolSettingsController, useNfcPatrolSettingsRepository, useNfcPatrolSettingsService, useNfcPatrolTagController, useNfcPatrolTagRepo, useNfcPatrolTagService, useOccurrenceBookController, useOccurrenceBookRepo, useOccurrenceBookService, useOccurrenceEntryController, useOccurrenceEntryRepo, useOccurrenceEntryService, useOccurrenceSubjectController, useOccurrenceSubjectRepo, useOccurrenceSubjectService, useOnlineFormController, useOnlineFormRepo, useOrgController, useOrgControllerV2, useOrgRepo, useOvernightParkingController, useOvernightParkingRepo, useOvernightParkingRequestController, useOvernightParkingRequestRepo, useOvernightParkingRequestService, usePatrolLogController, usePatrolLogRepo, usePatrolQuestionController, usePatrolQuestionRepo, usePatrolRouteController, usePatrolRouteRepo, usePersonController, usePersonRepo, usePostFavoriteController, usePostFavoriteRepo, usePostFavoriteService, usePostPrelovedController, usePostPrelovedRepo, usePriceController, usePriceModel, usePriceRepo, usePromoCodeController, usePromoCodeRepo, useRedDotPaymentController, useRedDotPaymentRepo, useRedDotPaymentSvc, useRobotController, useRobotRepo, useRobotService, useRoleController, useRoleControllerV2, useRoleRepo, useRoleRepoV2, useRoleServiceV2, useServiceProviderBillingController, useServiceProviderBillingRepo, useServiceProviderBillingService, useServiceProviderController, useServiceProviderRepo, useSessionRepo, useSiteBillingConfigurationController, useSiteBillingConfigurationRepo, useSiteBillingItemController, useSiteBillingItemRepo, useSiteCameraController, useSiteCameraRepo, useSiteCameraService, useSiteController, useSiteFacilityBookingController, useSiteFacilityBookingRepo, useSiteFacilityBookingService, useSiteFacilityController, useSiteFacilityRepo, useSiteFacilityService, useSiteRepo, useSiteService, useSiteUnitBillingController, useSiteUnitBillingRepo, useSiteUnitBillingService, useStatementOfAccountController, useStatementOfAccountRepo, useSubcategoryPrelovedController, useSubcategoryPrelovedRepo, useSubscriptionController, useSubscriptionRepo, useSubscriptionService, useUserController, useUserControllerV2, useUserRepo, useUserRepoV2, useUserService, useUserServiceV2, useVehicleController, useVehicleRepo, useVehicleService, useVerificationController, useVerificationControllerV2, useVerificationRepo, useVerificationRepoV2, useVerificationService, useVerificationServiceV2, useVisitorTransactionController, useVisitorTransactionRepo, useVisitorTransactionService, useWorkOrderController, useWorkOrderRepo, useWorkOrderService, userSchema, vehicleSchema, vehicles_namespace_collection, visitorPersonRepo, visitorPersonService, visitorType, visitors_namespace_collection, wallConfig, workOrderSchema, work_orders2_namespace_collection, work_orders_namespace_collection };