@greensecurity/javascript-sdk 0.44.0-beta.6 → 0.44.0-beta.61

package/src/models/components/zone.ts

@@ -9,9 +9,24 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import { Department, Department$inboundSchema } from "./department.js";
-import { Facility, Facility$inboundSchema } from "./facility.js";
-import { ZoneConfig, ZoneConfig$inboundSchema } from "./zoneconfig.js";
+import {
+  Department,
+  Department$inboundSchema,
+  Department$Outbound,
+  Department$outboundSchema,
+} from "./department.js";
+import {
+  Facility,
+  Facility$inboundSchema,
+  Facility$Outbound,
+  Facility$outboundSchema,
+} from "./facility.js";
+import {
+  ZoneConfig,
+  ZoneConfig$inboundSchema,
+  ZoneConfig$Outbound,
+  ZoneConfig$outboundSchema,
+} from "./zoneconfig.js";
 
 export type Facility2 = {
   id?: number | undefined;
@@ -83,6 +98,11 @@ export type GpsCheckinPolicy = {
   latitude?: string | null | undefined;
   longitude?: string | null | undefined;
   gpsCheckinRadius?: number | null | undefined;
+  allowGpsCheckout?: boolean | null | undefined;
+  /**
+   * Radius in feet around the zone coordinates used for zone-level automatic GPS check-out.
+   */
+  gpsCheckoutRadius?: number | null | undefined;
   geocodeError?: string | null | undefined;
 };
 
@@ -117,7 +137,25 @@ export const Facility2$inboundSchema: z.ZodType<
   id: types.optional(types.number()),
   name: types.optional(types.string()),
 });
+/** @internal */
+export type Facility2$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const Facility2$outboundSchema: z.ZodType<
+  Facility2$Outbound,
+  z.ZodTypeDef,
+  Facility2
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+});
 
+export function facility2ToJSON(facility2: Facility2): string {
+  return JSON.stringify(Facility2$outboundSchema.parse(facility2));
+}
 export function facility2FromJSON(
   jsonString: string,
 ): SafeParseResult<Facility2, SDKValidationError> {
@@ -134,7 +172,22 @@ export const ZoneFacility$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([Facility$inboundSchema, z.lazy(() => Facility2$inboundSchema)]);
+/** @internal */
+export type ZoneFacility$Outbound = Facility$Outbound | Facility2$Outbound;
 
+/** @internal */
+export const ZoneFacility$outboundSchema: z.ZodType<
+  ZoneFacility$Outbound,
+  z.ZodTypeDef,
+  ZoneFacility
+> = smartUnion([
+  Facility$outboundSchema,
+  z.lazy(() => Facility2$outboundSchema),
+]);
+
+export function zoneFacilityToJSON(zoneFacility: ZoneFacility): string {
+  return JSON.stringify(ZoneFacility$outboundSchema.parse(zoneFacility));
+}
 export function zoneFacilityFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneFacility, SDKValidationError> {
@@ -151,7 +204,19 @@ export const ZoneDepartment$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([Department$inboundSchema, types.number()]);
+/** @internal */
+export type ZoneDepartment$Outbound = Department$Outbound | number;
+
+/** @internal */
+export const ZoneDepartment$outboundSchema: z.ZodType<
+  ZoneDepartment$Outbound,
+  z.ZodTypeDef,
+  ZoneDepartment
+> = smartUnion([Department$outboundSchema, z.number().int()]);
 
+export function zoneDepartmentToJSON(zoneDepartment: ZoneDepartment): string {
+  return JSON.stringify(ZoneDepartment$outboundSchema.parse(zoneDepartment));
+}
 export function zoneDepartmentFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneDepartment, SDKValidationError> {
@@ -179,7 +244,36 @@ export const ZoneLocation$inboundSchema: z.ZodType<
     "floor_number": "floorNumber",
   });
 });
+/** @internal */
+export type ZoneLocation$Outbound = {
+  street_address?: string | null | undefined;
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+  zip?: string | null | undefined;
+  floor_number?: number | null | undefined;
+};
 
+/** @internal */
+export const ZoneLocation$outboundSchema: z.ZodType<
+  ZoneLocation$Outbound,
+  z.ZodTypeDef,
+  ZoneLocation
+> = z.object({
+  streetAddress: z.nullable(z.string()).optional(),
+  city: z.nullable(z.string()).optional(),
+  state: z.nullable(z.string()).optional(),
+  zip: z.nullable(z.string()).optional(),
+  floorNumber: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    streetAddress: "street_address",
+    floorNumber: "floor_number",
+  });
+});
+
+export function zoneLocationToJSON(zoneLocation: ZoneLocation): string {
+  return JSON.stringify(ZoneLocation$outboundSchema.parse(zoneLocation));
+}
 export function zoneLocationFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneLocation, SDKValidationError> {
@@ -207,7 +301,39 @@ export const KioskOfflineNotification$inboundSchema: z.ZodType<
     "auto_deactivate": "autoDeactivate",
   });
 });
+/** @internal */
+export type KioskOfflineNotification$Outbound = {
+  is_offline?: boolean | null | undefined;
+  message?: string | null | undefined;
+  auto_activate?: string | null | undefined;
+  auto_deactivate?: string | null | undefined;
+};
+
+/** @internal */
+export const KioskOfflineNotification$outboundSchema: z.ZodType<
+  KioskOfflineNotification$Outbound,
+  z.ZodTypeDef,
+  KioskOfflineNotification
+> = z.object({
+  isOffline: z.nullable(z.boolean()).optional(),
+  message: z.nullable(z.string()).optional(),
+  autoActivate: z.nullable(z.string()).optional(),
+  autoDeactivate: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    isOffline: "is_offline",
+    autoActivate: "auto_activate",
+    autoDeactivate: "auto_deactivate",
+  });
+});
 
+export function kioskOfflineNotificationToJSON(
+  kioskOfflineNotification: KioskOfflineNotification,
+): string {
+  return JSON.stringify(
+    KioskOfflineNotification$outboundSchema.parse(kioskOfflineNotification),
+  );
+}
 export function kioskOfflineNotificationFromJSON(
   jsonString: string,
 ): SafeParseResult<KioskOfflineNotification, SDKValidationError> {
@@ -240,7 +366,46 @@ export const ZoneVendorPolicy$inboundSchema: z.ZodType<
     "override_limit_days": "overrideLimitDays",
   });
 });
+/** @internal */
+export type ZoneVendorPolicy$Outbound = {
+  allow_gps_checkin?: boolean | undefined;
+  allow_scrubs?: boolean | undefined;
+  allow_vendor_scans?: boolean | undefined;
+  requires_checkin_for_scrubs?: boolean | undefined;
+  override_limit?: number | null | undefined;
+  override_limit_days?: number | null | undefined;
+};
 
+/** @internal */
+export const ZoneVendorPolicy$outboundSchema: z.ZodType<
+  ZoneVendorPolicy$Outbound,
+  z.ZodTypeDef,
+  ZoneVendorPolicy
+> = z.object({
+  allowGpsCheckin: z.boolean().optional(),
+  allowScrubs: z.boolean().optional(),
+  allowVendorScans: z.boolean().optional(),
+  requiresCheckinForScrubs: z.boolean().optional(),
+  overrideLimit: z.nullable(z.number().int()).optional(),
+  overrideLimitDays: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allowGpsCheckin: "allow_gps_checkin",
+    allowScrubs: "allow_scrubs",
+    allowVendorScans: "allow_vendor_scans",
+    requiresCheckinForScrubs: "requires_checkin_for_scrubs",
+    overrideLimit: "override_limit",
+    overrideLimitDays: "override_limit_days",
+  });
+});
+
+export function zoneVendorPolicyToJSON(
+  zoneVendorPolicy: ZoneVendorPolicy,
+): string {
+  return JSON.stringify(
+    ZoneVendorPolicy$outboundSchema.parse(zoneVendorPolicy),
+  );
+}
 export function zoneVendorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneVendorPolicy, SDKValidationError> {
@@ -271,7 +436,43 @@ export const ZoneVisitorCheckinPolicy$inboundSchema: z.ZodType<
     "max_visitor_count": "maxVisitorCount",
   });
 });
+/** @internal */
+export type ZoneVisitorCheckinPolicy$Outbound = {
+  allow_checkin?: boolean | undefined;
+  allow_visiting?: boolean | undefined;
+  allow_visiting_rooms?: boolean | undefined;
+  auto_checkout?: boolean | undefined;
+  max_visitor_count?: number | null | undefined;
+};
 
+/** @internal */
+export const ZoneVisitorCheckinPolicy$outboundSchema: z.ZodType<
+  ZoneVisitorCheckinPolicy$Outbound,
+  z.ZodTypeDef,
+  ZoneVisitorCheckinPolicy
+> = z.object({
+  allowCheckin: z.boolean().optional(),
+  allowVisiting: z.boolean().optional(),
+  allowVisitingRooms: z.boolean().optional(),
+  autoCheckout: z.boolean().optional(),
+  maxVisitorCount: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allowCheckin: "allow_checkin",
+    allowVisiting: "allow_visiting",
+    allowVisitingRooms: "allow_visiting_rooms",
+    autoCheckout: "auto_checkout",
+    maxVisitorCount: "max_visitor_count",
+  });
+});
+
+export function zoneVisitorCheckinPolicyToJSON(
+  zoneVisitorCheckinPolicy: ZoneVisitorCheckinPolicy,
+): string {
+  return JSON.stringify(
+    ZoneVisitorCheckinPolicy$outboundSchema.parse(zoneVisitorCheckinPolicy),
+  );
+}
 export function zoneVisitorCheckinPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneVisitorCheckinPolicy, SDKValidationError> {
@@ -312,7 +513,58 @@ export const ZoneVisitRequestPolicy$inboundSchema: z.ZodType<
     "restrict_to_scan_only": "restrictToScanOnly",
   });
 });
+/** @internal */
+export type ZoneVisitRequestPolicy$Outbound = {
+  allow_visiting?: boolean | undefined;
+  watchlist_hit_message?: string | null | undefined;
+  watchdog_hit_message?: string | null | undefined;
+  guest_limit_exceeded_message?: string | null | undefined;
+  denied_background_vendor_message?: string | null | undefined;
+  locked_vendor_message?: string | null | undefined;
+  stop_checkin_message?: string | null | undefined;
+  success_message?: string | null | undefined;
+  show_general_visitor?: boolean | undefined;
+  restrict_to_scan_only?: boolean | undefined;
+};
+
+/** @internal */
+export const ZoneVisitRequestPolicy$outboundSchema: z.ZodType<
+  ZoneVisitRequestPolicy$Outbound,
+  z.ZodTypeDef,
+  ZoneVisitRequestPolicy
+> = z.object({
+  allowVisiting: z.boolean().optional(),
+  watchlistHitMessage: z.nullable(z.string()).optional(),
+  watchdogHitMessage: z.nullable(z.string()).optional(),
+  guestLimitExceededMessage: z.nullable(z.string()).optional(),
+  deniedBackgroundVendorMessage: z.nullable(z.string()).optional(),
+  lockedVendorMessage: z.nullable(z.string()).optional(),
+  stopCheckinMessage: z.nullable(z.string()).optional(),
+  successMessage: z.nullable(z.string()).optional(),
+  showGeneralVisitor: z.boolean().optional(),
+  restrictToScanOnly: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allowVisiting: "allow_visiting",
+    watchlistHitMessage: "watchlist_hit_message",
+    watchdogHitMessage: "watchdog_hit_message",
+    guestLimitExceededMessage: "guest_limit_exceeded_message",
+    deniedBackgroundVendorMessage: "denied_background_vendor_message",
+    lockedVendorMessage: "locked_vendor_message",
+    stopCheckinMessage: "stop_checkin_message",
+    successMessage: "success_message",
+    showGeneralVisitor: "show_general_visitor",
+    restrictToScanOnly: "restrict_to_scan_only",
+  });
+});
 
+export function zoneVisitRequestPolicyToJSON(
+  zoneVisitRequestPolicy: ZoneVisitRequestPolicy,
+): string {
+  return JSON.stringify(
+    ZoneVisitRequestPolicy$outboundSchema.parse(zoneVisitRequestPolicy),
+  );
+}
 export function zoneVisitRequestPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneVisitRequestPolicy, SDKValidationError> {
@@ -343,7 +595,43 @@ export const PrinterConfig$inboundSchema: z.ZodType<
     "dymo_brightness_adjust": "dymoBrightnessAdjust",
   });
 });
+/** @internal */
+export type PrinterConfig$Outbound = {
+  type?: string | null | undefined;
+  name?: string | null | undefined;
+  dpi?: number | null | undefined;
+  ip?: string | null | undefined;
+  port?: string | null | undefined;
+  email?: string | null | undefined;
+  flip?: boolean | undefined;
+  orientation?: string | null | undefined;
+  dymo_brightness_adjust?: number | null | undefined;
+};
 
+/** @internal */
+export const PrinterConfig$outboundSchema: z.ZodType<
+  PrinterConfig$Outbound,
+  z.ZodTypeDef,
+  PrinterConfig
+> = z.object({
+  type: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
+  dpi: z.nullable(z.number().int()).optional(),
+  ip: z.nullable(z.string()).optional(),
+  port: z.nullable(z.string()).optional(),
+  email: z.nullable(z.string()).optional(),
+  flip: z.boolean().optional(),
+  orientation: z.nullable(z.string()).optional(),
+  dymoBrightnessAdjust: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dymoBrightnessAdjust: "dymo_brightness_adjust",
+  });
+});
+
+export function printerConfigToJSON(printerConfig: PrinterConfig): string {
+  return JSON.stringify(PrinterConfig$outboundSchema.parse(printerConfig));
+}
 export function printerConfigFromJSON(
   jsonString: string,
 ): SafeParseResult<PrinterConfig, SDKValidationError> {
@@ -363,14 +651,55 @@ export const GpsCheckinPolicy$inboundSchema: z.ZodType<
   latitude: z.nullable(types.string()).optional(),
   longitude: z.nullable(types.string()).optional(),
   gps_checkin_radius: z.nullable(types.number()).optional(),
+  allow_gps_checkout: z.nullable(types.boolean()).optional(),
+  gps_checkout_radius: z.nullable(types.number()).optional(),
   geocode_error: z.nullable(types.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "gps_checkin_radius": "gpsCheckinRadius",
+    "allow_gps_checkout": "allowGpsCheckout",
+    "gps_checkout_radius": "gpsCheckoutRadius",
     "geocode_error": "geocodeError",
   });
 });
+/** @internal */
+export type GpsCheckinPolicy$Outbound = {
+  latitude?: string | null | undefined;
+  longitude?: string | null | undefined;
+  gps_checkin_radius?: number | null | undefined;
+  allow_gps_checkout?: boolean | null | undefined;
+  gps_checkout_radius?: number | null | undefined;
+  geocode_error?: string | null | undefined;
+};
 
+/** @internal */
+export const GpsCheckinPolicy$outboundSchema: z.ZodType<
+  GpsCheckinPolicy$Outbound,
+  z.ZodTypeDef,
+  GpsCheckinPolicy
+> = z.object({
+  latitude: z.nullable(z.string()).optional(),
+  longitude: z.nullable(z.string()).optional(),
+  gpsCheckinRadius: z.nullable(z.number().int()).optional(),
+  allowGpsCheckout: z.nullable(z.boolean()).optional(),
+  gpsCheckoutRadius: z.nullable(z.number().int()).optional(),
+  geocodeError: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    gpsCheckinRadius: "gps_checkin_radius",
+    allowGpsCheckout: "allow_gps_checkout",
+    gpsCheckoutRadius: "gps_checkout_radius",
+    geocodeError: "geocode_error",
+  });
+});
+
+export function gpsCheckinPolicyToJSON(
+  gpsCheckinPolicy: GpsCheckinPolicy,
+): string {
+  return JSON.stringify(
+    GpsCheckinPolicy$outboundSchema.parse(gpsCheckinPolicy),
+  );
+}
 export function gpsCheckinPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<GpsCheckinPolicy, SDKValidationError> {
@@ -427,7 +756,72 @@ export const Zone$inboundSchema: z.ZodType<Zone, z.ZodTypeDef, unknown> = z
       "gps_checkin_policy": "gpsCheckinPolicy",
     });
   });
+/** @internal */
+export type Zone$Outbound = {
+  id?: number | undefined;
+  facility?: Facility$Outbound | Facility2$Outbound | null | undefined;
+  department?: Department$Outbound | number | null | undefined;
+  name?: string | null | undefined;
+  short_name?: string | null | undefined;
+  description?: string | null | undefined;
+  status?: string | null | undefined;
+  notes?: string | null | undefined;
+  rules?: Array<ZoneConfig$Outbound | null> | null | undefined;
+  location?: ZoneLocation$Outbound | undefined;
+  kiosk_offline_notification?: KioskOfflineNotification$Outbound | undefined;
+  vendor_policy?: ZoneVendorPolicy$Outbound | undefined;
+  visitor_checkin_policy?: ZoneVisitorCheckinPolicy$Outbound | undefined;
+  visit_request_policy?: ZoneVisitRequestPolicy$Outbound | undefined;
+  printer_config?: PrinterConfig$Outbound | undefined;
+  gps_checkin_policy?: GpsCheckinPolicy$Outbound | undefined;
+};
+
+/** @internal */
+export const Zone$outboundSchema: z.ZodType<Zone$Outbound, z.ZodTypeDef, Zone> =
+  z.object({
+    id: z.number().int().optional(),
+    facility: z.nullable(
+      smartUnion([
+        Facility$outboundSchema,
+        z.lazy(() => Facility2$outboundSchema),
+      ]),
+    ).optional(),
+    department: z.nullable(
+      smartUnion([Department$outboundSchema, z.number().int()]),
+    ).optional(),
+    name: z.nullable(z.string()).optional(),
+    shortName: z.nullable(z.string()).optional(),
+    description: z.nullable(z.string()).optional(),
+    status: z.nullable(z.string()).optional(),
+    notes: z.nullable(z.string()).optional(),
+    rules: z.nullable(z.array(z.nullable(ZoneConfig$outboundSchema)))
+      .optional(),
+    location: z.lazy(() => ZoneLocation$outboundSchema).optional(),
+    kioskOfflineNotification: z.lazy(() =>
+      KioskOfflineNotification$outboundSchema
+    ).optional(),
+    vendorPolicy: z.lazy(() => ZoneVendorPolicy$outboundSchema).optional(),
+    visitorCheckinPolicy: z.lazy(() => ZoneVisitorCheckinPolicy$outboundSchema)
+      .optional(),
+    visitRequestPolicy: z.lazy(() => ZoneVisitRequestPolicy$outboundSchema)
+      .optional(),
+    printerConfig: z.lazy(() => PrinterConfig$outboundSchema).optional(),
+    gpsCheckinPolicy: z.lazy(() => GpsCheckinPolicy$outboundSchema).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      shortName: "short_name",
+      kioskOfflineNotification: "kiosk_offline_notification",
+      vendorPolicy: "vendor_policy",
+      visitorCheckinPolicy: "visitor_checkin_policy",
+      visitRequestPolicy: "visit_request_policy",
+      printerConfig: "printer_config",
+      gpsCheckinPolicy: "gps_checkin_policy",
+    });
+  });
 
+export function zoneToJSON(zone: Zone): string {
+  return JSON.stringify(Zone$outboundSchema.parse(zone));
+}
 export function zoneFromJSON(
   jsonString: string,
 ): SafeParseResult<Zone, SDKValidationError> {