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

package/src/models/components/facilitycalendarsummary.ts

@@ -11,6 +11,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FacilityVendorType,
   FacilityVendorType$inboundSchema,
+  FacilityVendorType$Outbound,
+  FacilityVendorType$outboundSchema,
 } from "./facilityvendortype.js";
 
 export type FacilityCalendarSummaryVendorPolicy = {
@@ -42,7 +44,33 @@ export const FacilityCalendarSummaryVendorPolicy$inboundSchema: z.ZodType<
     "vendor_types": "vendorTypes",
   });
 });
+/** @internal */
+export type FacilityCalendarSummaryVendorPolicy$Outbound = {
+  vendor_types?: Array<FacilityVendorType$Outbound> | undefined;
+};
+
+/** @internal */
+export const FacilityCalendarSummaryVendorPolicy$outboundSchema: z.ZodType<
+  FacilityCalendarSummaryVendorPolicy$Outbound,
+  z.ZodTypeDef,
+  FacilityCalendarSummaryVendorPolicy
+> = z.object({
+  vendorTypes: z.array(FacilityVendorType$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorTypes: "vendor_types",
+  });
+});
 
+export function facilityCalendarSummaryVendorPolicyToJSON(
+  facilityCalendarSummaryVendorPolicy: FacilityCalendarSummaryVendorPolicy,
+): string {
+  return JSON.stringify(
+    FacilityCalendarSummaryVendorPolicy$outboundSchema.parse(
+      facilityCalendarSummaryVendorPolicy,
+    ),
+  );
+}
 export function facilityCalendarSummaryVendorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityCalendarSummaryVendorPolicy, SDKValidationError> {
@@ -77,7 +105,51 @@ export const FacilityCalendarSummary$inboundSchema: z.ZodType<
     "allow_dept_appointments": "allowDeptAppointments",
   });
 });
+/** @internal */
+export type FacilityCalendarSummary$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+  system_id?: number | undefined;
+  status?: string | null | undefined;
+  vendor_policy?:
+    | FacilityCalendarSummaryVendorPolicy$Outbound
+    | null
+    | undefined;
+  allow_user_appointments?: boolean | undefined;
+  allow_dept_appointments?: boolean | undefined;
+};
+
+/** @internal */
+export const FacilityCalendarSummary$outboundSchema: z.ZodType<
+  FacilityCalendarSummary$Outbound,
+  z.ZodTypeDef,
+  FacilityCalendarSummary
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+  systemId: z.number().int().optional(),
+  status: z.nullable(z.string()).optional(),
+  vendorPolicy: z.nullable(
+    z.lazy(() => FacilityCalendarSummaryVendorPolicy$outboundSchema),
+  ).optional(),
+  allowUserAppointments: z.boolean().optional(),
+  allowDeptAppointments: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    systemId: "system_id",
+    vendorPolicy: "vendor_policy",
+    allowUserAppointments: "allow_user_appointments",
+    allowDeptAppointments: "allow_dept_appointments",
+  });
+});
 
+export function facilityCalendarSummaryToJSON(
+  facilityCalendarSummary: FacilityCalendarSummary,
+): string {
+  return JSON.stringify(
+    FacilityCalendarSummary$outboundSchema.parse(facilityCalendarSummary),
+  );
+}
 export function facilityCalendarSummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityCalendarSummary, SDKValidationError> {

package/src/models/components/facilitysummary.ts

@@ -11,6 +11,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FacilityVendorType,
   FacilityVendorType$inboundSchema,
+  FacilityVendorType$Outbound,
+  FacilityVendorType$outboundSchema,
 } from "./facilityvendortype.js";
 
 export type VendorPolicy = {
@@ -40,7 +42,27 @@ export const VendorPolicy$inboundSchema: z.ZodType<
     "vendor_types": "vendorTypes",
   });
 });
+/** @internal */
+export type VendorPolicy$Outbound = {
+  vendor_types?: Array<FacilityVendorType$Outbound> | undefined;
+};
 
+/** @internal */
+export const VendorPolicy$outboundSchema: z.ZodType<
+  VendorPolicy$Outbound,
+  z.ZodTypeDef,
+  VendorPolicy
+> = z.object({
+  vendorTypes: z.array(FacilityVendorType$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorTypes: "vendor_types",
+  });
+});
+
+export function vendorPolicyToJSON(vendorPolicy: VendorPolicy): string {
+  return JSON.stringify(VendorPolicy$outboundSchema.parse(vendorPolicy));
+}
 export function vendorPolicyFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorPolicy, SDKValidationError> {
@@ -69,7 +91,39 @@ export const FacilitySummary$inboundSchema: z.ZodType<
     "vendor_policy": "vendorPolicy",
   });
 });
+/** @internal */
+export type FacilitySummary$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+  system_id?: number | undefined;
+  status?: string | null | undefined;
+  vendor_policy?: VendorPolicy$Outbound | null | undefined;
+};
+
+/** @internal */
+export const FacilitySummary$outboundSchema: z.ZodType<
+  FacilitySummary$Outbound,
+  z.ZodTypeDef,
+  FacilitySummary
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+  systemId: z.number().int().optional(),
+  status: z.nullable(z.string()).optional(),
+  vendorPolicy: z.nullable(z.lazy(() => VendorPolicy$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    systemId: "system_id",
+    vendorPolicy: "vendor_policy",
+  });
+});
 
+export function facilitySummaryToJSON(
+  facilitySummary: FacilitySummary,
+): string {
+  return JSON.stringify(FacilitySummary$outboundSchema.parse(facilitySummary));
+}
 export function facilitySummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilitySummary, SDKValidationError> {

package/src/models/components/facilityvendortype.ts

@@ -45,7 +45,36 @@ export const AppliesTo$inboundSchema: z.ZodType<
     "everyone_else": "everyoneElse",
   });
 });
+/** @internal */
+export type AppliesTo$Outbound = {
+  company_id?: number | null | undefined;
+  company_group_id?: number | null | undefined;
+  vendor_group_id?: number | null | undefined;
+  everyone_else: boolean;
+};
 
+/** @internal */
+export const AppliesTo$outboundSchema: z.ZodType<
+  AppliesTo$Outbound,
+  z.ZodTypeDef,
+  AppliesTo
+> = z.object({
+  companyId: z.nullable(z.number().int()).optional(),
+  companyGroupId: z.nullable(z.number().int()).optional(),
+  vendorGroupId: z.nullable(z.number().int()).optional(),
+  everyoneElse: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    companyId: "company_id",
+    companyGroupId: "company_group_id",
+    vendorGroupId: "vendor_group_id",
+    everyoneElse: "everyone_else",
+  });
+});
+
+export function appliesToToJSON(appliesTo: AppliesTo): string {
+  return JSON.stringify(AppliesTo$outboundSchema.parse(appliesTo));
+}
 export function appliesToFromJSON(
   jsonString: string,
 ): SafeParseResult<AppliesTo, SDKValidationError> {
@@ -74,7 +103,41 @@ export const FacilityVendorType$inboundSchema: z.ZodType<
     "applies_to": "appliesTo",
   });
 });
+/** @internal */
+export type FacilityVendorType$Outbound = {
+  id?: number | undefined;
+  name: string;
+  short_name: string;
+  sort_order: number;
+  applies_to: AppliesTo$Outbound;
+};
+
+/** @internal */
+export const FacilityVendorType$outboundSchema: z.ZodType<
+  FacilityVendorType$Outbound,
+  z.ZodTypeDef,
+  FacilityVendorType
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string(),
+  shortName: z.string(),
+  sortOrder: z.number().int(),
+  appliesTo: z.lazy(() => AppliesTo$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    shortName: "short_name",
+    sortOrder: "sort_order",
+    appliesTo: "applies_to",
+  });
+});
 
+export function facilityVendorTypeToJSON(
+  facilityVendorType: FacilityVendorType,
+): string {
+  return JSON.stringify(
+    FacilityVendorType$outboundSchema.parse(facilityVendorType),
+  );
+}
 export function facilityVendorTypeFromJSON(
   jsonString: string,
 ): SafeParseResult<FacilityVendorType, SDKValidationError> {

package/src/models/components/financialstatus.ts

@@ -32,3 +32,9 @@ export const FinancialStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(FinancialStatus);
+/** @internal */
+export const FinancialStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  FinancialStatus
+> = openEnums.outboundSchema(FinancialStatus);

package/src/models/components/imageset.ts

@@ -29,7 +29,29 @@ export const ImageSet$inboundSchema: z.ZodType<
   large: types.optional(types.string()),
   original: types.optional(types.string()),
 });
+/** @internal */
+export type ImageSet$Outbound = {
+  tiny?: string | undefined;
+  thumb?: string | undefined;
+  large?: string | undefined;
+  original?: string | undefined;
+};
 
+/** @internal */
+export const ImageSet$outboundSchema: z.ZodType<
+  ImageSet$Outbound,
+  z.ZodTypeDef,
+  ImageSet
+> = z.object({
+  tiny: z.string().optional(),
+  thumb: z.string().optional(),
+  large: z.string().optional(),
+  original: z.string().optional(),
+});
+
+export function imageSetToJSON(imageSet: ImageSet): string {
+  return JSON.stringify(ImageSet$outboundSchema.parse(imageSet));
+}
 export function imageSetFromJSON(
   jsonString: string,
 ): SafeParseResult<ImageSet, SDKValidationError> {

package/src/models/components/index.ts

@@ -72,6 +72,7 @@ export * from "./subscription.js";
 export * from "./supervisor.js";
 export * from "./supportarticle.js";
 export * from "./systemsummary.js";
+export * from "./targetfacilitystatuschange.js";
 export * from "./uploadhistoryitem.js";
 export * from "./user.js";
 export * from "./userdetails.js";
@@ -99,6 +100,12 @@ export * from "./vendorscrubdetails.js";
 export * from "./vendorscrubpurchase.js";
 export * from "./vendortargetfacility.js";
 export * from "./vendortype.js";
+export * from "./visitorcheckin.js";
+export * from "./webhookconsumers.js";
 export * from "./webhookendpoint.js";
+export * from "./webhookendpointcreate.js";
+export * from "./webhookendpointupdate.js";
+export * from "./webhooksubscription.js";
+export * from "./webhooksubscriptiondetail.js";
 export * from "./zone.js";
 export * from "./zoneconfig.js";

package/src/models/components/invoice.ts

@@ -10,10 +10,17 @@ import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import { InvoiceItem, InvoiceItem$inboundSchema } from "./invoiceitem.js";
+import {
+  InvoiceItem,
+  InvoiceItem$inboundSchema,
+  InvoiceItem$Outbound,
+  InvoiceItem$outboundSchema,
+} from "./invoiceitem.js";
 import {
   InvoiceTransaction,
   InvoiceTransaction$inboundSchema,
+  InvoiceTransaction$Outbound,
+  InvoiceTransaction$outboundSchema,
 } from "./invoicetransaction.js";
 
 /**
@@ -140,7 +147,34 @@ export const CustomFields$inboundSchema: z.ZodType<
     "vendor_field_id": "vendorFieldId",
   });
 });
+/** @internal */
+export type CustomFields$Outbound = {
+  name?: string | null | undefined;
+  field_type?: string | null | undefined;
+  value?: string | null | undefined;
+  vendor_field_id?: number | null | undefined;
+};
+
+/** @internal */
+export const CustomFields$outboundSchema: z.ZodType<
+  CustomFields$Outbound,
+  z.ZodTypeDef,
+  CustomFields
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+  fieldType: z.nullable(z.string()).optional(),
+  value: z.nullable(z.string()).optional(),
+  vendorFieldId: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fieldType: "field_type",
+    vendorFieldId: "vendor_field_id",
+  });
+});
 
+export function customFieldsToJSON(customFields: CustomFields): string {
+  return JSON.stringify(CustomFields$outboundSchema.parse(customFields));
+}
 export function customFieldsFromJSON(
   jsonString: string,
 ): SafeParseResult<CustomFields, SDKValidationError> {
@@ -157,6 +191,12 @@ export const InvoiceType$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(InvoiceType);
+/** @internal */
+export const InvoiceType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  InvoiceType
+> = openEnums.outboundSchema(InvoiceType);
 
 /** @internal */
 export const MayPayInvoice$inboundSchema: z.ZodType<
@@ -167,7 +207,25 @@ export const MayPayInvoice$inboundSchema: z.ZodType<
   users: types.optional(z.array(types.number())),
   companies: types.optional(z.array(types.number())),
 });
+/** @internal */
+export type MayPayInvoice$Outbound = {
+  users?: Array<number> | undefined;
+  companies?: Array<number> | undefined;
+};
 
+/** @internal */
+export const MayPayInvoice$outboundSchema: z.ZodType<
+  MayPayInvoice$Outbound,
+  z.ZodTypeDef,
+  MayPayInvoice
+> = z.object({
+  users: z.array(z.number().int()).optional(),
+  companies: z.array(z.number().int()).optional(),
+});
+
+export function mayPayInvoiceToJSON(mayPayInvoice: MayPayInvoice): string {
+  return JSON.stringify(MayPayInvoice$outboundSchema.parse(mayPayInvoice));
+}
 export function mayPayInvoiceFromJSON(
   jsonString: string,
 ): SafeParseResult<MayPayInvoice, SDKValidationError> {
@@ -217,7 +275,73 @@ export const Invoice$inboundSchema: z.ZodType<Invoice, z.ZodTypeDef, unknown> =
       "may_pay_invoice": "mayPayInvoice",
     });
   });
+/** @internal */
+export type Invoice$Outbound = {
+  id: number;
+  invoice_number?: string | null | undefined;
+  tracking_number?: string | null | undefined;
+  date_processed?: string | null | undefined;
+  date_due?: string | null | undefined;
+  amount?: number | null | undefined;
+  status?: string | null | undefined;
+  financial_status?: string | null | undefined;
+  amount_not_paid?: number | null | undefined;
+  tax?: number | null | undefined;
+  convenience_fee?: number | null | undefined;
+  shipping?: number | null | undefined;
+  custom_fields?: CustomFields$Outbound | null | undefined;
+  lines?: Array<InvoiceItem$Outbound | null> | null | undefined;
+  transactions?: Array<InvoiceTransaction$Outbound> | null | undefined;
+  representative?: string | null | undefined;
+  invoice_type?: string | undefined;
+  may_pay_invoice?: MayPayInvoice$Outbound | null | undefined;
+};
+
+/** @internal */
+export const Invoice$outboundSchema: z.ZodType<
+  Invoice$Outbound,
+  z.ZodTypeDef,
+  Invoice
+> = z.object({
+  id: z.number().int(),
+  invoiceNumber: z.nullable(z.string()).optional(),
+  trackingNumber: z.nullable(z.string()).optional(),
+  dateProcessed: z.nullable(z.string()).optional(),
+  dateDue: z.nullable(z.string()).optional(),
+  amount: z.nullable(z.number().int()).optional(),
+  status: z.nullable(z.string()).optional(),
+  financialStatus: z.nullable(z.string()).optional(),
+  amountNotPaid: z.nullable(z.number().int()).optional(),
+  tax: z.nullable(z.number().int()).optional(),
+  convenienceFee: z.nullable(z.number()).optional(),
+  shipping: z.nullable(z.number().int()).optional(),
+  customFields: z.nullable(z.lazy(() => CustomFields$outboundSchema))
+    .optional(),
+  lines: z.nullable(z.array(z.nullable(InvoiceItem$outboundSchema))).optional(),
+  transactions: z.nullable(z.array(InvoiceTransaction$outboundSchema))
+    .optional(),
+  representative: z.nullable(z.string()).optional(),
+  invoiceType: InvoiceType$outboundSchema.optional(),
+  mayPayInvoice: z.nullable(z.lazy(() => MayPayInvoice$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    invoiceNumber: "invoice_number",
+    trackingNumber: "tracking_number",
+    dateProcessed: "date_processed",
+    dateDue: "date_due",
+    financialStatus: "financial_status",
+    amountNotPaid: "amount_not_paid",
+    convenienceFee: "convenience_fee",
+    customFields: "custom_fields",
+    invoiceType: "invoice_type",
+    mayPayInvoice: "may_pay_invoice",
+  });
+});
 
+export function invoiceToJSON(invoice: Invoice): string {
+  return JSON.stringify(Invoice$outboundSchema.parse(invoice));
+}
 export function invoiceFromJSON(
   jsonString: string,
 ): SafeParseResult<Invoice, SDKValidationError> {

package/src/models/components/invoiceitem.ts

@@ -9,10 +9,17 @@ 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 { Product, Product$inboundSchema } from "./product.js";
+import {
+  Product,
+  Product$inboundSchema,
+  Product$Outbound,
+  Product$outboundSchema,
+} from "./product.js";
 import {
   ProductVariant,
   ProductVariant$inboundSchema,
+  ProductVariant$Outbound,
+  ProductVariant$outboundSchema,
 } from "./productvariant.js";
 
 export type Variant = ProductVariant | number;
@@ -48,7 +55,19 @@ export type InvoiceItem = {
 /** @internal */
 export const Variant$inboundSchema: z.ZodType<Variant, z.ZodTypeDef, unknown> =
   smartUnion([ProductVariant$inboundSchema, types.number()]);
+/** @internal */
+export type Variant$Outbound = ProductVariant$Outbound | number;
+
+/** @internal */
+export const Variant$outboundSchema: z.ZodType<
+  Variant$Outbound,
+  z.ZodTypeDef,
+  Variant
+> = smartUnion([ProductVariant$outboundSchema, z.number().int()]);
 
+export function variantToJSON(variant: Variant): string {
+  return JSON.stringify(Variant$outboundSchema.parse(variant));
+}
 export function variantFromJSON(
   jsonString: string,
 ): SafeParseResult<Variant, SDKValidationError> {
@@ -65,7 +84,23 @@ export const InvoiceItemProduct$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([Product$inboundSchema, types.number()]);
+/** @internal */
+export type InvoiceItemProduct$Outbound = Product$Outbound | number;
 
+/** @internal */
+export const InvoiceItemProduct$outboundSchema: z.ZodType<
+  InvoiceItemProduct$Outbound,
+  z.ZodTypeDef,
+  InvoiceItemProduct
+> = smartUnion([Product$outboundSchema, z.number().int()]);
+
+export function invoiceItemProductToJSON(
+  invoiceItemProduct: InvoiceItemProduct,
+): string {
+  return JSON.stringify(
+    InvoiceItemProduct$outboundSchema.parse(invoiceItemProduct),
+  );
+}
 export function invoiceItemProductFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceItemProduct, SDKValidationError> {
@@ -90,7 +125,35 @@ export const Details$inboundSchema: z.ZodType<Details, z.ZodTypeDef, unknown> =
       "used_days": "usedDays",
     });
   });
+/** @internal */
+export type Details$Outbound = {
+  total_days?: number | null | undefined;
+  unused_days?: number | null | undefined;
+  used_days?: number | null | undefined;
+  prorate?: number | null | undefined;
+};
 
+/** @internal */
+export const Details$outboundSchema: z.ZodType<
+  Details$Outbound,
+  z.ZodTypeDef,
+  Details
+> = z.object({
+  totalDays: z.nullable(z.number().int()).optional(),
+  unusedDays: z.nullable(z.number().int()).optional(),
+  usedDays: z.nullable(z.number().int()).optional(),
+  prorate: z.nullable(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    totalDays: "total_days",
+    unusedDays: "unused_days",
+    usedDays: "used_days",
+  });
+});
+
+export function detailsToJSON(details: Details): string {
+  return JSON.stringify(Details$outboundSchema.parse(details));
+}
 export function detailsFromJSON(
   jsonString: string,
 ): SafeParseResult<Details, SDKValidationError> {
@@ -132,7 +195,58 @@ export const InvoiceItem$inboundSchema: z.ZodType<
     "unit_price": "unitPrice",
   });
 });
+/** @internal */
+export type InvoiceItem$Outbound = {
+  id?: number | undefined;
+  date_starts?: string | null | undefined;
+  date_ends?: string | null | undefined;
+  is_subscription?: boolean | null | undefined;
+  product_title?: string | null | undefined;
+  title?: string | null | undefined;
+  quantity?: number | null | undefined;
+  unit_price?: number | null | undefined;
+  discount?: number | undefined;
+  subtotal?: number | null | undefined;
+  variant?: ProductVariant$Outbound | number | null | undefined;
+  product?: Product$Outbound | number | null | undefined;
+  details?: Details$Outbound | null | undefined;
+};
 
+/** @internal */
+export const InvoiceItem$outboundSchema: z.ZodType<
+  InvoiceItem$Outbound,
+  z.ZodTypeDef,
+  InvoiceItem
+> = z.object({
+  id: z.number().int().optional(),
+  dateStarts: z.nullable(z.string()).optional(),
+  dateEnds: z.nullable(z.string()).optional(),
+  isSubscription: z.nullable(z.boolean()).optional(),
+  productTitle: z.nullable(z.string()).optional(),
+  title: z.nullable(z.string()).optional(),
+  quantity: z.nullable(z.number()).optional(),
+  unitPrice: z.nullable(z.number().int()).optional(),
+  discount: z.number().int().optional(),
+  subtotal: z.nullable(z.number().int()).optional(),
+  variant: z.nullable(
+    smartUnion([ProductVariant$outboundSchema, z.number().int()]),
+  ).optional(),
+  product: z.nullable(smartUnion([Product$outboundSchema, z.number().int()]))
+    .optional(),
+  details: z.nullable(z.lazy(() => Details$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dateStarts: "date_starts",
+    dateEnds: "date_ends",
+    isSubscription: "is_subscription",
+    productTitle: "product_title",
+    unitPrice: "unit_price",
+  });
+});
+
+export function invoiceItemToJSON(invoiceItem: InvoiceItem): string {
+  return JSON.stringify(InvoiceItem$outboundSchema.parse(invoiceItem));
+}
 export function invoiceItemFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceItem, SDKValidationError> {