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

package/src/models/components/vendor.ts

@@ -9,36 +9,96 @@ 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 { Company, Company$inboundSchema } from "./company.js";
-import { Department, Department$inboundSchema } from "./department.js";
-import { Facility, Facility$inboundSchema } from "./facility.js";
+import {
+  Company,
+  Company$inboundSchema,
+  Company$Outbound,
+  Company$outboundSchema,
+} from "./company.js";
+import {
+  Department,
+  Department$inboundSchema,
+  Department$Outbound,
+  Department$outboundSchema,
+} from "./department.js";
+import {
+  Facility,
+  Facility$inboundSchema,
+  Facility$Outbound,
+  Facility$outboundSchema,
+} from "./facility.js";
 import {
   FacilityCalendarSummary,
   FacilityCalendarSummary$inboundSchema,
+  FacilityCalendarSummary$Outbound,
+  FacilityCalendarSummary$outboundSchema,
 } from "./facilitycalendarsummary.js";
 import {
   FacilitySummary,
   FacilitySummary$inboundSchema,
+  FacilitySummary$Outbound,
+  FacilitySummary$outboundSchema,
 } from "./facilitysummary.js";
-import { ImageSet, ImageSet$inboundSchema } from "./imageset.js";
-import { Invoice, Invoice$inboundSchema } from "./invoice.js";
+import {
+  ImageSet,
+  ImageSet$inboundSchema,
+  ImageSet$Outbound,
+  ImageSet$outboundSchema,
+} from "./imageset.js";
+import {
+  Invoice,
+  Invoice$inboundSchema,
+  Invoice$Outbound,
+  Invoice$outboundSchema,
+} from "./invoice.js";
 import {
   PaymentProfile,
   PaymentProfile$inboundSchema,
+  PaymentProfile$Outbound,
+  PaymentProfile$outboundSchema,
 } from "./paymentprofile.js";
-import { Subscription, Subscription$inboundSchema } from "./subscription.js";
-import { Supervisor, Supervisor$inboundSchema } from "./supervisor.js";
-import { UserLocation, UserLocation$inboundSchema } from "./userlocation.js";
+import {
+  Subscription,
+  Subscription$inboundSchema,
+  Subscription$Outbound,
+  Subscription$outboundSchema,
+} from "./subscription.js";
+import {
+  Supervisor,
+  Supervisor$inboundSchema,
+  Supervisor$Outbound,
+  Supervisor$outboundSchema,
+} from "./supervisor.js";
+import {
+  UserLocation,
+  UserLocation$inboundSchema,
+  UserLocation$Outbound,
+  UserLocation$outboundSchema,
+} from "./userlocation.js";
 import {
   VendorCustomFields,
   VendorCustomFields$inboundSchema,
+  VendorCustomFields$Outbound,
+  VendorCustomFields$outboundSchema,
 } from "./vendorcustomfields.js";
-import { VendorGroup, VendorGroup$inboundSchema } from "./vendorgroup.js";
+import {
+  VendorGroup,
+  VendorGroup$inboundSchema,
+  VendorGroup$Outbound,
+  VendorGroup$outboundSchema,
+} from "./vendorgroup.js";
 import {
   VendorJobTitle,
   VendorJobTitle$inboundSchema,
+  VendorJobTitle$Outbound,
+  VendorJobTitle$outboundSchema,
 } from "./vendorjobtitle.js";
-import { VendorType, VendorType$inboundSchema } from "./vendortype.js";
+import {
+  VendorType,
+  VendorType$inboundSchema,
+  VendorType$Outbound,
+  VendorType$outboundSchema,
+} from "./vendortype.js";
 
 export type Badge = {
   badgeType?: string | undefined;
@@ -212,7 +272,33 @@ export const Badge$inboundSchema: z.ZodType<Badge, z.ZodTypeDef, unknown> = z
       "required_badge_type": "requiredBadgeType",
     });
   });
+/** @internal */
+export type Badge$Outbound = {
+  badge_type?: string | undefined;
+  badge_mac_address?: string | null | undefined;
+  required_badge_type?: string | null | undefined;
+};
 
+/** @internal */
+export const Badge$outboundSchema: z.ZodType<
+  Badge$Outbound,
+  z.ZodTypeDef,
+  Badge
+> = z.object({
+  badgeType: z.string().optional(),
+  badgeMacAddress: z.nullable(z.string()).optional(),
+  requiredBadgeType: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    badgeType: "badge_type",
+    badgeMacAddress: "badge_mac_address",
+    requiredBadgeType: "required_badge_type",
+  });
+});
+
+export function badgeToJSON(badge: Badge): string {
+  return JSON.stringify(Badge$outboundSchema.parse(badge));
+}
 export function badgeFromJSON(
   jsonString: string,
 ): SafeParseResult<Badge, SDKValidationError> {
@@ -248,7 +334,51 @@ export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
       "image_urls": "imageUrls",
     });
   });
+/** @internal */
+export type One$Outbound = {
+  id?: number | undefined;
+  first_name?: string | null | undefined;
+  last_name?: string | null | undefined;
+  email?: string | null | undefined;
+  phone?: string | null | undefined;
+  mobile_phone?: string | null | undefined;
+  fax?: string | null | undefined;
+  user_type?: string | null | undefined;
+  timezone?: string | null | undefined;
+  qr_code?: string | null | undefined;
+  image_urls?: ImageSet$Outbound | null | undefined;
+  location?: UserLocation$Outbound | null | undefined;
+};
+
+/** @internal */
+export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
+  .object({
+    id: z.number().int().optional(),
+    firstName: z.nullable(z.string()).optional(),
+    lastName: z.nullable(z.string()).optional(),
+    email: z.nullable(z.string()).optional(),
+    phone: z.nullable(z.string()).optional(),
+    mobilePhone: z.nullable(z.string()).optional(),
+    fax: z.nullable(z.string()).optional(),
+    userType: z.nullable(z.string()).optional(),
+    timezone: z.nullable(z.string()).optional(),
+    qrCode: z.nullable(z.string()).optional(),
+    imageUrls: z.nullable(ImageSet$outboundSchema).optional(),
+    location: z.nullable(UserLocation$outboundSchema).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      firstName: "first_name",
+      lastName: "last_name",
+      mobilePhone: "mobile_phone",
+      userType: "user_type",
+      qrCode: "qr_code",
+      imageUrls: "image_urls",
+    });
+  });
 
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
+}
 export function oneFromJSON(
   jsonString: string,
 ): SafeParseResult<One, SDKValidationError> {
@@ -265,7 +395,19 @@ export const VendorUser$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([z.lazy(() => One$inboundSchema), types.number()]);
+/** @internal */
+export type VendorUser$Outbound = One$Outbound | number;
+
+/** @internal */
+export const VendorUser$outboundSchema: z.ZodType<
+  VendorUser$Outbound,
+  z.ZodTypeDef,
+  VendorUser
+> = smartUnion([z.lazy(() => One$outboundSchema), z.number().int()]);
 
+export function vendorUserToJSON(vendorUser: VendorUser): string {
+  return JSON.stringify(VendorUser$outboundSchema.parse(vendorUser));
+}
 export function vendorUserFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorUser, SDKValidationError> {
@@ -282,7 +424,19 @@ export const VendorJob$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([VendorJobTitle$inboundSchema, types.number()]);
+/** @internal */
+export type VendorJob$Outbound = VendorJobTitle$Outbound | number;
 
+/** @internal */
+export const VendorJob$outboundSchema: z.ZodType<
+  VendorJob$Outbound,
+  z.ZodTypeDef,
+  VendorJob
+> = smartUnion([VendorJobTitle$outboundSchema, z.number().int()]);
+
+export function vendorJobToJSON(vendorJob: VendorJob): string {
+  return JSON.stringify(VendorJob$outboundSchema.parse(vendorJob));
+}
 export function vendorJobFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorJob, SDKValidationError> {
@@ -299,7 +453,23 @@ export const VendorVendorType$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([VendorType$inboundSchema, types.number()]);
+/** @internal */
+export type VendorVendorType$Outbound = VendorType$Outbound | number;
 
+/** @internal */
+export const VendorVendorType$outboundSchema: z.ZodType<
+  VendorVendorType$Outbound,
+  z.ZodTypeDef,
+  VendorVendorType
+> = smartUnion([VendorType$outboundSchema, z.number().int()]);
+
+export function vendorVendorTypeToJSON(
+  vendorVendorType: VendorVendorType,
+): string {
+  return JSON.stringify(
+    VendorVendorType$outboundSchema.parse(vendorVendorType),
+  );
+}
 export function vendorVendorTypeFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorVendorType, SDKValidationError> {
@@ -316,7 +486,23 @@ export const VendorPaymentProfile$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([PaymentProfile$inboundSchema, types.number()]);
+/** @internal */
+export type VendorPaymentProfile$Outbound = PaymentProfile$Outbound | number;
 
+/** @internal */
+export const VendorPaymentProfile$outboundSchema: z.ZodType<
+  VendorPaymentProfile$Outbound,
+  z.ZodTypeDef,
+  VendorPaymentProfile
+> = smartUnion([PaymentProfile$outboundSchema, z.number().int()]);
+
+export function vendorPaymentProfileToJSON(
+  vendorPaymentProfile: VendorPaymentProfile,
+): string {
+  return JSON.stringify(
+    VendorPaymentProfile$outboundSchema.parse(vendorPaymentProfile),
+  );
+}
 export function vendorPaymentProfileFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorPaymentProfile, SDKValidationError> {
@@ -336,7 +522,25 @@ export const CompanySummary$inboundSchema: z.ZodType<
   id: types.string(),
   name: types.optional(types.string()),
 });
+/** @internal */
+export type CompanySummary$Outbound = {
+  id: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const CompanySummary$outboundSchema: z.ZodType<
+  CompanySummary$Outbound,
+  z.ZodTypeDef,
+  CompanySummary
+> = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+});
 
+export function companySummaryToJSON(companySummary: CompanySummary): string {
+  return JSON.stringify(CompanySummary$outboundSchema.parse(companySummary));
+}
 export function companySummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanySummary, SDKValidationError> {
@@ -356,7 +560,22 @@ export const VendorCompany$inboundSchema: z.ZodType<
   Company$inboundSchema,
   z.lazy(() => CompanySummary$inboundSchema),
 ]);
+/** @internal */
+export type VendorCompany$Outbound = Company$Outbound | CompanySummary$Outbound;
 
+/** @internal */
+export const VendorCompany$outboundSchema: z.ZodType<
+  VendorCompany$Outbound,
+  z.ZodTypeDef,
+  VendorCompany
+> = smartUnion([
+  Company$outboundSchema,
+  z.lazy(() => CompanySummary$outboundSchema),
+]);
+
+export function vendorCompanyToJSON(vendorCompany: VendorCompany): string {
+  return JSON.stringify(VendorCompany$outboundSchema.parse(vendorCompany));
+}
 export function vendorCompanyFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorCompany, SDKValidationError> {
@@ -408,7 +627,75 @@ export const PaymentResponsibility$inboundSchema: z.ZodType<
     "other_invoices_user_id": "otherInvoicesUserId",
   });
 });
+/** @internal */
+export type PaymentResponsibility$Outbound = {
+  id?: number | null | undefined;
+  company_manager_id?: number | null | undefined;
+  credentialing_subscription?: boolean | null | undefined;
+  scrubs_subscription?: boolean | null | undefined;
+  scrub_credits?: boolean | null | undefined;
+  hard_badge_initial?: boolean | null | undefined;
+  hard_badge_extra?: boolean | null | undefined;
+  other_invoices?: boolean | null | undefined;
+  facility_id?: number | null | undefined;
+  company_id?: number | null | undefined;
+  credentialing_subscription_user_id?: number | null | undefined;
+  scrubs_subscription_user_id?: number | null | undefined;
+  scrub_credits_user_id?: number | null | undefined;
+  hard_badge_initial_user_id?: number | null | undefined;
+  hard_badge_extra_user_id?: number | null | undefined;
+  other_invoices_user_id?: number | null | undefined;
+};
 
+/** @internal */
+export const PaymentResponsibility$outboundSchema: z.ZodType<
+  PaymentResponsibility$Outbound,
+  z.ZodTypeDef,
+  PaymentResponsibility
+> = z.object({
+  id: z.nullable(z.number().int()).optional(),
+  companyManagerId: z.nullable(z.number().int()).optional(),
+  credentialingSubscription: z.nullable(z.boolean()).optional(),
+  scrubsSubscription: z.nullable(z.boolean()).optional(),
+  scrubCredits: z.nullable(z.boolean()).optional(),
+  hardBadgeInitial: z.nullable(z.boolean()).optional(),
+  hardBadgeExtra: z.nullable(z.boolean()).optional(),
+  otherInvoices: z.nullable(z.boolean()).optional(),
+  facilityId: z.nullable(z.number().int()).optional(),
+  companyId: z.nullable(z.number().int()).optional(),
+  credentialingSubscriptionUserId: z.nullable(z.number().int()).optional(),
+  scrubsSubscriptionUserId: z.nullable(z.number().int()).optional(),
+  scrubCreditsUserId: z.nullable(z.number().int()).optional(),
+  hardBadgeInitialUserId: z.nullable(z.number().int()).optional(),
+  hardBadgeExtraUserId: z.nullable(z.number().int()).optional(),
+  otherInvoicesUserId: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    companyManagerId: "company_manager_id",
+    credentialingSubscription: "credentialing_subscription",
+    scrubsSubscription: "scrubs_subscription",
+    scrubCredits: "scrub_credits",
+    hardBadgeInitial: "hard_badge_initial",
+    hardBadgeExtra: "hard_badge_extra",
+    otherInvoices: "other_invoices",
+    facilityId: "facility_id",
+    companyId: "company_id",
+    credentialingSubscriptionUserId: "credentialing_subscription_user_id",
+    scrubsSubscriptionUserId: "scrubs_subscription_user_id",
+    scrubCreditsUserId: "scrub_credits_user_id",
+    hardBadgeInitialUserId: "hard_badge_initial_user_id",
+    hardBadgeExtraUserId: "hard_badge_extra_user_id",
+    otherInvoicesUserId: "other_invoices_user_id",
+  });
+});
+
+export function paymentResponsibilityToJSON(
+  paymentResponsibility: PaymentResponsibility,
+): string {
+  return JSON.stringify(
+    PaymentResponsibility$outboundSchema.parse(paymentResponsibility),
+  );
+}
 export function paymentResponsibilityFromJSON(
   jsonString: string,
 ): SafeParseResult<PaymentResponsibility, SDKValidationError> {
@@ -425,7 +712,19 @@ export const PendingInvoice$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([Invoice$inboundSchema, types.number()]);
+/** @internal */
+export type PendingInvoice$Outbound = Invoice$Outbound | number;
 
+/** @internal */
+export const PendingInvoice$outboundSchema: z.ZodType<
+  PendingInvoice$Outbound,
+  z.ZodTypeDef,
+  PendingInvoice
+> = smartUnion([Invoice$outboundSchema, z.number().int()]);
+
+export function pendingInvoiceToJSON(pendingInvoice: PendingInvoice): string {
+  return JSON.stringify(PendingInvoice$outboundSchema.parse(pendingInvoice));
+}
 export function pendingInvoiceFromJSON(
   jsonString: string,
 ): SafeParseResult<PendingInvoice, SDKValidationError> {
@@ -531,7 +830,147 @@ export const Vendor$inboundSchema: z.ZodType<Vendor, z.ZodTypeDef, unknown> = z
       "has_target_facility_questions": "hasTargetFacilityQuestions",
     });
   });
+/** @internal */
+export type Vendor$Outbound = {
+  id?: number | undefined;
+  badge?: Badge$Outbound | null | undefined;
+  email_recepient?: string | null | undefined;
+  send_weekly_summary_email?: boolean | null | undefined;
+  title?: string | null | undefined;
+  primary_sales_state?: string | null | undefined;
+  has_emerald_status?: boolean | null | undefined;
+  user?: One$Outbound | number | undefined;
+  registration_data?: { [k: string]: any } | null | undefined;
+  registration_finished?: boolean | null | undefined;
+  vendor_job?: VendorJobTitle$Outbound | number | null | undefined;
+  vendor_type?: VendorType$Outbound | number | null | undefined;
+  supervisor?: Supervisor$Outbound | null | undefined;
+  qr_code?: string | null | undefined;
+  head_shot?: ImageSet$Outbound | null | undefined;
+  drivers_license?: ImageSet$Outbound | null | undefined;
+  image_urls?: ImageSet$Outbound | null | undefined;
+  payment_profile?: PaymentProfile$Outbound | number | null | undefined;
+  primary_facility?: Facility$Outbound | null | undefined;
+  primary_department?: Department$Outbound | null | undefined;
+  company?: Company$Outbound | CompanySummary$Outbound | null | undefined;
+  credentialing_subscription?: Subscription$Outbound | null | undefined;
+  scrubs_subscription?: Subscription$Outbound | null | undefined;
+  payment_responsibility?: PaymentResponsibility$Outbound | null | undefined;
+  background_check_date_expires?: string | null | undefined;
+  credit_balance?: number | null | undefined;
+  target_facilities?: Array<FacilitySummary$Outbound> | null | undefined;
+  approved_calendaring_facilities?:
+    | Array<FacilityCalendarSummary$Outbound>
+    | null
+    | undefined;
+  pending_invoice?: Invoice$Outbound | number | null | undefined;
+  vendor_groups?: Array<VendorGroup$Outbound | null> | null | undefined;
+  has_credentialed_facilities?: boolean | null | undefined;
+  target_facilities_updated?: string | null | undefined;
+  custom_fields?: Array<VendorCustomFields$Outbound> | null | undefined;
+  last_scanned?: string | null | undefined;
+  has_target_facility_questions?: boolean | null | undefined;
+};
+
+/** @internal */
+export const Vendor$outboundSchema: z.ZodType<
+  Vendor$Outbound,
+  z.ZodTypeDef,
+  Vendor
+> = z.object({
+  id: z.number().int().optional(),
+  badge: z.nullable(z.lazy(() => Badge$outboundSchema)).optional(),
+  emailRecepient: z.nullable(z.string()).optional(),
+  sendWeeklySummaryEmail: z.nullable(z.boolean()).optional(),
+  title: z.nullable(z.string()).optional(),
+  primarySalesState: z.nullable(z.string()).optional(),
+  hasEmeraldStatus: z.nullable(z.boolean()).optional(),
+  user: smartUnion([z.lazy(() => One$outboundSchema), z.number().int()])
+    .optional(),
+  registrationData: z.nullable(z.record(z.any())).optional(),
+  registrationFinished: z.nullable(z.boolean()).optional(),
+  vendorJob: z.nullable(
+    smartUnion([VendorJobTitle$outboundSchema, z.number().int()]),
+  ).optional(),
+  vendorType: z.nullable(
+    smartUnion([VendorType$outboundSchema, z.number().int()]),
+  ).optional(),
+  supervisor: z.nullable(Supervisor$outboundSchema).optional(),
+  qrCode: z.nullable(z.string()).optional(),
+  headShot: z.nullable(ImageSet$outboundSchema).optional(),
+  driversLicense: z.nullable(ImageSet$outboundSchema).optional(),
+  imageUrls: z.nullable(ImageSet$outboundSchema).optional(),
+  paymentProfile: z.nullable(
+    smartUnion([PaymentProfile$outboundSchema, z.number().int()]),
+  ).optional(),
+  primaryFacility: z.nullable(Facility$outboundSchema).optional(),
+  primaryDepartment: z.nullable(Department$outboundSchema).optional(),
+  company: z.nullable(
+    smartUnion([
+      Company$outboundSchema,
+      z.lazy(() => CompanySummary$outboundSchema),
+    ]),
+  ).optional(),
+  credentialingSubscription: z.nullable(Subscription$outboundSchema).optional(),
+  scrubsSubscription: z.nullable(Subscription$outboundSchema).optional(),
+  paymentResponsibility: z.nullable(
+    z.lazy(() => PaymentResponsibility$outboundSchema),
+  ).optional(),
+  backgroundCheckDateExpires: z.nullable(z.string()).optional(),
+  creditBalance: z.nullable(z.number()).optional(),
+  targetFacilities: z.nullable(z.array(FacilitySummary$outboundSchema))
+    .optional(),
+  approvedCalendaringFacilities: z.nullable(
+    z.array(FacilityCalendarSummary$outboundSchema),
+  ).optional(),
+  pendingInvoice: z.nullable(
+    smartUnion([Invoice$outboundSchema, z.number().int()]),
+  ).optional(),
+  vendorGroups: z.nullable(z.array(z.nullable(VendorGroup$outboundSchema)))
+    .optional(),
+  hasCredentialedFacilities: z.nullable(z.boolean()).optional(),
+  targetFacilitiesUpdated: z.nullable(z.string()).optional(),
+  customFields: z.nullable(z.array(VendorCustomFields$outboundSchema))
+    .optional(),
+  lastScanned: z.nullable(z.string()).optional(),
+  hasTargetFacilityQuestions: z.nullable(z.boolean()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    emailRecepient: "email_recepient",
+    sendWeeklySummaryEmail: "send_weekly_summary_email",
+    primarySalesState: "primary_sales_state",
+    hasEmeraldStatus: "has_emerald_status",
+    registrationData: "registration_data",
+    registrationFinished: "registration_finished",
+    vendorJob: "vendor_job",
+    vendorType: "vendor_type",
+    qrCode: "qr_code",
+    headShot: "head_shot",
+    driversLicense: "drivers_license",
+    imageUrls: "image_urls",
+    paymentProfile: "payment_profile",
+    primaryFacility: "primary_facility",
+    primaryDepartment: "primary_department",
+    credentialingSubscription: "credentialing_subscription",
+    scrubsSubscription: "scrubs_subscription",
+    paymentResponsibility: "payment_responsibility",
+    backgroundCheckDateExpires: "background_check_date_expires",
+    creditBalance: "credit_balance",
+    targetFacilities: "target_facilities",
+    approvedCalendaringFacilities: "approved_calendaring_facilities",
+    pendingInvoice: "pending_invoice",
+    vendorGroups: "vendor_groups",
+    hasCredentialedFacilities: "has_credentialed_facilities",
+    targetFacilitiesUpdated: "target_facilities_updated",
+    customFields: "custom_fields",
+    lastScanned: "last_scanned",
+    hasTargetFacilityQuestions: "has_target_facility_questions",
+  });
+});
 
+export function vendorToJSON(vendor: Vendor): string {
+  return JSON.stringify(Vendor$outboundSchema.parse(vendor));
+}
 export function vendorFromJSON(
   jsonString: string,
 ): SafeParseResult<Vendor, SDKValidationError> {

package/src/models/components/vendorcustomfields.ts

@@ -82,10 +82,19 @@ export const FieldType$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(FieldType);
+/** @internal */
+export const FieldType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  FieldType
+> = openEnums.outboundSchema(FieldType);
 
 /** @internal */
 export const ForType$inboundSchema: z.ZodType<ForType, z.ZodTypeDef, unknown> =
   openEnums.inboundSchema(ForType);
+/** @internal */
+export const ForType$outboundSchema: z.ZodType<string, z.ZodTypeDef, ForType> =
+  openEnums.outboundSchema(ForType);
 
 /** @internal */
 export const FieldFor$inboundSchema: z.ZodType<
@@ -105,7 +114,37 @@ export const FieldFor$inboundSchema: z.ZodType<
     "facility_id": "facilityId",
   });
 });
+/** @internal */
+export type FieldFor$Outbound = {
+  for_type?: string | undefined;
+  company?: string | null | undefined;
+  company_id?: number | null | undefined;
+  facility?: string | null | undefined;
+  facility_id?: number | null | undefined;
+};
+
+/** @internal */
+export const FieldFor$outboundSchema: z.ZodType<
+  FieldFor$Outbound,
+  z.ZodTypeDef,
+  FieldFor
+> = z.object({
+  forType: ForType$outboundSchema.optional(),
+  company: z.nullable(z.string()).optional(),
+  companyId: z.nullable(z.number().int()).optional(),
+  facility: z.nullable(z.string()).optional(),
+  facilityId: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    forType: "for_type",
+    companyId: "company_id",
+    facilityId: "facility_id",
+  });
+});
 
+export function fieldForToJSON(fieldFor: FieldFor): string {
+  return JSON.stringify(FieldFor$outboundSchema.parse(fieldFor));
+}
 export function fieldForFromJSON(
   jsonString: string,
 ): SafeParseResult<FieldFor, SDKValidationError> {
@@ -133,7 +172,40 @@ export const VendorCustomFields$inboundSchema: z.ZodType<
     "field_for": "fieldFor",
   });
 });
+/** @internal */
+export type VendorCustomFields$Outbound = {
+  id?: number | undefined;
+  name?: string | null | undefined;
+  field_type?: string | null | undefined;
+  value?: string | null | undefined;
+  field_for?: FieldFor$Outbound | null | undefined;
+};
 
+/** @internal */
+export const VendorCustomFields$outboundSchema: z.ZodType<
+  VendorCustomFields$Outbound,
+  z.ZodTypeDef,
+  VendorCustomFields
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.nullable(z.string()).optional(),
+  fieldType: z.nullable(FieldType$outboundSchema).optional(),
+  value: z.nullable(z.string()).optional(),
+  fieldFor: z.nullable(z.lazy(() => FieldFor$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fieldType: "field_type",
+    fieldFor: "field_for",
+  });
+});
+
+export function vendorCustomFieldsToJSON(
+  vendorCustomFields: VendorCustomFields,
+): string {
+  return JSON.stringify(
+    VendorCustomFields$outboundSchema.parse(vendorCustomFields),
+  );
+}
 export function vendorCustomFieldsFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorCustomFields, SDKValidationError> {

package/src/models/components/vendorgroup.ts

@@ -34,7 +34,33 @@ export const VendorGroup$inboundSchema: z.ZodType<
     "vendor_type_ids": "vendorTypeIds",
   });
 });
+/** @internal */
+export type VendorGroup$Outbound = {
+  id?: number | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  vendor_type_ids?: string | null | undefined;
+};
+
+/** @internal */
+export const VendorGroup$outboundSchema: z.ZodType<
+  VendorGroup$Outbound,
+  z.ZodTypeDef,
+  VendorGroup
+> = z.object({
+  id: z.number().int().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  vendorTypeIds: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorTypeIds: "vendor_type_ids",
+  });
+});
 
+export function vendorGroupToJSON(vendorGroup: VendorGroup): string {
+  return JSON.stringify(VendorGroup$outboundSchema.parse(vendorGroup));
+}
 export function vendorGroupFromJSON(
   jsonString: string,
 ): SafeParseResult<VendorGroup, SDKValidationError> {