@greensecurity/javascript-sdk 0.44.0-beta.55 → 0.44.0-beta.56

package/src/models/components/facility.ts

@@ -11,13 +11,30 @@ 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 { Contact, Contact$inboundSchema } from "./contact.js";
+import {
+  Contact,
+  Contact$inboundSchema,
+  Contact$Outbound,
+  Contact$outboundSchema,
+} from "./contact.js";
 import {
   FacilityVendorType,
   FacilityVendorType$inboundSchema,
+  FacilityVendorType$Outbound,
+  FacilityVendorType$outboundSchema,
 } from "./facilityvendortype.js";
-import { ImageSet, ImageSet$inboundSchema } from "./imageset.js";
-import { SystemSummary, SystemSummary$inboundSchema } from "./systemsummary.js";
+import {
+  ImageSet,
+  ImageSet$inboundSchema,
+  ImageSet$Outbound,
+  ImageSet$outboundSchema,
+} from "./imageset.js";
+import {
+  SystemSummary,
+  SystemSummary$inboundSchema,
+  SystemSummary$Outbound,
+  SystemSummary$outboundSchema,
+} from "./systemsummary.js";
 
 export type AppointmentPolicy = {
   standingApptPeriod?: string | undefined;
@@ -117,7 +134,7 @@ export type VendorGuestLimitAndOr = OpenEnum<typeof VendorGuestLimitAndOr>;
 export type VendorGuestPolicy = {
   enabled: boolean;
   vendorGuestLimit?: number | undefined;
-  vendorGuestLimitAndOr: VendorGuestLimitAndOr;
+  vendorGuestLimitAndOr?: VendorGuestLimitAndOr | undefined;
   vendorGuestLimitDays?: number | undefined;
   vendorGuestRequireEmail: boolean;
 };
@@ -199,7 +216,49 @@ export const AppointmentPolicy$inboundSchema: z.ZodType<
     "max_invites_per_appt": "maxInvitesPerAppt",
   });
 });
+/** @internal */
+export type AppointmentPolicy$Outbound = {
+  standing_appt_period?: string | undefined;
+  appt_request_info?: string | undefined;
+  allow_vendor_appt_requests?: boolean | undefined;
+  allow_contact_appt_requests?: boolean | undefined;
+  allow_pending_vendor_appt_requests?: boolean | undefined;
+  allow_multi_facility_appt_requests?: boolean | undefined;
+  max_invites_per_appt?: number | undefined;
+};
+
+/** @internal */
+export const AppointmentPolicy$outboundSchema: z.ZodType<
+  AppointmentPolicy$Outbound,
+  z.ZodTypeDef,
+  AppointmentPolicy
+> = z.object({
+  standingApptPeriod: z.string().optional(),
+  apptRequestInfo: z.string().optional(),
+  allowVendorApptRequests: z.boolean().optional(),
+  allowContactApptRequests: z.boolean().optional(),
+  allowPendingVendorApptRequests: z.boolean().optional(),
+  allowMultiFacilityApptRequests: z.boolean().optional(),
+  maxInvitesPerAppt: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    standingApptPeriod: "standing_appt_period",
+    apptRequestInfo: "appt_request_info",
+    allowVendorApptRequests: "allow_vendor_appt_requests",
+    allowContactApptRequests: "allow_contact_appt_requests",
+    allowPendingVendorApptRequests: "allow_pending_vendor_appt_requests",
+    allowMultiFacilityApptRequests: "allow_multi_facility_appt_requests",
+    maxInvitesPerAppt: "max_invites_per_appt",
+  });
+});
 
+export function appointmentPolicyToJSON(
+  appointmentPolicy: AppointmentPolicy,
+): string {
+  return JSON.stringify(
+    AppointmentPolicy$outboundSchema.parse(appointmentPolicy),
+  );
+}
 export function appointmentPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<AppointmentPolicy, SDKValidationError> {
@@ -229,7 +288,38 @@ export const Contacts$inboundSchema: z.ZodType<
     "account_manager": "accountManager",
   });
 });
+/** @internal */
+export type Contacts$Outbound = {
+  contact?: Contact$Outbound | null | undefined;
+  admin_contact?: Contact$Outbound | null | undefined;
+  tech_contact?: Contact$Outbound | null | undefined;
+  green_security_csm?: Contact$Outbound | null | undefined;
+  account_manager?: Contact$Outbound | null | undefined;
+};
+
+/** @internal */
+export const Contacts$outboundSchema: z.ZodType<
+  Contacts$Outbound,
+  z.ZodTypeDef,
+  Contacts
+> = z.object({
+  contact: z.nullable(Contact$outboundSchema).optional(),
+  adminContact: z.nullable(Contact$outboundSchema).optional(),
+  techContact: z.nullable(Contact$outboundSchema).optional(),
+  greenSecurityCsm: z.nullable(Contact$outboundSchema).optional(),
+  accountManager: z.nullable(Contact$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    adminContact: "admin_contact",
+    techContact: "tech_contact",
+    greenSecurityCsm: "green_security_csm",
+    accountManager: "account_manager",
+  });
+});
 
+export function contactsToJSON(contacts: Contacts): string {
+  return JSON.stringify(Contacts$outboundSchema.parse(contacts));
+}
 export function contactsFromJSON(
   jsonString: string,
 ): SafeParseResult<Contacts, SDKValidationError> {
@@ -266,7 +356,48 @@ export const VendorCounts$inboundSchema: z.ZodType<
     "count_primary_inactive_pending": "countPrimaryInactivePending",
   });
 });
+/** @internal */
+export type VendorCounts$Outbound = {
+  count_targeted_active_approved?: number | undefined;
+  count_targeted_active_pending?: number | undefined;
+  count_targeted_inactive_approved?: number | undefined;
+  count_targeted_inactive_pending?: number | undefined;
+  count_primary_active_approved?: number | undefined;
+  count_primary_active_pending?: number | undefined;
+  count_primary_inactive_approved?: number | undefined;
+  count_primary_inactive_pending?: number | undefined;
+};
+
+/** @internal */
+export const VendorCounts$outboundSchema: z.ZodType<
+  VendorCounts$Outbound,
+  z.ZodTypeDef,
+  VendorCounts
+> = z.object({
+  countTargetedActiveApproved: z.number().int().optional(),
+  countTargetedActivePending: z.number().int().optional(),
+  countTargetedInactiveApproved: z.number().int().optional(),
+  countTargetedInactivePending: z.number().int().optional(),
+  countPrimaryActiveApproved: z.number().int().optional(),
+  countPrimaryActivePending: z.number().int().optional(),
+  countPrimaryInactiveApproved: z.number().int().optional(),
+  countPrimaryInactivePending: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    countTargetedActiveApproved: "count_targeted_active_approved",
+    countTargetedActivePending: "count_targeted_active_pending",
+    countTargetedInactiveApproved: "count_targeted_inactive_approved",
+    countTargetedInactivePending: "count_targeted_inactive_pending",
+    countPrimaryActiveApproved: "count_primary_active_approved",
+    countPrimaryActivePending: "count_primary_active_pending",
+    countPrimaryInactiveApproved: "count_primary_inactive_approved",
+    countPrimaryInactivePending: "count_primary_inactive_pending",
+  });
+});
 
+export function vendorCountsToJSON(vendorCounts: VendorCounts): string {
+  return JSON.stringify(VendorCounts$outboundSchema.parse(vendorCounts));
+}
 export function vendorCountsFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorCounts, SDKValidationError> {
@@ -283,7 +414,23 @@ export const FacilityFluCredential$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([types.string(), types.number()]);
+/** @internal */
+export type FacilityFluCredential$Outbound = string | number;
 
+/** @internal */
+export const FacilityFluCredential$outboundSchema: z.ZodType<
+  FacilityFluCredential$Outbound,
+  z.ZodTypeDef,
+  FacilityFluCredential
+> = smartUnion([z.string(), z.number().int()]);
+
+export function facilityFluCredentialToJSON(
+  facilityFluCredential: FacilityFluCredential,
+): string {
+  return JSON.stringify(
+    FacilityFluCredential$outboundSchema.parse(facilityFluCredential),
+  );
+}
 export function facilityFluCredentialFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityFluCredential, SDKValidationError> {
@@ -311,7 +458,38 @@ export const FluCredential$inboundSchema: z.ZodType<
     "flu_date_ends": "fluDateEnds",
   });
 });
+/** @internal */
+export type FluCredential$Outbound = {
+  flu_credential?: string | number | null | undefined;
+  flu_date_begins?: string | null | undefined;
+  flu_date_ends?: string | null | undefined;
+};
+
+/** @internal */
+export const FluCredential$outboundSchema: z.ZodType<
+  FluCredential$Outbound,
+  z.ZodTypeDef,
+  FluCredential
+> = z.object({
+  fluCredential: z.nullable(smartUnion([z.string(), z.number().int()]))
+    .optional(),
+  fluDateBegins: z.nullable(
+    z.date().transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+  ).optional(),
+  fluDateEnds: z.nullable(
+    z.date().transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fluCredential: "flu_credential",
+    fluDateBegins: "flu_date_begins",
+    fluDateEnds: "flu_date_ends",
+  });
+});
 
+export function fluCredentialToJSON(fluCredential: FluCredential): string {
+  return JSON.stringify(FluCredential$outboundSchema.parse(fluCredential));
+}
 export function fluCredentialFromJSON(
   jsonString: string,
 ): SafeParseResult<FluCredential, SDKValidationError> {
@@ -344,7 +522,50 @@ export const FacilityLocation$inboundSchema: z.ZodType<
     "utc_offset": "utcOffset",
   });
 });
+/** @internal */
+export type FacilityLocation$Outbound = {
+  street_address?: string | null | undefined;
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+  zip?: string | null | undefined;
+  email?: string | null | undefined;
+  phone?: string | null | undefined;
+  fax?: string | null | undefined;
+  website?: string | null | undefined;
+  utc_offset?: number | null | undefined;
+  timezone?: string | null | undefined;
+};
+
+/** @internal */
+export const FacilityLocation$outboundSchema: z.ZodType<
+  FacilityLocation$Outbound,
+  z.ZodTypeDef,
+  FacilityLocation
+> = 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(),
+  email: z.nullable(z.string()).optional(),
+  phone: z.nullable(z.string()).optional(),
+  fax: z.nullable(z.string()).optional(),
+  website: z.nullable(z.string()).optional(),
+  utcOffset: z.nullable(z.number()).optional(),
+  timezone: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    streetAddress: "street_address",
+    utcOffset: "utc_offset",
+  });
+});
 
+export function facilityLocationToJSON(
+  facilityLocation: FacilityLocation,
+): string {
+  return JSON.stringify(
+    FacilityLocation$outboundSchema.parse(facilityLocation),
+  );
+}
 export function facilityLocationFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityLocation, SDKValidationError> {
@@ -371,7 +592,33 @@ export const ScrubsPolicy$inboundSchema: z.ZodType<
     "minutes_between_scrub_debits": "minutesBetweenScrubDebits",
   });
 });
+/** @internal */
+export type ScrubsPolicy$Outbound = {
+  unlimited_scrubs?: boolean | undefined;
+  scrub_debits_per_day?: number | undefined;
+  minutes_between_scrub_debits?: number | undefined;
+};
+
+/** @internal */
+export const ScrubsPolicy$outboundSchema: z.ZodType<
+  ScrubsPolicy$Outbound,
+  z.ZodTypeDef,
+  ScrubsPolicy
+> = z.object({
+  unlimitedScrubs: z.boolean().optional(),
+  scrubDebitsPerDay: z.number().int().optional(),
+  minutesBetweenScrubDebits: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    unlimitedScrubs: "unlimited_scrubs",
+    scrubDebitsPerDay: "scrub_debits_per_day",
+    minutesBetweenScrubDebits: "minutes_between_scrub_debits",
+  });
+});
 
+export function scrubsPolicyToJSON(scrubsPolicy: ScrubsPolicy): string {
+  return JSON.stringify(ScrubsPolicy$outboundSchema.parse(scrubsPolicy));
+}
 export function scrubsPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<ScrubsPolicy, SDKValidationError> {
@@ -388,7 +635,19 @@ export const FacilitySystem$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([SystemSummary$inboundSchema, types.number()]);
+/** @internal */
+export type FacilitySystem$Outbound = SystemSummary$Outbound | number;
+
+/** @internal */
+export const FacilitySystem$outboundSchema: z.ZodType<
+  FacilitySystem$Outbound,
+  z.ZodTypeDef,
+  FacilitySystem
+> = smartUnion([SystemSummary$outboundSchema, z.number().int()]);
 
+export function facilitySystemToJSON(facilitySystem: FacilitySystem): string {
+  return JSON.stringify(FacilitySystem$outboundSchema.parse(facilitySystem));
+}
 export function facilitySystemFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilitySystem, SDKValidationError> {
@@ -416,7 +675,38 @@ export const Uses$inboundSchema: z.ZodType<Uses, z.ZodTypeDef, unknown> = z
       "visitor_search": "visitorSearch",
     });
   });
+/** @internal */
+export type Uses$Outbound = {
+  calendaring: boolean;
+  credentialing: boolean;
+  rfid: boolean;
+  scrubs: boolean;
+  value_analysis: boolean;
+  visitor_management: boolean;
+  visitor_search: boolean;
+};
+
+/** @internal */
+export const Uses$outboundSchema: z.ZodType<Uses$Outbound, z.ZodTypeDef, Uses> =
+  z.object({
+    calendaring: z.boolean(),
+    credentialing: z.boolean(),
+    rfid: z.boolean(),
+    scrubs: z.boolean(),
+    valueAnalysis: z.boolean(),
+    visitorManagement: z.boolean(),
+    visitorSearch: z.boolean(),
+  }).transform((v) => {
+    return remap$(v, {
+      valueAnalysis: "value_analysis",
+      visitorManagement: "visitor_management",
+      visitorSearch: "visitor_search",
+    });
+  });
 
+export function usesToJSON(uses: Uses): string {
+  return JSON.stringify(Uses$outboundSchema.parse(uses));
+}
 export function usesFromJSON(
   jsonString: string,
 ): SafeParseResult<Uses, SDKValidationError> {
@@ -433,6 +723,12 @@ export const VendorGuestLimitAndOr$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(VendorGuestLimitAndOr);
+/** @internal */
+export const VendorGuestLimitAndOr$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  VendorGuestLimitAndOr
+> = openEnums.outboundSchema(VendorGuestLimitAndOr);
 
 /** @internal */
 export const VendorGuestPolicy$inboundSchema: z.ZodType<
@@ -453,7 +749,42 @@ export const VendorGuestPolicy$inboundSchema: z.ZodType<
     "vendor_guest_require_email": "vendorGuestRequireEmail",
   });
 });
+/** @internal */
+export type VendorGuestPolicy$Outbound = {
+  enabled: boolean;
+  vendor_guest_limit?: number | undefined;
+  vendor_guest_limit_and_or: string;
+  vendor_guest_limit_days?: number | undefined;
+  vendor_guest_require_email: boolean;
+};
+
+/** @internal */
+export const VendorGuestPolicy$outboundSchema: z.ZodType<
+  VendorGuestPolicy$Outbound,
+  z.ZodTypeDef,
+  VendorGuestPolicy
+> = z.object({
+  enabled: z.boolean(),
+  vendorGuestLimit: z.number().int().optional(),
+  vendorGuestLimitAndOr: VendorGuestLimitAndOr$outboundSchema.default("or"),
+  vendorGuestLimitDays: z.number().int().optional(),
+  vendorGuestRequireEmail: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorGuestLimit: "vendor_guest_limit",
+    vendorGuestLimitAndOr: "vendor_guest_limit_and_or",
+    vendorGuestLimitDays: "vendor_guest_limit_days",
+    vendorGuestRequireEmail: "vendor_guest_require_email",
+  });
+});
 
+export function vendorGuestPolicyToJSON(
+  vendorGuestPolicy: VendorGuestPolicy,
+): string {
+  return JSON.stringify(
+    VendorGuestPolicy$outboundSchema.parse(vendorGuestPolicy),
+  );
+}
 export function vendorGuestPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorGuestPolicy, SDKValidationError> {
@@ -488,7 +819,49 @@ export const FacilityVendorPolicy$inboundSchema: z.ZodType<
     "vendor_types": "vendorTypes",
   });
 });
+/** @internal */
+export type FacilityVendorPolicy$Outbound = {
+  allow_department_other: boolean;
+  allow_food: boolean;
+  allow_non_kiosk_checkouts: boolean;
+  auto_scan_out_violation: boolean;
+  contractor_guest_require_email: boolean;
+  visitor_checkin_require_phone: boolean;
+  vendor_types: Array<FacilityVendorType$Outbound>;
+};
+
+/** @internal */
+export const FacilityVendorPolicy$outboundSchema: z.ZodType<
+  FacilityVendorPolicy$Outbound,
+  z.ZodTypeDef,
+  FacilityVendorPolicy
+> = z.object({
+  allowDepartmentOther: z.boolean(),
+  allowFood: z.boolean(),
+  allowNonKioskCheckouts: z.boolean(),
+  autoScanOutViolation: z.boolean(),
+  contractorGuestRequireEmail: z.boolean(),
+  visitorCheckinRequirePhone: z.boolean(),
+  vendorTypes: z.array(FacilityVendorType$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    allowDepartmentOther: "allow_department_other",
+    allowFood: "allow_food",
+    allowNonKioskCheckouts: "allow_non_kiosk_checkouts",
+    autoScanOutViolation: "auto_scan_out_violation",
+    contractorGuestRequireEmail: "contractor_guest_require_email",
+    visitorCheckinRequirePhone: "visitor_checkin_require_phone",
+    vendorTypes: "vendor_types",
+  });
+});
 
+export function facilityVendorPolicyToJSON(
+  facilityVendorPolicy: FacilityVendorPolicy,
+): string {
+  return JSON.stringify(
+    FacilityVendorPolicy$outboundSchema.parse(facilityVendorPolicy),
+  );
+}
 export function facilityVendorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityVendorPolicy, SDKValidationError> {
@@ -521,7 +894,42 @@ export const VisitorPolicy$inboundSchema: z.ZodType<
     "visitor_subtypes": "visitorSubtypes",
   });
 });
+/** @internal */
+export type VisitorPolicy$Outbound = {
+  auto_checkout_visitors: boolean;
+  require_visit_request_zone: boolean;
+  show_general_visitor: boolean;
+  store_visitor_dl_number: boolean;
+  visit_request_demographics?: string | undefined;
+  visitor_subtypes?: Array<string> | undefined;
+};
+
+/** @internal */
+export const VisitorPolicy$outboundSchema: z.ZodType<
+  VisitorPolicy$Outbound,
+  z.ZodTypeDef,
+  VisitorPolicy
+> = z.object({
+  autoCheckoutVisitors: z.boolean(),
+  requireVisitRequestZone: z.boolean(),
+  showGeneralVisitor: z.boolean(),
+  storeVisitorDlNumber: z.boolean(),
+  visitRequestDemographics: z.string().optional(),
+  visitorSubtypes: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    autoCheckoutVisitors: "auto_checkout_visitors",
+    requireVisitRequestZone: "require_visit_request_zone",
+    showGeneralVisitor: "show_general_visitor",
+    storeVisitorDlNumber: "store_visitor_dl_number",
+    visitRequestDemographics: "visit_request_demographics",
+    visitorSubtypes: "visitor_subtypes",
+  });
+});
 
+export function visitorPolicyToJSON(visitorPolicy: VisitorPolicy): string {
+  return JSON.stringify(VisitorPolicy$outboundSchema.parse(visitorPolicy));
+}
 export function visitorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<VisitorPolicy, SDKValidationError> {
@@ -548,7 +956,33 @@ export const WorkflowPolicy$inboundSchema: z.ZodType<
     "auto_approve_zone_change_requests": "autoApproveZoneChangeRequests",
   });
 });
+/** @internal */
+export type WorkflowPolicy$Outbound = {
+  auto_approve_dept_change_requests: boolean;
+  auto_approve_role_change_requests: boolean;
+  auto_approve_zone_change_requests: boolean;
+};
+
+/** @internal */
+export const WorkflowPolicy$outboundSchema: z.ZodType<
+  WorkflowPolicy$Outbound,
+  z.ZodTypeDef,
+  WorkflowPolicy
+> = z.object({
+  autoApproveDeptChangeRequests: z.boolean(),
+  autoApproveRoleChangeRequests: z.boolean(),
+  autoApproveZoneChangeRequests: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    autoApproveDeptChangeRequests: "auto_approve_dept_change_requests",
+    autoApproveRoleChangeRequests: "auto_approve_role_change_requests",
+    autoApproveZoneChangeRequests: "auto_approve_zone_change_requests",
+  });
+});
 
+export function workflowPolicyToJSON(workflowPolicy: WorkflowPolicy): string {
+  return JSON.stringify(WorkflowPolicy$outboundSchema.parse(workflowPolicy));
+}
 export function workflowPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<WorkflowPolicy, SDKValidationError> {
@@ -608,7 +1042,81 @@ export const Facility$inboundSchema: z.ZodType<
     "workflow_policy": "workflowPolicy",
   });
 });
+/** @internal */
+export type Facility$Outbound = {
+  appointment_policy?: AppointmentPolicy$Outbound | null | undefined;
+  contacts?: Contacts$Outbound | null | undefined;
+  vendor_counts?: VendorCounts$Outbound | null | undefined;
+  email_domain?: string | null | undefined;
+  facility_type?: string | null | undefined;
+  flu_credential?: FluCredential$Outbound | undefined;
+  id?: number | undefined;
+  image_urls?: ImageSet$Outbound | null | undefined;
+  location?: FacilityLocation$Outbound | undefined;
+  name?: string | undefined;
+  scrubs_policy?: ScrubsPolicy$Outbound | null | undefined;
+  status?: string | undefined;
+  system?: SystemSummary$Outbound | number | undefined;
+  uses?: Uses$Outbound | undefined;
+  vendor_guest_policy?: VendorGuestPolicy$Outbound | null | undefined;
+  vendor_policy?: FacilityVendorPolicy$Outbound | null | undefined;
+  visible?: boolean | undefined;
+  visitor_policy?: VisitorPolicy$Outbound | null | undefined;
+  workflow_policy?: WorkflowPolicy$Outbound | null | undefined;
+};
+
+/** @internal */
+export const Facility$outboundSchema: z.ZodType<
+  Facility$Outbound,
+  z.ZodTypeDef,
+  Facility
+> = z.object({
+  appointmentPolicy: z.nullable(z.lazy(() => AppointmentPolicy$outboundSchema))
+    .optional(),
+  contacts: z.nullable(z.lazy(() => Contacts$outboundSchema)).optional(),
+  vendorCounts: z.nullable(z.lazy(() => VendorCounts$outboundSchema))
+    .optional(),
+  emailDomain: z.nullable(z.string()).optional(),
+  facilityType: z.nullable(z.string()).optional(),
+  fluCredential: z.lazy(() => FluCredential$outboundSchema).optional(),
+  id: z.number().int().optional(),
+  imageUrls: z.nullable(ImageSet$outboundSchema).optional(),
+  location: z.lazy(() => FacilityLocation$outboundSchema).optional(),
+  name: z.string().optional(),
+  scrubsPolicy: z.nullable(z.lazy(() => ScrubsPolicy$outboundSchema))
+    .optional(),
+  status: z.string().optional(),
+  system: smartUnion([SystemSummary$outboundSchema, z.number().int()])
+    .optional(),
+  uses: z.lazy(() => Uses$outboundSchema).optional(),
+  vendorGuestPolicy: z.nullable(z.lazy(() => VendorGuestPolicy$outboundSchema))
+    .optional(),
+  vendorPolicy: z.nullable(z.lazy(() => FacilityVendorPolicy$outboundSchema))
+    .optional(),
+  visible: z.boolean().optional(),
+  visitorPolicy: z.nullable(z.lazy(() => VisitorPolicy$outboundSchema))
+    .optional(),
+  workflowPolicy: z.nullable(z.lazy(() => WorkflowPolicy$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    appointmentPolicy: "appointment_policy",
+    vendorCounts: "vendor_counts",
+    emailDomain: "email_domain",
+    facilityType: "facility_type",
+    fluCredential: "flu_credential",
+    imageUrls: "image_urls",
+    scrubsPolicy: "scrubs_policy",
+    vendorGuestPolicy: "vendor_guest_policy",
+    vendorPolicy: "vendor_policy",
+    visitorPolicy: "visitor_policy",
+    workflowPolicy: "workflow_policy",
+  });
+});
 
+export function facilityToJSON(facility: Facility): string {
+  return JSON.stringify(Facility$outboundSchema.parse(facility));
+}
 export function facilityFromJSON(
   jsonString: string,
 ): SafeParseResult<Facility, SDKValidationError> {