@greensecurity/javascript-sdk 0.30.35 → 0.30.39

package/bin/mcp-server.js

@@ -34192,9 +34192,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.3",
-    sdkVersion: "0.30.35",
-    genVersion: "2.593.3",
-    userAgent: "speakeasy-sdk/typescript 0.30.35 2.593.3 0.0.3 @greensecurity/javascript-sdk"
+    sdkVersion: "0.30.39",
+    genVersion: "2.597.9",
+    userAgent: "speakeasy-sdk/typescript 0.30.39 2.597.9 0.0.3 @greensecurity/javascript-sdk"
   };
 });
 
@@ -34820,26 +34820,22 @@ class ClientSDK {
     }
     cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
     headers.set("cookie", cookie);
-    const userHeaders = new Headers(options?.fetchOptions?.headers);
+    const userHeaders = new Headers(options?.headers ?? options?.fetchOptions?.headers);
     for (const [k2, v2] of userHeaders) {
       headers.set(k2, v2);
     }
     if (!isBrowserLike) {
       headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
     }
-    let fetchOptions = options?.fetchOptions;
+    const fetchOptions = {
+      ...options?.fetchOptions,
+      ...options
+    };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
       const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      if (!fetchOptions) {
-        fetchOptions = { signal: timeoutSignal };
-      } else {
-        fetchOptions.signal = timeoutSignal;
-      }
+      fetchOptions.signal = timeoutSignal;
     }
     if (conf.body instanceof ReadableStream) {
-      if (!fetchOptions) {
-        fetchOptions = {};
-      }
       Object.assign(fetchOptions, { duplex: "half" });
     }
     let input;
@@ -36779,6 +36775,639 @@ var init_facility = __esm(() => {
   })(Facility$ ||= {});
 });
 
+// src/models/components/zoneconfig.ts
+var VendorGroupId1$inboundSchema, VendorGroupId1$outboundSchema, VendorGroupId1$, VendorGroupId$inboundSchema, VendorGroupId$outboundSchema, VendorGroupId$, CompanyGroupId1$inboundSchema, CompanyGroupId1$outboundSchema, CompanyGroupId1$, CompanyGroupId$inboundSchema, CompanyGroupId$outboundSchema, CompanyGroupId$, ZoneConfigAppliesTo$inboundSchema, ZoneConfigAppliesTo$outboundSchema, ZoneConfigAppliesTo$, ZoneConfigVendorPolicy$inboundSchema, ZoneConfigVendorPolicy$outboundSchema, ZoneConfigVendorPolicy$, VisitorCheckinPolicy$inboundSchema, VisitorCheckinPolicy$outboundSchema, VisitorCheckinPolicy$, VisitRequestPolicy$inboundSchema, VisitRequestPolicy$outboundSchema, VisitRequestPolicy$, ZoneConfig$inboundSchema, ZoneConfig$outboundSchema, ZoneConfig$;
+var init_zoneconfig = __esm(() => {
+  init_lib();
+  init_primitives();
+  VendorGroupId1$inboundSchema = objectType({
+    id: numberType().int().optional(),
+    name: stringType().optional(),
+    description: nullableType(stringType()).optional(),
+    visible: booleanType().optional()
+  });
+  VendorGroupId1$outboundSchema = objectType({
+    id: numberType().int().optional(),
+    name: stringType().optional(),
+    description: nullableType(stringType()).optional(),
+    visible: booleanType().optional()
+  });
+  ((VendorGroupId1$) => {
+    VendorGroupId1$.inboundSchema = VendorGroupId1$inboundSchema;
+    VendorGroupId1$.outboundSchema = VendorGroupId1$outboundSchema;
+  })(VendorGroupId1$ ||= {});
+  VendorGroupId$inboundSchema = unionType([lazyType(() => VendorGroupId1$inboundSchema), numberType().int()]);
+  VendorGroupId$outboundSchema = unionType([lazyType(() => VendorGroupId1$outboundSchema), numberType().int()]);
+  ((VendorGroupId$) => {
+    VendorGroupId$.inboundSchema = VendorGroupId$inboundSchema;
+    VendorGroupId$.outboundSchema = VendorGroupId$outboundSchema;
+  })(VendorGroupId$ ||= {});
+  CompanyGroupId1$inboundSchema = objectType({
+    id: numberType().int().optional(),
+    name: stringType().optional(),
+    description: nullableType(stringType()).optional(),
+    visible: booleanType().optional()
+  });
+  CompanyGroupId1$outboundSchema = objectType({
+    id: numberType().int().optional(),
+    name: stringType().optional(),
+    description: nullableType(stringType()).optional(),
+    visible: booleanType().optional()
+  });
+  ((CompanyGroupId1$) => {
+    CompanyGroupId1$.inboundSchema = CompanyGroupId1$inboundSchema;
+    CompanyGroupId1$.outboundSchema = CompanyGroupId1$outboundSchema;
+  })(CompanyGroupId1$ ||= {});
+  CompanyGroupId$inboundSchema = unionType([lazyType(() => CompanyGroupId1$inboundSchema), numberType().int()]);
+  CompanyGroupId$outboundSchema = unionType([lazyType(() => CompanyGroupId1$outboundSchema), numberType().int()]);
+  ((CompanyGroupId$) => {
+    CompanyGroupId$.inboundSchema = CompanyGroupId$inboundSchema;
+    CompanyGroupId$.outboundSchema = CompanyGroupId$outboundSchema;
+  })(CompanyGroupId$ ||= {});
+  ZoneConfigAppliesTo$inboundSchema = objectType({
+    vendor_group_id: nullableType(unionType([lazyType(() => VendorGroupId1$inboundSchema), numberType().int()])).optional(),
+    company_group_id: nullableType(unionType([lazyType(() => CompanyGroupId1$inboundSchema), numberType().int()])).optional(),
+    visitor_type: nullableType(stringType()).optional(),
+    visitor_subtype: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vendor_group_id: "vendorGroupId",
+      company_group_id: "companyGroupId",
+      visitor_type: "visitorType",
+      visitor_subtype: "visitorSubtype"
+    });
+  });
+  ZoneConfigAppliesTo$outboundSchema = objectType({
+    vendorGroupId: nullableType(unionType([lazyType(() => VendorGroupId1$outboundSchema), numberType().int()])).optional(),
+    companyGroupId: nullableType(unionType([lazyType(() => CompanyGroupId1$outboundSchema), numberType().int()])).optional(),
+    visitorType: nullableType(stringType()).optional(),
+    visitorSubtype: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vendorGroupId: "vendor_group_id",
+      companyGroupId: "company_group_id",
+      visitorType: "visitor_type",
+      visitorSubtype: "visitor_subtype"
+    });
+  });
+  ((ZoneConfigAppliesTo$) => {
+    ZoneConfigAppliesTo$.inboundSchema = ZoneConfigAppliesTo$inboundSchema;
+    ZoneConfigAppliesTo$.outboundSchema = ZoneConfigAppliesTo$outboundSchema;
+  })(ZoneConfigAppliesTo$ ||= {});
+  ZoneConfigVendorPolicy$inboundSchema = objectType({
+    allow_vendor_scans: booleanType().optional(),
+    print_vendor_badge: booleanType().optional(),
+    mfa: booleanType().optional(),
+    ask_questions: booleanType().optional(),
+    requires_facility_appt: booleanType().optional(),
+    requires_department_appt: booleanType().optional(),
+    requires_credentialed: booleanType().optional(),
+    allow_checkin: booleanType().optional(),
+    allow_checkout: booleanType().optional(),
+    allow_spot_check: booleanType().optional(),
+    requires_checkin: booleanType().optional(),
+    full_checkin: booleanType().optional(),
+    full_checkin_always: booleanType().optional(),
+    verify_face: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allow_vendor_scans: "allowVendorScans",
+      print_vendor_badge: "printVendorBadge",
+      ask_questions: "askQuestions",
+      requires_facility_appt: "requiresFacilityAppt",
+      requires_department_appt: "requiresDepartmentAppt",
+      requires_credentialed: "requiresCredentialed",
+      allow_checkin: "allowCheckin",
+      allow_checkout: "allowCheckout",
+      allow_spot_check: "allowSpotCheck",
+      requires_checkin: "requiresCheckin",
+      full_checkin: "fullCheckin",
+      full_checkin_always: "fullCheckinAlways",
+      verify_face: "verifyFace"
+    });
+  });
+  ZoneConfigVendorPolicy$outboundSchema = objectType({
+    allowVendorScans: booleanType().optional(),
+    printVendorBadge: booleanType().optional(),
+    mfa: booleanType().optional(),
+    askQuestions: booleanType().optional(),
+    requiresFacilityAppt: booleanType().optional(),
+    requiresDepartmentAppt: booleanType().optional(),
+    requiresCredentialed: booleanType().optional(),
+    allowCheckin: booleanType().optional(),
+    allowCheckout: booleanType().optional(),
+    allowSpotCheck: booleanType().optional(),
+    requiresCheckin: booleanType().optional(),
+    fullCheckin: booleanType().optional(),
+    fullCheckinAlways: booleanType().optional(),
+    verifyFace: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allowVendorScans: "allow_vendor_scans",
+      printVendorBadge: "print_vendor_badge",
+      askQuestions: "ask_questions",
+      requiresFacilityAppt: "requires_facility_appt",
+      requiresDepartmentAppt: "requires_department_appt",
+      requiresCredentialed: "requires_credentialed",
+      allowCheckin: "allow_checkin",
+      allowCheckout: "allow_checkout",
+      allowSpotCheck: "allow_spot_check",
+      requiresCheckin: "requires_checkin",
+      fullCheckin: "full_checkin",
+      fullCheckinAlways: "full_checkin_always",
+      verifyFace: "verify_face"
+    });
+  });
+  ((ZoneConfigVendorPolicy$) => {
+    ZoneConfigVendorPolicy$.inboundSchema = ZoneConfigVendorPolicy$inboundSchema;
+    ZoneConfigVendorPolicy$.outboundSchema = ZoneConfigVendorPolicy$outboundSchema;
+  })(ZoneConfigVendorPolicy$ ||= {});
+  VisitorCheckinPolicy$inboundSchema = objectType({
+    print_visitor_badge: booleanType().optional(),
+    ask_questions_visitor_checkins: booleanType().optional(),
+    full_checkin: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      print_visitor_badge: "printVisitorBadge",
+      ask_questions_visitor_checkins: "askQuestionsVisitorCheckins",
+      full_checkin: "fullCheckin"
+    });
+  });
+  VisitorCheckinPolicy$outboundSchema = objectType({
+    printVisitorBadge: booleanType().optional(),
+    askQuestionsVisitorCheckins: booleanType().optional(),
+    fullCheckin: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      printVisitorBadge: "print_visitor_badge",
+      askQuestionsVisitorCheckins: "ask_questions_visitor_checkins",
+      fullCheckin: "full_checkin"
+    });
+  });
+  ((VisitorCheckinPolicy$) => {
+    VisitorCheckinPolicy$.inboundSchema = VisitorCheckinPolicy$inboundSchema;
+    VisitorCheckinPolicy$.outboundSchema = VisitorCheckinPolicy$outboundSchema;
+  })(VisitorCheckinPolicy$ ||= {});
+  VisitRequestPolicy$inboundSchema = objectType({
+    ask_questions_visit_requests: nullableType(booleanType()).optional(),
+    require_website_visit_request_picture: nullableType(booleanType()).optional(),
+    require_kiosk_visit_request_picture: nullableType(booleanType()).optional(),
+    visit_request_use_previous_picture: nullableType(booleanType()).optional(),
+    auto_approve_visit_requests: nullableType(booleanType()).optional(),
+    auto_checkin_visit_requests: nullableType(booleanType()).optional(),
+    auto_approve_visit_requests_with_flags: nullableType(booleanType()).optional(),
+    auto_checkin_visit_requests_with_flags: nullableType(booleanType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      ask_questions_visit_requests: "askQuestionsVisitRequests",
+      require_website_visit_request_picture: "requireWebsiteVisitRequestPicture",
+      require_kiosk_visit_request_picture: "requireKioskVisitRequestPicture",
+      visit_request_use_previous_picture: "visitRequestUsePreviousPicture",
+      auto_approve_visit_requests: "autoApproveVisitRequests",
+      auto_checkin_visit_requests: "autoCheckinVisitRequests",
+      auto_approve_visit_requests_with_flags: "autoApproveVisitRequestsWithFlags",
+      auto_checkin_visit_requests_with_flags: "autoCheckinVisitRequestsWithFlags"
+    });
+  });
+  VisitRequestPolicy$outboundSchema = objectType({
+    askQuestionsVisitRequests: nullableType(booleanType()).optional(),
+    requireWebsiteVisitRequestPicture: nullableType(booleanType()).optional(),
+    requireKioskVisitRequestPicture: nullableType(booleanType()).optional(),
+    visitRequestUsePreviousPicture: nullableType(booleanType()).optional(),
+    autoApproveVisitRequests: nullableType(booleanType()).optional(),
+    autoCheckinVisitRequests: nullableType(booleanType()).optional(),
+    autoApproveVisitRequestsWithFlags: nullableType(booleanType()).optional(),
+    autoCheckinVisitRequestsWithFlags: nullableType(booleanType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      askQuestionsVisitRequests: "ask_questions_visit_requests",
+      requireWebsiteVisitRequestPicture: "require_website_visit_request_picture",
+      requireKioskVisitRequestPicture: "require_kiosk_visit_request_picture",
+      visitRequestUsePreviousPicture: "visit_request_use_previous_picture",
+      autoApproveVisitRequests: "auto_approve_visit_requests",
+      autoCheckinVisitRequests: "auto_checkin_visit_requests",
+      autoApproveVisitRequestsWithFlags: "auto_approve_visit_requests_with_flags",
+      autoCheckinVisitRequestsWithFlags: "auto_checkin_visit_requests_with_flags"
+    });
+  });
+  ((VisitRequestPolicy$) => {
+    VisitRequestPolicy$.inboundSchema = VisitRequestPolicy$inboundSchema;
+    VisitRequestPolicy$.outboundSchema = VisitRequestPolicy$outboundSchema;
+  })(VisitRequestPolicy$ ||= {});
+  ZoneConfig$inboundSchema = objectType({
+    id: numberType().int().optional(),
+    zone_id: numberType().int().optional(),
+    sort_order: nullableType(numberType().int()).optional(),
+    applies_to: lazyType(() => ZoneConfigAppliesTo$inboundSchema).optional(),
+    vendor_policy: lazyType(() => ZoneConfigVendorPolicy$inboundSchema).optional(),
+    visitor_checkin_policy: lazyType(() => VisitorCheckinPolicy$inboundSchema).optional(),
+    visit_request_policy: lazyType(() => VisitRequestPolicy$inboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      zone_id: "zoneId",
+      sort_order: "sortOrder",
+      applies_to: "appliesTo",
+      vendor_policy: "vendorPolicy",
+      visitor_checkin_policy: "visitorCheckinPolicy",
+      visit_request_policy: "visitRequestPolicy"
+    });
+  });
+  ZoneConfig$outboundSchema = objectType({
+    id: numberType().int().optional(),
+    zoneId: numberType().int().optional(),
+    sortOrder: nullableType(numberType().int()).optional(),
+    appliesTo: lazyType(() => ZoneConfigAppliesTo$outboundSchema).optional(),
+    vendorPolicy: lazyType(() => ZoneConfigVendorPolicy$outboundSchema).optional(),
+    visitorCheckinPolicy: lazyType(() => VisitorCheckinPolicy$outboundSchema).optional(),
+    visitRequestPolicy: lazyType(() => VisitRequestPolicy$outboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      zoneId: "zone_id",
+      sortOrder: "sort_order",
+      appliesTo: "applies_to",
+      vendorPolicy: "vendor_policy",
+      visitorCheckinPolicy: "visitor_checkin_policy",
+      visitRequestPolicy: "visit_request_policy"
+    });
+  });
+  ((ZoneConfig$) => {
+    ZoneConfig$.inboundSchema = ZoneConfig$inboundSchema;
+    ZoneConfig$.outboundSchema = ZoneConfig$outboundSchema;
+  })(ZoneConfig$ ||= {});
+});
+
+// src/models/components/zone.ts
+var ZoneFacility$inboundSchema, ZoneFacility$outboundSchema, ZoneFacility$, ZoneDepartment$inboundSchema, ZoneDepartment$outboundSchema, ZoneDepartment$, ZoneLocation$inboundSchema, ZoneLocation$outboundSchema, ZoneLocation$, KioskOfflineNotification$inboundSchema, KioskOfflineNotification$outboundSchema, KioskOfflineNotification$, ZoneVendorPolicy$inboundSchema, ZoneVendorPolicy$outboundSchema, ZoneVendorPolicy$, ZoneVisitorCheckinPolicy$inboundSchema, ZoneVisitorCheckinPolicy$outboundSchema, ZoneVisitorCheckinPolicy$, ZoneVisitRequestPolicy$inboundSchema, ZoneVisitRequestPolicy$outboundSchema, ZoneVisitRequestPolicy$, PrinterConfig$inboundSchema, PrinterConfig$outboundSchema, PrinterConfig$, GpsCheckinPolicy$inboundSchema, GpsCheckinPolicy$outboundSchema, GpsCheckinPolicy$, Zone$inboundSchema, Zone$outboundSchema, Zone$;
+var init_zone = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_department();
+  init_facility();
+  init_zoneconfig();
+  ZoneFacility$inboundSchema = unionType([Facility$inboundSchema, numberType().int()]);
+  ZoneFacility$outboundSchema = unionType([Facility$outboundSchema, numberType().int()]);
+  ((ZoneFacility$) => {
+    ZoneFacility$.inboundSchema = ZoneFacility$inboundSchema;
+    ZoneFacility$.outboundSchema = ZoneFacility$outboundSchema;
+  })(ZoneFacility$ ||= {});
+  ZoneDepartment$inboundSchema = unionType([Department$inboundSchema, numberType().int()]);
+  ZoneDepartment$outboundSchema = unionType([Department$outboundSchema, numberType().int()]);
+  ((ZoneDepartment$) => {
+    ZoneDepartment$.inboundSchema = ZoneDepartment$inboundSchema;
+    ZoneDepartment$.outboundSchema = ZoneDepartment$outboundSchema;
+  })(ZoneDepartment$ ||= {});
+  ZoneLocation$inboundSchema = objectType({
+    street_address: nullableType(stringType()).optional(),
+    city: nullableType(stringType()).optional(),
+    state: nullableType(stringType()).optional(),
+    zip: nullableType(stringType()).optional(),
+    floor_number: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      street_address: "streetAddress",
+      floor_number: "floorNumber"
+    });
+  });
+  ZoneLocation$outboundSchema = objectType({
+    streetAddress: nullableType(stringType()).optional(),
+    city: nullableType(stringType()).optional(),
+    state: nullableType(stringType()).optional(),
+    zip: nullableType(stringType()).optional(),
+    floorNumber: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      streetAddress: "street_address",
+      floorNumber: "floor_number"
+    });
+  });
+  ((ZoneLocation$) => {
+    ZoneLocation$.inboundSchema = ZoneLocation$inboundSchema;
+    ZoneLocation$.outboundSchema = ZoneLocation$outboundSchema;
+  })(ZoneLocation$ ||= {});
+  KioskOfflineNotification$inboundSchema = objectType({
+    is_offline: nullableType(booleanType()).optional(),
+    message: nullableType(stringType()).optional(),
+    auto_activate: nullableType(stringType()).optional(),
+    auto_deactivate: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      is_offline: "isOffline",
+      auto_activate: "autoActivate",
+      auto_deactivate: "autoDeactivate"
+    });
+  });
+  KioskOfflineNotification$outboundSchema = objectType({
+    isOffline: nullableType(booleanType()).optional(),
+    message: nullableType(stringType()).optional(),
+    autoActivate: nullableType(stringType()).optional(),
+    autoDeactivate: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      isOffline: "is_offline",
+      autoActivate: "auto_activate",
+      autoDeactivate: "auto_deactivate"
+    });
+  });
+  ((KioskOfflineNotification$) => {
+    KioskOfflineNotification$.inboundSchema = KioskOfflineNotification$inboundSchema;
+    KioskOfflineNotification$.outboundSchema = KioskOfflineNotification$outboundSchema;
+  })(KioskOfflineNotification$ ||= {});
+  ZoneVendorPolicy$inboundSchema = objectType({
+    allow_gps_checkin: booleanType().optional(),
+    allow_scrubs: booleanType().optional(),
+    allow_vendor_scans: booleanType().optional(),
+    requires_checkin_for_scrubs: booleanType().optional(),
+    override_limit: nullableType(numberType().int()).optional(),
+    override_limit_days: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allow_gps_checkin: "allowGpsCheckin",
+      allow_scrubs: "allowScrubs",
+      allow_vendor_scans: "allowVendorScans",
+      requires_checkin_for_scrubs: "requiresCheckinForScrubs",
+      override_limit: "overrideLimit",
+      override_limit_days: "overrideLimitDays"
+    });
+  });
+  ZoneVendorPolicy$outboundSchema = objectType({
+    allowGpsCheckin: booleanType().optional(),
+    allowScrubs: booleanType().optional(),
+    allowVendorScans: booleanType().optional(),
+    requiresCheckinForScrubs: booleanType().optional(),
+    overrideLimit: nullableType(numberType().int()).optional(),
+    overrideLimitDays: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allowGpsCheckin: "allow_gps_checkin",
+      allowScrubs: "allow_scrubs",
+      allowVendorScans: "allow_vendor_scans",
+      requiresCheckinForScrubs: "requires_checkin_for_scrubs",
+      overrideLimit: "override_limit",
+      overrideLimitDays: "override_limit_days"
+    });
+  });
+  ((ZoneVendorPolicy$) => {
+    ZoneVendorPolicy$.inboundSchema = ZoneVendorPolicy$inboundSchema;
+    ZoneVendorPolicy$.outboundSchema = ZoneVendorPolicy$outboundSchema;
+  })(ZoneVendorPolicy$ ||= {});
+  ZoneVisitorCheckinPolicy$inboundSchema = objectType({
+    allow_checkin: booleanType().optional(),
+    allow_visiting: booleanType().optional(),
+    allow_visiting_rooms: booleanType().optional(),
+    auto_checkout: booleanType().optional(),
+    max_visitor_count: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allow_checkin: "allowCheckin",
+      allow_visiting: "allowVisiting",
+      allow_visiting_rooms: "allowVisitingRooms",
+      auto_checkout: "autoCheckout",
+      max_visitor_count: "maxVisitorCount"
+    });
+  });
+  ZoneVisitorCheckinPolicy$outboundSchema = objectType({
+    allowCheckin: booleanType().optional(),
+    allowVisiting: booleanType().optional(),
+    allowVisitingRooms: booleanType().optional(),
+    autoCheckout: booleanType().optional(),
+    maxVisitorCount: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allowCheckin: "allow_checkin",
+      allowVisiting: "allow_visiting",
+      allowVisitingRooms: "allow_visiting_rooms",
+      autoCheckout: "auto_checkout",
+      maxVisitorCount: "max_visitor_count"
+    });
+  });
+  ((ZoneVisitorCheckinPolicy$) => {
+    ZoneVisitorCheckinPolicy$.inboundSchema = ZoneVisitorCheckinPolicy$inboundSchema;
+    ZoneVisitorCheckinPolicy$.outboundSchema = ZoneVisitorCheckinPolicy$outboundSchema;
+  })(ZoneVisitorCheckinPolicy$ ||= {});
+  ZoneVisitRequestPolicy$inboundSchema = objectType({
+    allow_visiting: booleanType().optional(),
+    watchlist_hit_message: nullableType(stringType()).optional(),
+    watchdog_hit_message: nullableType(stringType()).optional(),
+    guest_limit_exceeded_message: nullableType(stringType()).optional(),
+    denied_background_vendor_message: nullableType(stringType()).optional(),
+    locked_vendor_message: nullableType(stringType()).optional(),
+    stop_checkin_message: nullableType(stringType()).optional(),
+    success_message: nullableType(stringType()).optional(),
+    show_general_visitor: booleanType().optional(),
+    restrict_to_scan_only: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allow_visiting: "allowVisiting",
+      watchlist_hit_message: "watchlistHitMessage",
+      watchdog_hit_message: "watchdogHitMessage",
+      guest_limit_exceeded_message: "guestLimitExceededMessage",
+      denied_background_vendor_message: "deniedBackgroundVendorMessage",
+      locked_vendor_message: "lockedVendorMessage",
+      stop_checkin_message: "stopCheckinMessage",
+      success_message: "successMessage",
+      show_general_visitor: "showGeneralVisitor",
+      restrict_to_scan_only: "restrictToScanOnly"
+    });
+  });
+  ZoneVisitRequestPolicy$outboundSchema = objectType({
+    allowVisiting: booleanType().optional(),
+    watchlistHitMessage: nullableType(stringType()).optional(),
+    watchdogHitMessage: nullableType(stringType()).optional(),
+    guestLimitExceededMessage: nullableType(stringType()).optional(),
+    deniedBackgroundVendorMessage: nullableType(stringType()).optional(),
+    lockedVendorMessage: nullableType(stringType()).optional(),
+    stopCheckinMessage: nullableType(stringType()).optional(),
+    successMessage: nullableType(stringType()).optional(),
+    showGeneralVisitor: booleanType().optional(),
+    restrictToScanOnly: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      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"
+    });
+  });
+  ((ZoneVisitRequestPolicy$) => {
+    ZoneVisitRequestPolicy$.inboundSchema = ZoneVisitRequestPolicy$inboundSchema;
+    ZoneVisitRequestPolicy$.outboundSchema = ZoneVisitRequestPolicy$outboundSchema;
+  })(ZoneVisitRequestPolicy$ ||= {});
+  PrinterConfig$inboundSchema = objectType({
+    type: nullableType(stringType()).optional(),
+    name: nullableType(stringType()).optional(),
+    dpi: nullableType(stringType()).optional(),
+    ip: nullableType(stringType()).optional(),
+    port: nullableType(stringType()).optional(),
+    email: nullableType(stringType()).optional(),
+    flip: booleanType().optional(),
+    orientation: nullableType(stringType()).optional(),
+    dymo_brightness_adjust: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      dymo_brightness_adjust: "dymoBrightnessAdjust"
+    });
+  });
+  PrinterConfig$outboundSchema = objectType({
+    type: nullableType(stringType()).optional(),
+    name: nullableType(stringType()).optional(),
+    dpi: nullableType(stringType()).optional(),
+    ip: nullableType(stringType()).optional(),
+    port: nullableType(stringType()).optional(),
+    email: nullableType(stringType()).optional(),
+    flip: booleanType().optional(),
+    orientation: nullableType(stringType()).optional(),
+    dymoBrightnessAdjust: nullableType(numberType().int()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      dymoBrightnessAdjust: "dymo_brightness_adjust"
+    });
+  });
+  ((PrinterConfig$) => {
+    PrinterConfig$.inboundSchema = PrinterConfig$inboundSchema;
+    PrinterConfig$.outboundSchema = PrinterConfig$outboundSchema;
+  })(PrinterConfig$ ||= {});
+  GpsCheckinPolicy$inboundSchema = objectType({
+    latitude: nullableType(stringType()).optional(),
+    longitude: nullableType(stringType()).optional(),
+    gps_checkin_radius: nullableType(numberType().int()).optional(),
+    geocode_error: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      gps_checkin_radius: "gpsCheckinRadius",
+      geocode_error: "geocodeError"
+    });
+  });
+  GpsCheckinPolicy$outboundSchema = objectType({
+    latitude: nullableType(stringType()).optional(),
+    longitude: nullableType(stringType()).optional(),
+    gpsCheckinRadius: nullableType(numberType().int()).optional(),
+    geocodeError: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      gpsCheckinRadius: "gps_checkin_radius",
+      geocodeError: "geocode_error"
+    });
+  });
+  ((GpsCheckinPolicy$) => {
+    GpsCheckinPolicy$.inboundSchema = GpsCheckinPolicy$inboundSchema;
+    GpsCheckinPolicy$.outboundSchema = GpsCheckinPolicy$outboundSchema;
+  })(GpsCheckinPolicy$ ||= {});
+  Zone$inboundSchema = objectType({
+    id: numberType().int().optional(),
+    facility: nullableType(unionType([Facility$inboundSchema, numberType().int()])).optional(),
+    department: nullableType(unionType([Department$inboundSchema, numberType().int()])).optional(),
+    name: nullableType(stringType()).optional(),
+    short_name: nullableType(stringType()).optional(),
+    description: nullableType(stringType()).optional(),
+    status: nullableType(stringType()).optional(),
+    notes: nullableType(stringType()).optional(),
+    rules: nullableType(arrayType(nullableType(ZoneConfig$inboundSchema))).optional(),
+    location: lazyType(() => ZoneLocation$inboundSchema).optional(),
+    kiosk_offline_notification: lazyType(() => KioskOfflineNotification$inboundSchema).optional(),
+    vendor_policy: lazyType(() => ZoneVendorPolicy$inboundSchema).optional(),
+    visitor_checkin_policy: lazyType(() => ZoneVisitorCheckinPolicy$inboundSchema).optional(),
+    visit_request_policy: lazyType(() => ZoneVisitRequestPolicy$inboundSchema).optional(),
+    printer_config: lazyType(() => PrinterConfig$inboundSchema).optional(),
+    gps_checkin_policy: lazyType(() => GpsCheckinPolicy$inboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      short_name: "shortName",
+      kiosk_offline_notification: "kioskOfflineNotification",
+      vendor_policy: "vendorPolicy",
+      visitor_checkin_policy: "visitorCheckinPolicy",
+      visit_request_policy: "visitRequestPolicy",
+      printer_config: "printerConfig",
+      gps_checkin_policy: "gpsCheckinPolicy"
+    });
+  });
+  Zone$outboundSchema = objectType({
+    id: numberType().int().optional(),
+    facility: nullableType(unionType([Facility$outboundSchema, numberType().int()])).optional(),
+    department: nullableType(unionType([Department$outboundSchema, numberType().int()])).optional(),
+    name: nullableType(stringType()).optional(),
+    shortName: nullableType(stringType()).optional(),
+    description: nullableType(stringType()).optional(),
+    status: nullableType(stringType()).optional(),
+    notes: nullableType(stringType()).optional(),
+    rules: nullableType(arrayType(nullableType(ZoneConfig$outboundSchema))).optional(),
+    location: lazyType(() => ZoneLocation$outboundSchema).optional(),
+    kioskOfflineNotification: lazyType(() => KioskOfflineNotification$outboundSchema).optional(),
+    vendorPolicy: lazyType(() => ZoneVendorPolicy$outboundSchema).optional(),
+    visitorCheckinPolicy: lazyType(() => ZoneVisitorCheckinPolicy$outboundSchema).optional(),
+    visitRequestPolicy: lazyType(() => ZoneVisitRequestPolicy$outboundSchema).optional(),
+    printerConfig: lazyType(() => PrinterConfig$outboundSchema).optional(),
+    gpsCheckinPolicy: lazyType(() => GpsCheckinPolicy$outboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      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"
+    });
+  });
+  ((Zone$) => {
+    Zone$.inboundSchema = Zone$inboundSchema;
+    Zone$.outboundSchema = Zone$outboundSchema;
+  })(Zone$ ||= {});
+});
+
+// src/models/components/handoff.ts
+var Handoff$inboundSchema, Handoff$outboundSchema, Handoff$;
+var init_handoff = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_zone();
+  Handoff$inboundSchema = objectType({
+    id: numberType().int().optional(),
+    zone: Zone$inboundSchema.optional(),
+    qr_code: nullableType(stringType()).optional(),
+    date_created: nullableType(stringType()).optional(),
+    date_received: nullableType(stringType()).optional(),
+    date_completed: nullableType(stringType()).optional(),
+    status: nullableType(stringType()).optional(),
+    gps_checkin: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      qr_code: "qrCode",
+      date_created: "dateCreated",
+      date_received: "dateReceived",
+      date_completed: "dateCompleted",
+      gps_checkin: "gpsCheckin"
+    });
+  });
+  Handoff$outboundSchema = objectType({
+    id: numberType().int().optional(),
+    zone: Zone$outboundSchema.optional(),
+    qrCode: nullableType(stringType()).optional(),
+    dateCreated: nullableType(stringType()).optional(),
+    dateReceived: nullableType(stringType()).optional(),
+    dateCompleted: nullableType(stringType()).optional(),
+    status: nullableType(stringType()).optional(),
+    gpsCheckin: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      qrCode: "qr_code",
+      dateCreated: "date_created",
+      dateReceived: "date_received",
+      dateCompleted: "date_completed",
+      gpsCheckin: "gps_checkin"
+    });
+  });
+  ((Handoff$) => {
+    Handoff$.inboundSchema = Handoff$inboundSchema;
+    Handoff$.outboundSchema = Handoff$outboundSchema;
+  })(Handoff$ ||= {});
+});
+
 // src/models/components/invoiceitem.ts
 var InvoiceItem$inboundSchema, InvoiceItem$outboundSchema, InvoiceItem$;
 var init_invoiceitem = __esm(() => {
@@ -38474,6 +39103,7 @@ var init_components = __esm(() => {
   init_expand();
   init_facility();
   init_facilitysummary();
+  init_handoff();
   init_imageset();
   init_invoice();
   init_invoiceitem();
@@ -38506,6 +39136,8 @@ var init_components = __esm(() => {
   init_vendorscrubpurchase();
   init_vendortype();
   init_webhookendpoint();
+  init_zone();
+  init_zoneconfig();
 });
 
 // src/models/operations/createvendorcompany.ts
@@ -39031,6 +39663,88 @@ var init_listorsearchfacilities = __esm(() => {
   })(ListOrSearchFacilitiesResponse$ ||= {});
 });
 
+// src/models/operations/listorsearchsecurityzones.ts
+var ListOrSearchSecurityZonesRequest$inboundSchema, ListOrSearchSecurityZonesRequest$outboundSchema, ListOrSearchSecurityZonesRequest$, ListOrSearchSecurityZonesResponseBody$inboundSchema, ListOrSearchSecurityZonesResponseBody$outboundSchema, ListOrSearchSecurityZonesResponseBody$, ListOrSearchSecurityZonesResponse$inboundSchema, ListOrSearchSecurityZonesResponse$outboundSchema, ListOrSearchSecurityZonesResponse$;
+var init_listorsearchsecurityzones = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  ListOrSearchSecurityZonesRequest$inboundSchema = objectType({
+    sort: nullableType(stringType()).optional(),
+    desc: Desc$inboundSchema.optional(),
+    page: numberType().int().optional(),
+    items_per_page: numberType().int().optional(),
+    latitude: numberType().optional(),
+    longitude: numberType().optional(),
+    name_like: stringType().optional(),
+    contact_id: numberType().optional(),
+    facility_id: numberType().optional(),
+    green_location_id: numberType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      items_per_page: "itemsPerPage",
+      name_like: "nameLike",
+      contact_id: "contactId",
+      facility_id: "facilityId",
+      green_location_id: "greenLocationId"
+    });
+  });
+  ListOrSearchSecurityZonesRequest$outboundSchema = objectType({
+    sort: nullableType(stringType()).optional(),
+    desc: Desc$outboundSchema.optional(),
+    page: numberType().int().optional(),
+    itemsPerPage: numberType().int().optional(),
+    latitude: numberType().optional(),
+    longitude: numberType().optional(),
+    nameLike: stringType().optional(),
+    contactId: numberType().optional(),
+    facilityId: numberType().optional(),
+    greenLocationId: numberType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      itemsPerPage: "items_per_page",
+      nameLike: "name_like",
+      contactId: "contact_id",
+      facilityId: "facility_id",
+      greenLocationId: "green_location_id"
+    });
+  });
+  ((ListOrSearchSecurityZonesRequest$) => {
+    ListOrSearchSecurityZonesRequest$.inboundSchema = ListOrSearchSecurityZonesRequest$inboundSchema;
+    ListOrSearchSecurityZonesRequest$.outboundSchema = ListOrSearchSecurityZonesRequest$outboundSchema;
+  })(ListOrSearchSecurityZonesRequest$ ||= {});
+  ListOrSearchSecurityZonesResponseBody$inboundSchema = objectType({
+    pager: Pager$inboundSchema,
+    items: arrayType(Zone$inboundSchema)
+  });
+  ListOrSearchSecurityZonesResponseBody$outboundSchema = objectType({
+    pager: Pager$outboundSchema,
+    items: arrayType(Zone$outboundSchema)
+  });
+  ((ListOrSearchSecurityZonesResponseBody$) => {
+    ListOrSearchSecurityZonesResponseBody$.inboundSchema = ListOrSearchSecurityZonesResponseBody$inboundSchema;
+    ListOrSearchSecurityZonesResponseBody$.outboundSchema = ListOrSearchSecurityZonesResponseBody$outboundSchema;
+  })(ListOrSearchSecurityZonesResponseBody$ ||= {});
+  ListOrSearchSecurityZonesResponse$inboundSchema = objectType({
+    Result: lazyType(() => ListOrSearchSecurityZonesResponseBody$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Result: "result"
+    });
+  });
+  ListOrSearchSecurityZonesResponse$outboundSchema = objectType({
+    result: lazyType(() => ListOrSearchSecurityZonesResponseBody$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      result: "Result"
+    });
+  });
+  ((ListOrSearchSecurityZonesResponse$) => {
+    ListOrSearchSecurityZonesResponse$.inboundSchema = ListOrSearchSecurityZonesResponse$inboundSchema;
+    ListOrSearchSecurityZonesResponse$.outboundSchema = ListOrSearchSecurityZonesResponse$outboundSchema;
+  })(ListOrSearchSecurityZonesResponse$ ||= {});
+});
+
 // src/models/operations/listorsearchsupportarticles.ts
 var ListOrSearchSupportArticlesRequest$inboundSchema, ListOrSearchSupportArticlesRequest$outboundSchema, ListOrSearchSupportArticlesRequest$, ListOrSearchSupportArticlesListOrSearchArticlesOk$inboundSchema, ListOrSearchSupportArticlesListOrSearchArticlesOk$outboundSchema, ListOrSearchSupportArticlesListOrSearchArticlesOk$, ListOrSearchSupportArticlesResponse$inboundSchema, ListOrSearchSupportArticlesResponse$outboundSchema, ListOrSearchSupportArticlesResponse$;
 var init_listorsearchsupportarticles = __esm(() => {
@@ -40057,6 +40771,62 @@ var init_purchasescrubcredits = __esm(() => {
   })(PurchaseScrubCreditsResponseBody$ ||= {});
 });
 
+// src/models/operations/securityzonecheckin.ts
+var Two$inboundSchema, Two$outboundSchema, Two$, One$inboundSchema2, One$outboundSchema2, One$2, SecurityZoneCheckinRequestBody$inboundSchema, SecurityZoneCheckinRequestBody$outboundSchema, SecurityZoneCheckinRequestBody$;
+var init_securityzonecheckin = __esm(() => {
+  init_lib();
+  init_primitives();
+  Two$inboundSchema = objectType({
+    qr_code: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      qr_code: "qrCode"
+    });
+  });
+  Two$outboundSchema = objectType({
+    qrCode: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      qrCode: "qr_code"
+    });
+  });
+  ((Two$) => {
+    Two$.inboundSchema = Two$inboundSchema;
+    Two$.outboundSchema = Two$outboundSchema;
+  })(Two$ ||= {});
+  One$inboundSchema2 = objectType({
+    zone_id: numberType().int(),
+    longitude: anyType().optional(),
+    latitude: anyType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      zone_id: "zoneId"
+    });
+  });
+  One$outboundSchema2 = objectType({
+    zoneId: numberType().int(),
+    longitude: anyType().optional(),
+    latitude: anyType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      zoneId: "zone_id"
+    });
+  });
+  ((One$) => {
+    One$.inboundSchema = One$inboundSchema2;
+    One$.outboundSchema = One$outboundSchema2;
+  })(One$2 ||= {});
+  SecurityZoneCheckinRequestBody$inboundSchema = unionType([lazyType(() => Two$inboundSchema), lazyType(() => One$inboundSchema2)]);
+  SecurityZoneCheckinRequestBody$outboundSchema = unionType([
+    lazyType(() => Two$outboundSchema),
+    lazyType(() => One$outboundSchema2)
+  ]);
+  ((SecurityZoneCheckinRequestBody$) => {
+    SecurityZoneCheckinRequestBody$.inboundSchema = SecurityZoneCheckinRequestBody$inboundSchema;
+    SecurityZoneCheckinRequestBody$.outboundSchema = SecurityZoneCheckinRequestBody$outboundSchema;
+  })(SecurityZoneCheckinRequestBody$ ||= {});
+});
+
 // src/models/operations/updatevendordetails.ts
 var EmailRecepient, EmailRecepient$inboundSchema, EmailRecepient$outboundSchema, EmailRecepient$, UpdateVendorDetailsRequestBody$inboundSchema, UpdateVendorDetailsRequestBody$outboundSchema, UpdateVendorDetailsRequestBody$, UpdateVendorDetailsRequest$inboundSchema, UpdateVendorDetailsRequest$outboundSchema, UpdateVendorDetailsRequest$;
 var init_updatevendordetails = __esm(() => {
@@ -40353,6 +41123,7 @@ var init_operations = __esm(() => {
   init_listallwebhookendpoints();
   init_listorsearchcompanies();
   init_listorsearchfacilities();
+  init_listorsearchsecurityzones();
   init_listorsearchsupportarticles();
   init_listvendoradditionalfacilityfields();
   init_listvendorcredentials();
@@ -40369,6 +41140,7 @@ var init_operations = __esm(() => {
   init_password();
   init_passwordresetrequest();
   init_purchasescrubcredits();
+  init_securityzonecheckin();
   init_updatevendordetails();
   init_updatevendormanagedbycompany();
   init_updatevendorscrubdetails();
@@ -44584,11 +45356,256 @@ Returns a list of your webhook endpoints.`,
   };
 });
 
+// src/funcs/zonesListOrSearchSecurityZones.ts
+function zonesListOrSearchSecurityZones(client, request, options) {
+  return new APIPromise($do36(client, request, options));
+}
+async function $do36(client, request, options) {
+  const parsed = safeParse(request, (value) => ListOrSearchSecurityZonesRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [haltIterator(parsed), { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/security_zones")();
+  const query = encodeFormQuery({
+    contact_id: payload.contact_id,
+    desc: payload.desc,
+    facility_id: payload.facility_id,
+    green_location_id: payload.green_location_id,
+    items_per_page: payload.items_per_page,
+    latitude: payload.latitude,
+    longitude: payload.longitude,
+    name_like: payload.name_like,
+    page: payload.page,
+    sort: payload.sort
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listOrSearchSecurityZones",
+    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: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [haltIterator(requestRes), { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "401", "403", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [haltIterator(doResult), { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result, raw] = await match(json(200, ListOrSearchSecurityZonesResponse$inboundSchema, {
+    key: "Result"
+  }), jsonErr([400, 401, 403], ApiErrorResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response
+    }];
+  }
+  const nextFunc = (responseData) => {
+    const page2 = request?.page ?? 1;
+    const nextPage = page2 + 1;
+    if (!responseData) {
+      return { next: () => null };
+    }
+    const results = dlv(responseData, "items");
+    if (!Array.isArray(results) || !results.length) {
+      return { next: () => null };
+    }
+    const limit = request?.itemsPerPage ?? 0;
+    if (results.length < limit) {
+      return { next: () => null };
+    }
+    const nextVal = () => zonesListOrSearchSecurityZones(client, {
+      ...request,
+      page: nextPage
+    }, options);
+    return { next: nextVal, "~next": { page: nextPage } };
+  };
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
+    status: "complete",
+    request: req,
+    response
+  }];
+}
+var init_zonesListOrSearchSecurityZones = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors();
+  init_operations();
+  init_async();
+  init_operations2();
+});
+
+// src/mcp-server/tools/zonesListOrSearchSecurityZones.ts
+var args35, tool$zonesListOrSearchSecurityZones;
+var init_zonesListOrSearchSecurityZones2 = __esm(() => {
+  init_zonesListOrSearchSecurityZones();
+  init_operations();
+  init_tools();
+  args35 = {
+    request: ListOrSearchSecurityZonesRequest$inboundSchema
+  };
+  tool$zonesListOrSearchSecurityZones = {
+    name: "zones-list-or-search-security-zones",
+    description: `List or search security zones
+
+List or search security zones`,
+    args: args35,
+    tool: async (client, args36, ctx) => {
+      const [result, apiCall] = await zonesListOrSearchSecurityZones(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/zonesSecurityZoneCheckin.ts
+function zonesSecurityZoneCheckin(client, request, options) {
+  return new APIPromise($do37(client, request, options));
+}
+async function $do37(client, request, options) {
+  const parsed = safeParse(request, (value) => SecurityZoneCheckinRequestBody$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/security_zones/checkin_request")();
+  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 = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "securityZoneCheckin",
+    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,
+    headers,
+    body,
+    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, {
+    context,
+    errorCodes: ["400", "401", "403", "404", "4XX", "500", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: 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 match(json(200, Handoff$inboundSchema), jsonErr([400, 401, 403, 404], ApiErrorResponse$inboundSchema), jsonErr(500, ApiErrorResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_zonesSecurityZoneCheckin = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/zonesSecurityZoneCheckin.ts
+var args36, tool$zonesSecurityZoneCheckin;
+var init_zonesSecurityZoneCheckin2 = __esm(() => {
+  init_zonesSecurityZoneCheckin();
+  init_operations();
+  init_tools();
+  args36 = {
+    request: SecurityZoneCheckinRequestBody$inboundSchema
+  };
+  tool$zonesSecurityZoneCheckin = {
+    name: "zones-security-zone-checkin",
+    description: `Security zone checkin request
+
+It will create a handoff record in the db for security zone check in request`,
+    args: args36,
+    tool: async (client, args37, ctx) => {
+      const [result, apiCall] = await zonesSecurityZoneCheckin(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
 // src/mcp-server/server.ts
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "GreenSecurity",
-    version: "0.30.35"
+    version: "0.30.39"
   });
   const client = new GreenSecurityCore({
     security: deps.security,
@@ -44637,6 +45654,8 @@ function createMCPServer(deps) {
   tool(tool$webhooksGetWebhookEndpoint);
   tool(tool$vendorScansVendorScanOut);
   tool(tool$companiesListOrSearchCompanies);
+  tool(tool$zonesListOrSearchSecurityZones);
+  tool(tool$zonesSecurityZoneCheckin);
   return server;
 }
 var init_server2 = __esm(() => {
@@ -44679,6 +45698,8 @@ var init_server2 = __esm(() => {
   init_vendorsUpdateVendorScrubDetails2();
   init_webhooksGetWebhookEndpoint2();
   init_webhooksListAllWebhookEndpoints2();
+  init_zonesListOrSearchSecurityZones2();
+  init_zonesSecurityZoneCheckin2();
 });
 
 // src/mcp-server/cli/start/impl.ts
@@ -45877,7 +46898,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.30.35"
+    currentVersion: "0.30.39"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -45885,5 +46906,5 @@ export {
   app
 };
 
-//# debugId=7EAA6346987B997D64756E2164756E21
+//# debugId=9B787DB528C4EE0764756E2164756E21
 //# sourceMappingURL=mcp-server.js.map