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

package/src/models/components/zoneconfig.ts

@@ -96,7 +96,29 @@ export const VendorGroupId1$inboundSchema: z.ZodType<
   description: z.nullable(types.string()).optional(),
   visible: types.optional(types.boolean()),
 });
+/** @internal */
+export type VendorGroupId1$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  visible?: boolean | undefined;
+};
 
+/** @internal */
+export const VendorGroupId1$outboundSchema: z.ZodType<
+  VendorGroupId1$Outbound,
+  z.ZodTypeDef,
+  VendorGroupId1
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  visible: z.boolean().optional(),
+});
+
+export function vendorGroupId1ToJSON(vendorGroupId1: VendorGroupId1): string {
+  return JSON.stringify(VendorGroupId1$outboundSchema.parse(vendorGroupId1));
+}
 export function vendorGroupId1FromJSON(
   jsonString: string,
 ): SafeParseResult<VendorGroupId1, SDKValidationError> {
@@ -113,7 +135,19 @@ export const VendorGroupId$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([z.lazy(() => VendorGroupId1$inboundSchema), types.number()]);
+/** @internal */
+export type VendorGroupId$Outbound = VendorGroupId1$Outbound | number;
 
+/** @internal */
+export const VendorGroupId$outboundSchema: z.ZodType<
+  VendorGroupId$Outbound,
+  z.ZodTypeDef,
+  VendorGroupId
+> = smartUnion([z.lazy(() => VendorGroupId1$outboundSchema), z.number().int()]);
+
+export function vendorGroupIdToJSON(vendorGroupId: VendorGroupId): string {
+  return JSON.stringify(VendorGroupId$outboundSchema.parse(vendorGroupId));
+}
 export function vendorGroupIdFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorGroupId, SDKValidationError> {
@@ -135,7 +169,31 @@ export const CompanyGroupId1$inboundSchema: z.ZodType<
   description: z.nullable(types.string()).optional(),
   visible: types.optional(types.boolean()),
 });
+/** @internal */
+export type CompanyGroupId1$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  visible?: boolean | undefined;
+};
+
+/** @internal */
+export const CompanyGroupId1$outboundSchema: z.ZodType<
+  CompanyGroupId1$Outbound,
+  z.ZodTypeDef,
+  CompanyGroupId1
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  visible: z.boolean().optional(),
+});
 
+export function companyGroupId1ToJSON(
+  companyGroupId1: CompanyGroupId1,
+): string {
+  return JSON.stringify(CompanyGroupId1$outboundSchema.parse(companyGroupId1));
+}
 export function companyGroupId1FromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyGroupId1, SDKValidationError> {
@@ -152,7 +210,22 @@ export const CompanyGroupId$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([z.lazy(() => CompanyGroupId1$inboundSchema), types.number()]);
+/** @internal */
+export type CompanyGroupId$Outbound = CompanyGroupId1$Outbound | number;
 
+/** @internal */
+export const CompanyGroupId$outboundSchema: z.ZodType<
+  CompanyGroupId$Outbound,
+  z.ZodTypeDef,
+  CompanyGroupId
+> = smartUnion([
+  z.lazy(() => CompanyGroupId1$outboundSchema),
+  z.number().int(),
+]);
+
+export function companyGroupIdToJSON(companyGroupId: CompanyGroupId): string {
+  return JSON.stringify(CompanyGroupId$outboundSchema.parse(companyGroupId));
+}
 export function companyGroupIdFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyGroupId, SDKValidationError> {
@@ -185,7 +258,47 @@ export const ZoneConfigAppliesTo$inboundSchema: z.ZodType<
     "visitor_subtype": "visitorSubtype",
   });
 });
+/** @internal */
+export type ZoneConfigAppliesTo$Outbound = {
+  vendor_group_id?: VendorGroupId1$Outbound | number | null | undefined;
+  company_group_id?: CompanyGroupId1$Outbound | number | null | undefined;
+  visitor_type?: string | null | undefined;
+  visitor_subtype?: string | null | undefined;
+};
 
+/** @internal */
+export const ZoneConfigAppliesTo$outboundSchema: z.ZodType<
+  ZoneConfigAppliesTo$Outbound,
+  z.ZodTypeDef,
+  ZoneConfigAppliesTo
+> = z.object({
+  vendorGroupId: z.nullable(
+    smartUnion([z.lazy(() => VendorGroupId1$outboundSchema), z.number().int()]),
+  ).optional(),
+  companyGroupId: z.nullable(
+    smartUnion([
+      z.lazy(() => CompanyGroupId1$outboundSchema),
+      z.number().int(),
+    ]),
+  ).optional(),
+  visitorType: z.nullable(z.string()).optional(),
+  visitorSubtype: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorGroupId: "vendor_group_id",
+    companyGroupId: "company_group_id",
+    visitorType: "visitor_type",
+    visitorSubtype: "visitor_subtype",
+  });
+});
+
+export function zoneConfigAppliesToToJSON(
+  zoneConfigAppliesTo: ZoneConfigAppliesTo,
+): string {
+  return JSON.stringify(
+    ZoneConfigAppliesTo$outboundSchema.parse(zoneConfigAppliesTo),
+  );
+}
 export function zoneConfigAppliesToFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneConfigAppliesTo, SDKValidationError> {
@@ -233,7 +346,69 @@ export const ZoneConfigVendorPolicy$inboundSchema: z.ZodType<
     "verify_face": "verifyFace",
   });
 });
+/** @internal */
+export type ZoneConfigVendorPolicy$Outbound = {
+  allow_vendor_scans?: boolean | undefined;
+  print_vendor_badge?: boolean | undefined;
+  mfa?: boolean | undefined;
+  ask_questions?: boolean | undefined;
+  requires_facility_appt?: boolean | undefined;
+  requires_department_appt?: boolean | undefined;
+  requires_credentialed?: boolean | undefined;
+  allow_checkin?: boolean | undefined;
+  allow_checkout?: boolean | undefined;
+  allow_spot_check?: boolean | undefined;
+  requires_checkin?: boolean | undefined;
+  full_checkin?: boolean | undefined;
+  full_checkin_always?: boolean | undefined;
+  verify_face?: boolean | undefined;
+};
 
+/** @internal */
+export const ZoneConfigVendorPolicy$outboundSchema: z.ZodType<
+  ZoneConfigVendorPolicy$Outbound,
+  z.ZodTypeDef,
+  ZoneConfigVendorPolicy
+> = z.object({
+  allowVendorScans: z.boolean().optional(),
+  printVendorBadge: z.boolean().optional(),
+  mfa: z.boolean().optional(),
+  askQuestions: z.boolean().optional(),
+  requiresFacilityAppt: z.boolean().optional(),
+  requiresDepartmentAppt: z.boolean().optional(),
+  requiresCredentialed: z.boolean().optional(),
+  allowCheckin: z.boolean().optional(),
+  allowCheckout: z.boolean().optional(),
+  allowSpotCheck: z.boolean().optional(),
+  requiresCheckin: z.boolean().optional(),
+  fullCheckin: z.boolean().optional(),
+  fullCheckinAlways: z.boolean().optional(),
+  verifyFace: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    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",
+  });
+});
+
+export function zoneConfigVendorPolicyToJSON(
+  zoneConfigVendorPolicy: ZoneConfigVendorPolicy,
+): string {
+  return JSON.stringify(
+    ZoneConfigVendorPolicy$outboundSchema.parse(zoneConfigVendorPolicy),
+  );
+}
 export function zoneConfigVendorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneConfigVendorPolicy, SDKValidationError> {
@@ -260,7 +435,37 @@ export const VisitorCheckinPolicy$inboundSchema: z.ZodType<
     "full_checkin": "fullCheckin",
   });
 });
+/** @internal */
+export type VisitorCheckinPolicy$Outbound = {
+  print_visitor_badge?: boolean | undefined;
+  ask_questions_visitor_checkins?: boolean | undefined;
+  full_checkin?: boolean | undefined;
+};
 
+/** @internal */
+export const VisitorCheckinPolicy$outboundSchema: z.ZodType<
+  VisitorCheckinPolicy$Outbound,
+  z.ZodTypeDef,
+  VisitorCheckinPolicy
+> = z.object({
+  printVisitorBadge: z.boolean().optional(),
+  askQuestionsVisitorCheckins: z.boolean().optional(),
+  fullCheckin: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    printVisitorBadge: "print_visitor_badge",
+    askQuestionsVisitorCheckins: "ask_questions_visitor_checkins",
+    fullCheckin: "full_checkin",
+  });
+});
+
+export function visitorCheckinPolicyToJSON(
+  visitorCheckinPolicy: VisitorCheckinPolicy,
+): string {
+  return JSON.stringify(
+    VisitorCheckinPolicy$outboundSchema.parse(visitorCheckinPolicy),
+  );
+}
 export function visitorCheckinPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<VisitorCheckinPolicy, SDKValidationError> {
@@ -312,7 +517,63 @@ export const VisitRequestPolicy$inboundSchema: z.ZodType<
     "email_field": "emailField",
   });
 });
+/** @internal */
+export type VisitRequestPolicy$Outbound = {
+  ask_questions_visit_requests?: boolean | null | undefined;
+  require_website_visit_request_picture?: boolean | null | undefined;
+  require_kiosk_visit_request_picture?: boolean | null | undefined;
+  visit_request_use_previous_picture?: boolean | null | undefined;
+  auto_approve_visit_requests_from_facility?: boolean | null | undefined;
+  auto_approve_visit_requests_from_visitor?: boolean | null | undefined;
+  auto_checkin_visit_requests?: boolean | null | undefined;
+  auto_approve_visit_requests_with_flags?: boolean | null | undefined;
+  auto_checkin_visit_requests_with_flags?: boolean | null | undefined;
+  company_name_field?: string | undefined;
+  email_field?: string | undefined;
+};
 
+/** @internal */
+export const VisitRequestPolicy$outboundSchema: z.ZodType<
+  VisitRequestPolicy$Outbound,
+  z.ZodTypeDef,
+  VisitRequestPolicy
+> = z.object({
+  askQuestionsVisitRequests: z.nullable(z.boolean()).optional(),
+  requireWebsiteVisitRequestPicture: z.nullable(z.boolean()).optional(),
+  requireKioskVisitRequestPicture: z.nullable(z.boolean()).optional(),
+  visitRequestUsePreviousPicture: z.nullable(z.boolean()).optional(),
+  autoApproveVisitRequestsFromFacility: z.nullable(z.boolean()).optional(),
+  autoApproveVisitRequestsFromVisitor: z.nullable(z.boolean()).optional(),
+  autoCheckinVisitRequests: z.nullable(z.boolean()).optional(),
+  autoApproveVisitRequestsWithFlags: z.nullable(z.boolean()).optional(),
+  autoCheckinVisitRequestsWithFlags: z.nullable(z.boolean()).optional(),
+  companyNameField: z.string().optional(),
+  emailField: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    askQuestionsVisitRequests: "ask_questions_visit_requests",
+    requireWebsiteVisitRequestPicture: "require_website_visit_request_picture",
+    requireKioskVisitRequestPicture: "require_kiosk_visit_request_picture",
+    visitRequestUsePreviousPicture: "visit_request_use_previous_picture",
+    autoApproveVisitRequestsFromFacility:
+      "auto_approve_visit_requests_from_facility",
+    autoApproveVisitRequestsFromVisitor:
+      "auto_approve_visit_requests_from_visitor",
+    autoCheckinVisitRequests: "auto_checkin_visit_requests",
+    autoApproveVisitRequestsWithFlags: "auto_approve_visit_requests_with_flags",
+    autoCheckinVisitRequestsWithFlags: "auto_checkin_visit_requests_with_flags",
+    companyNameField: "company_name_field",
+    emailField: "email_field",
+  });
+});
+
+export function visitRequestPolicyToJSON(
+  visitRequestPolicy: VisitRequestPolicy,
+): string {
+  return JSON.stringify(
+    VisitRequestPolicy$outboundSchema.parse(visitRequestPolicy),
+  );
+}
 export function visitRequestPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<VisitRequestPolicy, SDKValidationError> {
@@ -352,7 +613,46 @@ export const ZoneConfig$inboundSchema: z.ZodType<
     "visit_request_policy": "visitRequestPolicy",
   });
 });
+/** @internal */
+export type ZoneConfig$Outbound = {
+  id?: number | undefined;
+  zone_id?: number | undefined;
+  sort_order?: number | null | undefined;
+  applies_to?: ZoneConfigAppliesTo$Outbound | undefined;
+  vendor_policy?: ZoneConfigVendorPolicy$Outbound | undefined;
+  visitor_checkin_policy?: VisitorCheckinPolicy$Outbound | undefined;
+  visit_request_policy?: VisitRequestPolicy$Outbound | undefined;
+};
+
+/** @internal */
+export const ZoneConfig$outboundSchema: z.ZodType<
+  ZoneConfig$Outbound,
+  z.ZodTypeDef,
+  ZoneConfig
+> = z.object({
+  id: z.number().int().optional(),
+  zoneId: z.number().int().optional(),
+  sortOrder: z.nullable(z.number().int()).optional(),
+  appliesTo: z.lazy(() => ZoneConfigAppliesTo$outboundSchema).optional(),
+  vendorPolicy: z.lazy(() => ZoneConfigVendorPolicy$outboundSchema).optional(),
+  visitorCheckinPolicy: z.lazy(() => VisitorCheckinPolicy$outboundSchema)
+    .optional(),
+  visitRequestPolicy: z.lazy(() => VisitRequestPolicy$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    zoneId: "zone_id",
+    sortOrder: "sort_order",
+    appliesTo: "applies_to",
+    vendorPolicy: "vendor_policy",
+    visitorCheckinPolicy: "visitor_checkin_policy",
+    visitRequestPolicy: "visit_request_policy",
+  });
+});
 
+export function zoneConfigToJSON(zoneConfig: ZoneConfig): string {
+  return JSON.stringify(ZoneConfig$outboundSchema.parse(zoneConfig));
+}
 export function zoneConfigFromJSON(
   jsonString: string,
 ): SafeParseResult<ZoneConfig, SDKValidationError> {

package/src/models/operations/deletewebhookendpoint.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type DeleteWebhookEndpointRequest = {
+  /**
+   * The identifier of the object
+   */
+  id: number;
+};
+
+/** @internal */
+export type DeleteWebhookEndpointRequest$Outbound = {
+  id: number;
+};
+
+/** @internal */
+export const DeleteWebhookEndpointRequest$outboundSchema: z.ZodType<
+  DeleteWebhookEndpointRequest$Outbound,
+  z.ZodTypeDef,
+  DeleteWebhookEndpointRequest
+> = z.object({
+  id: z.number().int(),
+});
+
+export function deleteWebhookEndpointRequestToJSON(
+  deleteWebhookEndpointRequest: DeleteWebhookEndpointRequest,
+): string {
+  return JSON.stringify(
+    DeleteWebhookEndpointRequest$outboundSchema.parse(
+      deleteWebhookEndpointRequest,
+    ),
+  );
+}

package/src/models/operations/index.ts

@@ -33,6 +33,7 @@ export * from "./deletefhirconfigbyid.js";
 export * from "./deletepaymentprofile.js";
 export * from "./deletevendorcredentialfile.js";
 export * from "./deletevendormanagedbycompany.js";
+export * from "./deletewebhookendpoint.js";
 export * from "./downloadcompanytargetfacilitiesexport.js";
 export * from "./downloadfacilityvendorsexport.js";
 export * from "./downloadinvoicesexport.js";

package/src/models/operations/listallwebhookendpoints.ts

@@ -39,6 +39,10 @@ export type ListAllWebhookEndpointsListAllWebhookEndpointsOk = {
   items: Array<components.WebhookEndpoint>;
 };
 
+export type ListAllWebhookEndpointsResponse = {
+  result: ListAllWebhookEndpointsListAllWebhookEndpointsOk;
+};
+
 /** @internal */
 export type ListAllWebhookEndpointsRequest$Outbound = {
   page?: number | undefined;
@@ -99,3 +103,28 @@ export function listAllWebhookEndpointsListAllWebhookEndpointsOkFromJSON(
     `Failed to parse 'ListAllWebhookEndpointsListAllWebhookEndpointsOk' from JSON`,
   );
 }
+
+/** @internal */
+export const ListAllWebhookEndpointsResponse$inboundSchema: z.ZodType<
+  ListAllWebhookEndpointsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Result: z.lazy(() =>
+    ListAllWebhookEndpointsListAllWebhookEndpointsOk$inboundSchema
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    "Result": "result",
+  });
+});
+
+export function listAllWebhookEndpointsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAllWebhookEndpointsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAllWebhookEndpointsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAllWebhookEndpointsResponse' from JSON`,
+  );
+}

package/src/models/operations/updatesthewebhookendpointwiththegivenid.ts

@@ -11,13 +11,13 @@ export type UpdatesTheWebhookEndpointWithTheGivenIdRequest = {
    * The identifier of the object
    */
   id: number;
-  webhookEndpoint: components.WebhookEndpoint;
+  webhookEndpointUpdate: components.WebhookEndpointUpdate;
 };
 
 /** @internal */
 export type UpdatesTheWebhookEndpointWithTheGivenIdRequest$Outbound = {
   id: number;
-  WebhookEndpoint: components.WebhookEndpoint$Outbound;
+  WebhookEndpointUpdate: components.WebhookEndpointUpdate$Outbound;
 };
 
 /** @internal */
@@ -28,10 +28,10 @@ export const UpdatesTheWebhookEndpointWithTheGivenIdRequest$outboundSchema:
     UpdatesTheWebhookEndpointWithTheGivenIdRequest
   > = z.object({
     id: z.number().int(),
-    webhookEndpoint: components.WebhookEndpoint$outboundSchema,
+    webhookEndpointUpdate: components.WebhookEndpointUpdate$outboundSchema,
   }).transform((v) => {
     return remap$(v, {
-      webhookEndpoint: "WebhookEndpoint",
+      webhookEndpointUpdate: "WebhookEndpointUpdate",
     });
   });
 

package/src/models/webhooks/index.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export * from "./sendtargetfacilitystatuschangecreated.js";
+export * from "./sendtargetfacilitystatuschangedestroyed.js";
+export * from "./sendtargetfacilitystatuschangeupdated.js";
+export * from "./sendvendorcreated.js";
+export * from "./sendvendordestroyed.js";
+export * from "./sendvendorscancreated.js";
+export * from "./sendvendorscandestroyed.js";
+export * from "./sendvendorscanupdated.js";
+export * from "./sendvendorupdated.js";
+export * from "./sendvisitorcheckincreated.js";
+export * from "./sendvisitorcheckindestroyed.js";
+export * from "./sendvisitorcheckinupdated.js";

package/src/models/webhooks/sendtargetfacilitystatuschangecreated.ts

@@ -0,0 +1,119 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SendTargetFacilityStatusChangeCreatedRequest = {
+  /**
+   * `t=<unix seconds>,v1=<hex hmac>`, one `v1` per active secret. Each is
+   *
+   * @remarks
+   * `HMAC-SHA256(secret, "<t>.<raw body>")`. Compare with a constant-time function and
+   * reject a timestamp that is not recent.
+   */
+  greenSecuritySignature: string;
+  /**
+   * The event this delivery belongs to. Route on it when one URL serves several events.
+   */
+  greenSecurityEvent: string;
+  /**
+   * Stable per delivery, including across retries. Key your de-duplication on it.
+   */
+  greenSecurityIdempotencyKey: string;
+  /**
+   * The entity in the body.
+   */
+  greenWebhookId: string;
+  targetFacilityStatusChange: components.TargetFacilityStatusChange | null;
+};
+
+/** @internal */
+export const SendTargetFacilityStatusChangeCreatedRequest$inboundSchema:
+  z.ZodType<
+    SendTargetFacilityStatusChangeCreatedRequest,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    "Green-Security-Signature": types.string(),
+    "Green-Security-Event": types.string(),
+    "Green-Security-Idempotency-Key": types.string(),
+    "Green-Webhook-Id": types.string(),
+    TargetFacilityStatusChange: types.nullable(
+      components.TargetFacilityStatusChange$inboundSchema,
+    ),
+  }).transform((v) => {
+    return remap$(v, {
+      "Green-Security-Signature": "greenSecuritySignature",
+      "Green-Security-Event": "greenSecurityEvent",
+      "Green-Security-Idempotency-Key": "greenSecurityIdempotencyKey",
+      "Green-Webhook-Id": "greenWebhookId",
+      "TargetFacilityStatusChange": "targetFacilityStatusChange",
+    });
+  });
+/** @internal */
+export type SendTargetFacilityStatusChangeCreatedRequest$Outbound = {
+  "Green-Security-Signature": string;
+  "Green-Security-Event": string;
+  "Green-Security-Idempotency-Key": string;
+  "Green-Webhook-Id": string;
+  TargetFacilityStatusChange:
+    | components.TargetFacilityStatusChange$Outbound
+    | null;
+};
+
+/** @internal */
+export const SendTargetFacilityStatusChangeCreatedRequest$outboundSchema:
+  z.ZodType<
+    SendTargetFacilityStatusChangeCreatedRequest$Outbound,
+    z.ZodTypeDef,
+    SendTargetFacilityStatusChangeCreatedRequest
+  > = z.object({
+    greenSecuritySignature: z.string(),
+    greenSecurityEvent: z.string(),
+    greenSecurityIdempotencyKey: z.string(),
+    greenWebhookId: z.string(),
+    targetFacilityStatusChange: z.nullable(
+      components.TargetFacilityStatusChange$outboundSchema,
+    ),
+  }).transform((v) => {
+    return remap$(v, {
+      greenSecuritySignature: "Green-Security-Signature",
+      greenSecurityEvent: "Green-Security-Event",
+      greenSecurityIdempotencyKey: "Green-Security-Idempotency-Key",
+      greenWebhookId: "Green-Webhook-Id",
+      targetFacilityStatusChange: "TargetFacilityStatusChange",
+    });
+  });
+
+export function sendTargetFacilityStatusChangeCreatedRequestToJSON(
+  sendTargetFacilityStatusChangeCreatedRequest:
+    SendTargetFacilityStatusChangeCreatedRequest,
+): string {
+  return JSON.stringify(
+    SendTargetFacilityStatusChangeCreatedRequest$outboundSchema.parse(
+      sendTargetFacilityStatusChangeCreatedRequest,
+    ),
+  );
+}
+export function sendTargetFacilityStatusChangeCreatedRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  SendTargetFacilityStatusChangeCreatedRequest,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SendTargetFacilityStatusChangeCreatedRequest$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'SendTargetFacilityStatusChangeCreatedRequest' from JSON`,
+  );
+}