@greensecurity/javascript-sdk 0.45.0-beta.8 → 0.45.0

package/src/__tests__/companies.test.ts

@@ -233,3 +233,23 @@ test("Companies List Company Credentials", async () => {
     },
   });
 });
+
+test("Companies List Company Manager Contacts", async () => {
+  const testHttpClient = createTestHTTPClient("listCompanyManagerContacts");
+
+  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.companies.listCompanyManagerContacts({
+    companyId: 389688,
+  });
+  expect(result).toBeDefined();
+  expect(result).toEqual({
+    items: [],
+  });
+});

package/src/__tests__/doAdmin.test.ts

@@ -1,10 +1,13 @@
-import { expect, test } from "vitest";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
 import type { HookContext } from "../hooks/types.js";
 import type { RetryConfig } from "../lib/retries.js";
 import {
+  $doPut,
   buildDoOptions,
   matchesInternalApiErrorStatusCode,
 } from "../admin-funcs/doAdmin.js";
+import { initializeInternalCoreByUrl } from "../admin-funcs/initializeCore.js";
+import { ApiErrorResponse } from "../models/errors/apierrorresponse.js";
 
 const retryConfig: RetryConfig = { strategy: "none" };
 const context: HookContext = {
@@ -47,3 +50,73 @@ test("buildDoOptions includes both legacy and current error matchers", () => {
   expect(compatibleOptions.isErrorStatusCode?.(302)).toBe(false);
   expect(compatibleOptions.retryCodes).toEqual(["429", "500"]);
 });
+
+const originalFetch = globalThis.fetch;
+
+beforeEach(() => {
+  initializeInternalCoreByUrl("test-token", "https://internal.test");
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+test("$doPut sends the JSON body via PUT and returns the parsed success payload", async () => {
+  const fetchMock = vi.fn(async (request: Request) => {
+    expect(request.method).toBe("PUT");
+    expect(await request.json()).toEqual({ name: "updated" });
+    return new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  });
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+  const [result, call] = await $doPut("/kiosks/1", { name: "updated" });
+
+  expect(fetchMock).toHaveBeenCalledTimes(1);
+  expect(result.ok).toBe(true);
+  expect(result.ok && result.value).toEqual({ ok: true });
+  expect(call.status).toBe("complete");
+});
+
+test("$doPut surfaces a typed 4xx as an ApiErrorResponse", async () => {
+  globalThis.fetch = vi.fn(async () =>
+    new Response(JSON.stringify({ error: "not found" }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" },
+    })
+  ) as unknown as typeof fetch;
+
+  const [result, call] = await $doPut("/kiosks/1", { name: "updated" });
+
+  expect(result.ok).toBe(false);
+  expect(!result.ok && result.error).toBeInstanceOf(ApiErrorResponse);
+  expect(!result.ok && (result.error as ApiErrorResponse).error).toBe(
+    "not found",
+  );
+  expect(call.status).toBe("complete");
+});
+
+test("$doPut surfaces a 5xx as a failed result", async () => {
+  globalThis.fetch = vi.fn(async () =>
+    new Response("internal error", { status: 500 })
+  ) as unknown as typeof fetch;
+
+  const [result, call] = await $doPut("/kiosks/1", { name: "updated" });
+
+  expect(result.ok).toBe(false);
+  expect(call.status).toBe("complete");
+});
+
+test("$doPut reports a network failure as a request-error", async () => {
+  globalThis.fetch = vi.fn(async () => {
+    throw new TypeError("fetch failed");
+  }) as unknown as typeof fetch;
+
+  const [result, call] = await $doPut("/kiosks/1", { name: "updated" });
+
+  expect(result.ok).toBe(false);
+  expect(call.status).toBe("request-error");
+});

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: 5361.49,
+    creditBalance: 5488.14,
   });
 });
 
@@ -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,64 +39,30 @@ test("Zones List Or Search Security Zones", async () => {
         facility: {
           contacts: {
             contact: {
-              status: "Inactive",
-              department: null,
-            },
-            adminContact: {
-              status: "Deleted",
-              department: 123,
-            },
-            techContact: {
-              status: "Deleted",
-              department: 123,
-            },
-            greenSecurityCsm: {
-              status: "Deleted",
-              department: 123,
-            },
-            accountManager: {
               status: "Active",
               department: 123,
             },
-          },
-          vendorGuestPolicy: {
-            enabled: false,
-            vendorGuestLimitAndOr: "and",
-            vendorGuestRequireEmail: false,
-          },
-        },
-      },
-      {
-        facility: {
-          contacts: {
-            contact: {
-              status: "Inactive",
-              department: null,
-            },
             adminContact: {
-              status: "Deleted",
+              status: "Active",
               department: 123,
             },
             techContact: {
-              status: "Deleted",
-              department: 123,
-            },
-            greenSecurityCsm: {
-              status: "Deleted",
-              department: 123,
-            },
-            accountManager: {
-              status: "Active",
+              status: "Inactive",
               department: 123,
             },
+            greenSecurityCsm: null,
+            accountManager: null,
           },
           vendorGuestPolicy: {
-            enabled: false,
+            enabled: true,
             vendorGuestLimitAndOr: "and",
             vendorGuestRequireEmail: false,
           },
         },
       },
+      {
+        facility: {},
+      },
     ],
   });
 });
@@ -114,7 +80,7 @@ test("Zones Security Zone Checkin", async () => {
 
   const result = await greenSecurity.zones.securityZoneCheckin({
     qrCode: "<value>",
-    zoneId: 834385,
+    zoneId: 891667,
   });
   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

@@ -308,6 +308,113 @@ export async function $doPost<T extends object>(
   return [result, { status: "complete", request: req, response }];
 }
 
+export async function $doPut<T extends object>(
+  route: string,
+  putData: T,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      Json,
+      | errors.ApiErrorResponse
+      | GreenSecurityError
+      | ResponseValidationError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
+> {
+  const client = getInternalCore();
+  if (!client) {
+    throw new Error("GreenSecurityCore client is not initialized.");
+  }
+
+  const body = encodeJSON("body", putData, { explode: true });
+
+  // Extract the path parameters from the request object
+  const pathParams = {}; //extractRouteParameters(route, request);
+
+  const path = pathToFunc(route)(pathParams);
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    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: "PUT",
+    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),
+    M.jsonErr([400, 401, 403, 404], 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 function hashToQueryString(hash: Record<string, any>): string {
   const params = [];
   for (const key in hash) {

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));
+}