@greensecurity/javascript-sdk 0.45.0-beta.9 → 0.46.0-beta.1

package/src/__tests__/getAppVersionStatus.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// The parameters are declared, rather than `vi.fn(() => ...)`, so that mock.calls is typed as the
+// argument tuple rather than `[][]` — see smartBadgeGetPsks.test.ts for why that matters for tshy.
+const { doGetSingleMock } = vi.hoisted(() => ({
+  doGetSingleMock: vi.fn((_route: string, _query: unknown, _options?: unknown) =>
+    Promise.resolve([{ ok: true }, { status: "complete" }])
+  ),
+}));
+
+// Only the transport is mocked: the real `hashToQueryString` has to run, because the encoding of
+// the route is what these tests are about.
+vi.mock("../admin-funcs/doAdmin.js", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../admin-funcs/doAdmin.js")>()),
+  $doGetSingle: doGetSingleMock,
+}));
+
+import { getAppVersionStatus } from "../admin-funcs/getAppVersionStatus.js";
+
+describe("getAppVersionStatus", () => {
+  beforeEach(() => {
+    doGetSingleMock.mockClear();
+  });
+
+  // The app names itself in the query rather than in `X-SDK-User-Agent`: the internal core carries
+  // no app token, so a route that dropped either value would have the server answer about an app it
+  // cannot name — which is "no opinion", and the update prompt would never appear.
+  it("names the app and version in the query", () => {
+    const request = getAppVersionStatus("repconnex-ios", "2.0.122");
+
+    expect(doGetSingleMock).toHaveBeenCalledWith(
+      "/app-version?app_name=repconnex-ios&app_version=2.0.122",
+      {},
+      undefined
+    );
+    expect(request).toBeDefined();
+  });
+
+  // `+` is the one that bites: unencoded it arrives at Rails as a space, and a version that does
+  // not match AppVersionPolicy::VERSION_PATTERN fails open rather than prompting.
+  it("percent-encodes reserved characters in both values", () => {
+    getAppVersionStatus("repconnex-ios/next", "2.0.122+build 7&beta");
+
+    expect(doGetSingleMock).toHaveBeenLastCalledWith(
+      "/app-version?app_name=repconnex-ios%2Fnext&app_version=2.0.122%2Bbuild%207%26beta",
+      {},
+      undefined
+    );
+  });
+
+  it("forwards request options through to $doGetSingle", () => {
+    getAppVersionStatus("repconnex-android", "2.0.122", { timeoutMs: 2000 });
+
+    expect(doGetSingleMock).toHaveBeenLastCalledWith(
+      "/app-version?app_name=repconnex-android&app_version=2.0.122",
+      {},
+      { timeoutMs: 2000 }
+    );
+  });
+});

package/src/__tests__/kiosk.test.ts

@@ -0,0 +1,163 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// The parameters are declared, rather than `vi.fn(() => ...)`, so that mock.calls is typed as the
+// argument tuple rather than `[][]` — see smartBadgeGetPsks.test.ts for why that matters for tshy.
+const { doGetSingleMock, doPostMock, doPutMock } = vi.hoisted(() => ({
+  doGetSingleMock: vi.fn((_route: string, _query: unknown, _options?: unknown) =>
+    Promise.resolve([{ ok: true }, { status: "complete" }])
+  ),
+  doPostMock: vi.fn((_route: string, _body: unknown, _options?: unknown) =>
+    Promise.resolve([{ ok: true }, { status: "complete" }])
+  ),
+  doPutMock: vi.fn((_route: string, _body: unknown, _options?: unknown) =>
+    Promise.resolve([{ ok: true }, { status: "complete" }])
+  ),
+}));
+
+vi.mock("../admin-funcs/doAdmin.js", () => ({
+  $doGetSingle: doGetSingleMock,
+  $doPost: doPostMock,
+  $doPut: doPutMock,
+}));
+
+import { kioskPing2 } from "../admin-funcs/kioskPing2.js";
+import { kioskCreateKioskDevice } from "../admin-funcs/kioskCreateKioskDevice.js";
+import { kioskGetKioskDevice } from "../admin-funcs/kioskGetKioskDevice.js";
+import { kioskUpdateKioskDevice } from "../admin-funcs/kioskUpdateKioskDevice.js";
+import { kioskCreateZoneDevice } from "../admin-funcs/kioskCreateZoneDevice.js";
+import { kioskCreateEvent } from "../admin-funcs/kioskCreateEvent.js";
+import { kioskHeartbeat } from "../admin-funcs/kioskHeartbeat.js";
+
+beforeEach(() => {
+  doGetSingleMock.mockClear();
+  doPostMock.mockClear();
+  doPutMock.mockClear();
+});
+
+describe("kioskPing2", () => {
+  it("calls the unauthenticated liveness route with no query parameters", () => {
+    const request = kioskPing2();
+
+    expect(doGetSingleMock).toHaveBeenCalledWith("/kiosks/ping2", {}, undefined);
+    expect(request).toBeDefined();
+  });
+
+  // The reachability probe passes a finite timeout so a half-open request cannot hang forever;
+  // that only works if the option actually reaches $doGetSingle.
+  it("forwards request options (e.g. timeoutMs) through to $doGetSingle", () => {
+    kioskPing2({ timeoutMs: 2000 });
+
+    expect(doGetSingleMock).toHaveBeenLastCalledWith("/kiosks/ping2", {}, { timeoutMs: 2000 });
+  });
+});
+
+describe("kioskCreateKioskDevice", () => {
+  it("posts to the unauthenticated device-registration route with the request body", () => {
+    const request = kioskCreateKioskDevice({ apns_token: "abc", sandbox: true });
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/kiosk-devices", { apns_token: "abc", sandbox: true });
+    expect(request).toBeDefined();
+  });
+});
+
+describe("kioskGetKioskDevice", () => {
+  it("builds the device+id+token path and sends no query parameters", () => {
+    kioskGetKioskDevice(42, "sekret");
+
+    expect(doGetSingleMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/kiosk-devices/42", {});
+  });
+
+  // The security token authenticates the request, so it must reach the path percent-encoded rather
+  // than dropped or sent as a query parameter.
+  it("percent-encodes the security token", () => {
+    kioskGetKioskDevice(42, "tok/en+with special=chars");
+
+    expect(doGetSingleMock).toHaveBeenCalledWith(
+      "/kiosk-api/42/tok%2Fen%2Bwith%20special%3Dchars/kiosk-devices/42",
+      {}
+    );
+  });
+});
+
+describe("kioskUpdateKioskDevice", () => {
+  it("PUTs the update body to the device+id+token path", () => {
+    const request = kioskUpdateKioskDevice(42, "sekret", { apns_token: "xyz" });
+
+    expect(doPutMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/kiosk-devices/42", { apns_token: "xyz" });
+    expect(request).toBeDefined();
+  });
+
+  it("percent-encodes the security token", () => {
+    kioskUpdateKioskDevice(42, "tok en", { apns_token: "xyz" });
+
+    expect(doPutMock).toHaveBeenCalledWith("/kiosk-api/42/tok%20en/kiosk-devices/42", { apns_token: "xyz" });
+  });
+});
+
+describe("kioskCreateZoneDevice", () => {
+  it("posts the zone id in the body, not the path", () => {
+    kioskCreateZoneDevice(42, "sekret", 7);
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/zone-devices", { zone_id: 7 });
+  });
+
+  it("percent-encodes the security token", () => {
+    kioskCreateZoneDevice(42, "tok en", 7);
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/42/tok%20en/zone-devices", { zone_id: 7 });
+  });
+});
+
+describe("kioskCreateEvent", () => {
+  it("posts the event name and value to the events route", () => {
+    kioskCreateEvent(42, "sekret", "print_job_completed", { pages: 1 });
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/events", {
+      name: "print_job_completed",
+      value: { pages: 1 },
+    });
+  });
+
+  // The ObjC fire-and-forget event calls sometimes have no payload; that must survive as an
+  // explicit null rather than being dropped, since it is what distinguishes "no value" from
+  // "value omitted" server-side.
+  it("normalizes an undefined value to null rather than dropping the field", () => {
+    kioskCreateEvent(42, "sekret", "printer_error", undefined);
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/events", {
+      name: "printer_error",
+      value: null,
+    });
+  });
+
+  it("percent-encodes the security token", () => {
+    kioskCreateEvent(42, "tok en", "printer_error", null);
+
+    expect(doPostMock).toHaveBeenCalledWith("/kiosk-api/42/tok%20en/events", {
+      name: "printer_error",
+      value: null,
+    });
+  });
+});
+
+describe("kioskHeartbeat", () => {
+  it("sends printer status, ip and last-notification timestamp as query parameters", () => {
+    const query = {
+      printer_status: "ok",
+      ip: "10.0.0.5",
+      date_received_notification: "2026-08-27T00:00:00Z",
+    };
+
+    kioskHeartbeat(42, "sekret", query);
+
+    expect(doGetSingleMock).toHaveBeenCalledWith("/kiosk-api/42/sekret/ping", query);
+  });
+
+  it("percent-encodes the security token", () => {
+    const query = { printer_status: "ok", ip: "10.0.0.5", date_received_notification: "2026-08-27T00:00:00Z" };
+
+    kioskHeartbeat(42, "tok en", query);
+
+    expect(doGetSingleMock).toHaveBeenCalledWith("/kiosk-api/42/tok%20en/ping", query);
+  });
+});

package/src/__tests__/lookups.test.ts

@@ -27,3 +27,54 @@ test("Lookups List Lookup Systems", async () => {
     systems: [],
   });
 });
+
+test("Lookups Lookup Postal Code", async () => {
+  const testHttpClient = createTestHTTPClient("lookupPostalCode");
+
+  const greenSecurity = new GreenSecurity({
+    serverURL: process.env["TEST_SERVER_URL"] ?? "https://localhost:3000/api",
+    httpClient: testHttpClient,
+    security: {
+      token: process.env["GREEN_SECURITY_TOKEN"] ?? "value",
+    },
+  });
+
+  const result = await greenSecurity.lookups.lookupPostalCode({
+    postalCode: "12383-0520",
+    state: "Rhode Island",
+    country: "Belgium",
+  });
+  expect(result).toBeDefined();
+  expect(result).toEqual({
+    status: "mismatch",
+    expectedStates: [],
+    error: "<value>",
+  });
+});
+
+test("Lookups Lookup Company Managers", async () => {
+  const testHttpClient = createTestHTTPClient("lookupCompanyManagers");
+
+  const greenSecurity = new GreenSecurity({
+    serverURL: process.env["TEST_SERVER_URL"] ?? "https://localhost:3000/api",
+    httpClient: testHttpClient,
+    security: {
+      token: process.env["GREEN_SECURITY_TOKEN"] ?? "value",
+    },
+  });
+
+  const result = await greenSecurity.lookups.lookupCompanyManagers({
+    companyId: 156948,
+  });
+  expect(result).toBeDefined();
+  expect(result).toEqual({
+    items: [
+      {
+        id: 226485,
+        firstName: "Eleonore",
+        lastName: "Swift",
+        email: "Garland_Larson59@hotmail.com",
+      },
+    ],
+  });
+});

package/src/__tests__/vendors.test.ts

@@ -121,7 +121,7 @@ test("Vendors List Vendor Credits", async () => {
       page: 1,
       useUrlParams: false,
     },
-    creditBalance: 7634.4,
+    creditBalance: 473.87,
   });
 });
 
@@ -1339,3 +1339,34 @@ test("Vendors Get Vendor Target Facilities", async () => {
     items: [],
   });
 });
+
+test("Vendors Get Vendor Screening Questions", async () => {
+  const testHttpClient = createTestHTTPClient("getVendorScreeningQuestions");
+
+  const greenSecurity = new GreenSecurity({
+    serverURL: process.env["TEST_SERVER_URL"] ?? "https://localhost:3000/api",
+    httpClient: testHttpClient,
+    security: {
+      token: process.env["GREEN_SECURITY_TOKEN"] ?? "value",
+    },
+  });
+
+  const result = await greenSecurity.vendors.getVendorScreeningQuestions({
+    vendorIdOrMe: "<value>",
+    facilityId: 657279,
+  });
+  expect(result).toBeDefined();
+  expect(result).toEqual({
+    pager: {
+      baseUrl: "api/vendors/job_titles",
+      sort: "job,title",
+      desc: 0,
+      itemCount: 228,
+      itemsPerPage: 860787,
+      page: 1,
+      useUrlParams: true,
+    },
+    items: [],
+    facilityName: "<value>",
+  });
+});

package/src/__tests__/webhooks.test.ts

@@ -20,7 +20,7 @@ test("Webhooks List All Webhook Endpoints", async () => {
   const testWebhookListForVendorUserResult = await greenSecurity.webhooks
     .listAllWebhookEndpoints({
       itemsPerPage: 25,
-      desc: true,
+      desc: 0,
       sort: "",
     });
   expect(testWebhookListForVendorUserResult).toBeDefined();

package/src/__tests__/zones.test.ts

@@ -39,7 +39,7 @@ test("Zones List Or Search Security Zones", async () => {
         facility: {
           contacts: {
             contact: {
-              status: "Inactive",
+              status: "Active",
               department: 123,
             },
             adminContact: {
@@ -47,7 +47,7 @@ test("Zones List Or Search Security Zones", async () => {
               department: 123,
             },
             techContact: {
-              status: "Deleted",
+              status: "Inactive",
               department: 123,
             },
             greenSecurityCsm: {
@@ -85,8 +85,9 @@ test("Zones Security Zone Checkin", async () => {
   });
 
   const result = await greenSecurity.zones.securityZoneCheckin({
-    qrCode: "<value>",
-    zoneId: 738916,
+    longitude: 8706.45,
+    latitude: 7315.87,
+    zoneId: 944641,
   });
   expect(result).toBeDefined();
   expect(result).toEqual({});

package/src/admin-funcs/dismissCommunication.ts

@@ -0,0 +1,20 @@
+import { APIPromise } from "../types/async.js";
+import { $doPost, internalApiResult } from "./doAdmin.js";
+
+// Records that the caller dismissed a communication (GSSD-7336).
+//
+// Internal for the same reason as listCommunications: it only means anything to our own portal.
+//
+// The durable half of a two-layer dismissal — the client suppresses locally straight away so a
+// banner does not flash back while this is in flight, and this row is what makes the timed
+// rules ("after a week", "after a month") hold on a second device. Whether a past dismissal
+// still suppresses anything is decided server-side on the next list call.
+//
+// The server re-checks the caller's audience before writing, so dismissing a communication that
+// was never aimed at you answers 404 rather than creating a row.
+export function dismissCommunication(communicationId: number): internalApiResult {
+  return new APIPromise($doPost(
+    `/communications/${communicationId}/dismiss`,
+    {},
+  ));
+}

package/src/admin-funcs/doAdmin.ts

@@ -201,10 +201,150 @@ export async function $doGetSingle<T extends object>(
   return [result, { status: "complete", request: req, response }];
 }
 
+type PostResult = Promise<
+  [
+    Result<
+      Json,
+      | errors.ApiErrorResponse
+      | GreenSecurityError
+      | ResponseValidationError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
+>;
+
+// Shared by the JSON and multipart posts below: everything except how the body is built and
+// whether we name a Content-Type. A multipart body must NOT carry one, because only fetch can
+// append the boundary it generates.
+async function $doPostBody(
+  route: string,
+  body: BodyInit | undefined,
+  contentTypeHeader: Record<string, string>,
+  options?: RequestOptions,
+): PostResult {
+  const client = getInternalCore();
+  if (!client) {
+    throw new Error("GreenSecurityCore client is not initialized.");
+  }
+
+  // Extract the path parameters from the request object
+  const pathParams = {}; //extractRouteParameters(route, request);
+
+  const path = pathToFunc(route)(pathParams);
+
+  const headers = new Headers(compactMap({
+    ...contentTypeHeader,
+    Accept: "application/json",
+  }));
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "internalApiRoutes",
+    oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    ...buildDoOptions(context, context.retryConfig, context.retryCodes),
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    Json,
+    | errors.ApiErrorResponse
+    | GreenSecurityError
+    | ResponseValidationError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >(
+    M.json(200, jsonSchema),
+    // A REST create answers 201, which matches none of the cases below — an unmatched status is
+    // an error, so the caller saw a failure for a request the server had accepted.
+    M.json(201, jsonSchema),
+    // 422 is a real answer here, not a surprise: the create returns it for a refused certificate
+    // and for a model validation failure. Left out, it fell through to M.fail("4XX"), which
+    // yields a generic APIError and hides the server's message from the form.
+    M.jsonErr([400, 401, 403, 404, 422], errors.ApiErrorResponse$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}
+
 export async function $doPost<T extends object>(
   route: string,
   postData: T,
   options?: RequestOptions,
+): PostResult {
+  return $doPostBody(
+    route,
+    encodeJSON("body", postData, { explode: true }),
+    { "Content-Type": "application/json" },
+    options,
+  );
+}
+
+// For a route that takes a file alongside its fields. The caller builds the FormData so it owns
+// the field naming the server expects (`wifi[ssid]`, `facility_ids[]`).
+export async function $doPostForm(
+  route: string,
+  form: FormData,
+  options?: RequestOptions,
+): PostResult {
+  return $doPostBody(route, form, {}, options);
+}
+
+export async function $doPut<T extends object>(
+  route: string,
+  putData: T,
+  options?: RequestOptions,
 ): Promise<
   [
     Result<
@@ -227,7 +367,7 @@ export async function $doPost<T extends object>(
     throw new Error("GreenSecurityCore client is not initialized.");
   }
 
-  const body = encodeJSON("body", postData, { explode: true });
+  const body = encodeJSON("body", putData, { explode: true });
 
   // Extract the path parameters from the request object
   const pathParams = {}; //extractRouteParameters(route, request);
@@ -259,7 +399,7 @@ export async function $doPost<T extends object>(
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "PUT",
     baseURL: options?.serverURL,
     path: path,
     headers: headers,

package/src/admin-funcs/getAppVersionStatus.ts

@@ -0,0 +1,21 @@
+import { APIPromise } from "../types/async.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { $doGetSingle, hashToQueryString, internalApiResult } from "./doAdmin.js";
+
+// Whether the calling build is below the minimum version configured for its app.
+//
+// Internal rather than part of the public spec: the answer is about one of our own apps against a
+// floor our ops set, which no third-party SDK consumer has any use for.
+//
+// Unauthenticated, and the app names itself in the query rather than relying on a user-agent
+// header: the internal core does not carry the app token the transport hook appends, and this is
+// asked on app launch, before anyone has signed in.
+export function getAppVersionStatus(
+  appName: string,
+  appVersion: string,
+  options?: RequestOptions,
+): internalApiResult {
+  const query = hashToQueryString({ app_name: appName, app_version: appVersion });
+
+  return new APIPromise($doGetSingle(`/app-version?${query}`, {}, options));
+}

package/src/admin-funcs/kioskCreateEvent.ts

@@ -0,0 +1,18 @@
+import { APIPromise } from "../types/async.js";
+import { $doPost, internalApiResult } from "./doAdmin.js";
+
+// Logs a kiosk event (print jobs, printer errors, vending requests, phone
+// home profiles, ...). `value` may be any JSON value or null.
+export function kioskCreateEvent(
+  kioskDeviceId: number,
+  securityToken: string,
+  name: string,
+  value: unknown,
+): internalApiResult {
+  return new APIPromise(
+    $doPost(
+      `/kiosk-api/${kioskDeviceId}/${encodeURIComponent(securityToken)}/events`,
+      { name, value: value ?? null },
+    )
+  );
+}

package/src/admin-funcs/kioskCreateKioskDevice.ts

@@ -0,0 +1,17 @@
+import { APIPromise } from "../types/async.js";
+import { $doPost, internalApiResult } from "./doAdmin.js";
+
+export type KioskCreateKioskDeviceRequest = {
+  apns_token?: string;
+  sandbox?: boolean;
+};
+
+// Registers a new kiosk device. Unauthenticated; the response contains the
+// device id and security token used by all subsequent kiosk-api calls.
+export function kioskCreateKioskDevice(
+  request: KioskCreateKioskDeviceRequest,
+): internalApiResult {
+  return new APIPromise(
+    $doPost(`/kiosk-api/kiosk-devices`, request)
+  );
+}

package/src/admin-funcs/kioskCreateZoneDevice.ts

@@ -0,0 +1,17 @@
+import { APIPromise } from "../types/async.js";
+import { $doPost, internalApiResult } from "./doAdmin.js";
+
+// Registers a zone device for the kiosk's zone. The response includes the
+// zone device id and a base64 PKCS#12 AWS IoT client certificate.
+export function kioskCreateZoneDevice(
+  kioskDeviceId: number,
+  securityToken: string,
+  zoneId: number,
+): internalApiResult {
+  return new APIPromise(
+    $doPost(
+      `/kiosk-api/${kioskDeviceId}/${encodeURIComponent(securityToken)}/zone-devices`,
+      { zone_id: zoneId },
+    )
+  );
+}

package/src/admin-funcs/kioskGetKioskDevice.ts

@@ -0,0 +1,16 @@
+import { APIPromise } from "../types/async.js";
+import { $doGetSingle, internalApiResult } from "./doAdmin.js";
+
+// Fetches the kiosk device (including its kiosk/zone assignment).
+// Kiosk-api routes authenticate via the device id + security token in the path.
+export function kioskGetKioskDevice(
+  kioskDeviceId: number,
+  securityToken: string,
+): internalApiResult {
+  return new APIPromise(
+    $doGetSingle(
+      `/kiosk-api/${kioskDeviceId}/${encodeURIComponent(securityToken)}/kiosk-devices/${kioskDeviceId}`,
+      {},
+    )
+  );
+}

package/src/admin-funcs/kioskHeartbeat.ts

@@ -0,0 +1,23 @@
+import { APIPromise } from "../types/async.js";
+import { $doGetSingle, internalApiResult } from "./doAdmin.js";
+
+export type KioskHeartbeatQuery = {
+  printer_status: string;
+  ip: string;
+  date_received_notification: string;
+};
+
+// 60-second keep-alive ping carrying printer status, local IP and the last
+// APNS heartbeat timestamp.
+export function kioskHeartbeat(
+  kioskDeviceId: number,
+  securityToken: string,
+  query: KioskHeartbeatQuery,
+): internalApiResult {
+  return new APIPromise(
+    $doGetSingle(
+      `/kiosk-api/${kioskDeviceId}/${encodeURIComponent(securityToken)}/ping`,
+      query,
+    )
+  );
+}

package/src/admin-funcs/kioskPing2.ts

@@ -0,0 +1,10 @@
+import { APIPromise } from "../types/async.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { $doGetSingle, internalApiResult } from "./doAdmin.js";
+
+// Unauthenticated server liveness probe used by the kiosk before setup.
+export function kioskPing2(options?: RequestOptions): internalApiResult {
+  return new APIPromise(
+    $doGetSingle(`/kiosks/ping2`, {}, options)
+  );
+}