@greensecurity/javascript-sdk 0.42.5 → 0.42.12-beta.0

package/src/models/components/contact.ts

@@ -4,8 +4,11 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 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 {
   DepartmentSummary,
@@ -29,7 +32,7 @@ export const Status = {
   Inactive: "Inactive",
   Deleted: "Deleted",
 } as const;
-export type Status = ClosedEnum<typeof Status>;
+export type Status = OpenEnum<typeof Status>;
 
 export type ContactDepartment = DepartmentSummary | number;
 
@@ -51,7 +54,7 @@ export const ContactFacility$inboundSchema: z.ZodType<
   ContactFacility,
   z.ZodTypeDef,
   unknown
-> = z.union([FacilitySummary$inboundSchema, z.number().int()]);
+> = smartUnion([FacilitySummary$inboundSchema, types.number()]);
 
 export function contactFacilityFromJSON(
   jsonString: string,
@@ -64,8 +67,8 @@ export function contactFacilityFromJSON(
 }
 
 /** @internal */
-export const System$inboundSchema: z.ZodType<System, z.ZodTypeDef, unknown> = z
-  .union([SystemSummary$inboundSchema, z.number().int()]);
+export const System$inboundSchema: z.ZodType<System, z.ZodTypeDef, unknown> =
+  smartUnion([SystemSummary$inboundSchema, types.number()]);
 
 export function systemFromJSON(
   jsonString: string,
@@ -82,7 +85,7 @@ export const ContactUser$inboundSchema: z.ZodType<
   ContactUser,
   z.ZodTypeDef,
   unknown
-> = z.union([UserSummary$inboundSchema, z.number().int()]);
+> = smartUnion([UserSummary$inboundSchema, types.number()]);
 
 export function contactUserFromJSON(
   jsonString: string,
@@ -95,15 +98,15 @@ export function contactUserFromJSON(
 }
 
 /** @internal */
-export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
-  .nativeEnum(Status);
+export const Status$inboundSchema: z.ZodType<Status, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Status);
 
 /** @internal */
 export const ContactDepartment$inboundSchema: z.ZodType<
   ContactDepartment,
   z.ZodTypeDef,
   unknown
-> = z.union([DepartmentSummary$inboundSchema, z.number().int()]);
+> = smartUnion([DepartmentSummary$inboundSchema, types.number()]);
 
 export function contactDepartmentFromJSON(
   jsonString: string,
@@ -118,18 +121,19 @@ export function contactDepartmentFromJSON(
 /** @internal */
 export const Contact$inboundSchema: z.ZodType<Contact, z.ZodTypeDef, unknown> =
   z.object({
-    id: z.number().int().optional(),
+    id: types.optional(types.number()),
     facility: z.nullable(
-      z.union([FacilitySummary$inboundSchema, z.number().int()]),
+      smartUnion([FacilitySummary$inboundSchema, types.number()]),
     ).optional(),
-    system: z.nullable(z.union([SystemSummary$inboundSchema, z.number().int()]))
-      .optional(),
-    user: z.nullable(z.union([UserSummary$inboundSchema, z.number().int()]))
+    system: z.nullable(
+      smartUnion([SystemSummary$inboundSchema, types.number()]),
+    ).optional(),
+    user: z.nullable(smartUnion([UserSummary$inboundSchema, types.number()]))
       .optional(),
     status: Status$inboundSchema,
-    position: z.nullable(z.string()).optional(),
+    position: z.nullable(types.string()).optional(),
     department: z.nullable(
-      z.union([DepartmentSummary$inboundSchema, z.number().int()]),
+      smartUnion([DepartmentSummary$inboundSchema, types.number()]),
     ).optional(),
   });
 

package/src/models/components/credential.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+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 {
   CredentialDocument,
@@ -20,7 +22,7 @@ export const CredentialType = {
   Three: "3",
   Four: "4",
 } as const;
-export type CredentialType = ClosedEnum<typeof CredentialType>;
+export type CredentialType = OpenEnum<typeof CredentialType>;
 
 export const ValidFor = {
   Ongoing: "Ongoing",
@@ -29,14 +31,14 @@ export const ValidFor = {
   EndOfYear: "End of Year",
   DayOfYear: "Day of Year",
 } as const;
-export type ValidFor = ClosedEnum<typeof ValidFor>;
+export type ValidFor = OpenEnum<typeof ValidFor>;
 
 export const CredentialStatus1 = {
   Active: "Active",
   Inactive: "Inactive",
   Deleted: "Deleted",
 } as const;
-export type CredentialStatus1 = ClosedEnum<typeof CredentialStatus1>;
+export type CredentialStatus1 = OpenEnum<typeof CredentialStatus1>;
 
 /**
  * Reduced list of attributes of Credential record
@@ -49,7 +51,7 @@ export type Credential = {
   credentialType?: CredentialType | undefined;
   validFor?: ValidFor | undefined;
   status?: CredentialStatus1 | null | undefined;
-  hasPricing?: boolean | undefined;
+  hasPricing?: boolean | null | undefined;
   allowDecline?: boolean | undefined;
   jsSchema?: string | null | undefined;
   uiSchema?: string | null | undefined;
@@ -63,21 +65,29 @@ export type Credential = {
   credentialDocuments?: Array<CredentialDocument | null> | null | undefined;
   fileUrl?: string | null | undefined;
   declineFileUrl?: string | null | undefined;
+  invoiceAfterCredential?: boolean | null | undefined;
 };
 
 /** @internal */
-export const CredentialType$inboundSchema: z.ZodNativeEnum<
-  typeof CredentialType
-> = z.nativeEnum(CredentialType);
+export const CredentialType$inboundSchema: z.ZodType<
+  CredentialType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CredentialType);
 
 /** @internal */
-export const ValidFor$inboundSchema: z.ZodNativeEnum<typeof ValidFor> = z
-  .nativeEnum(ValidFor);
+export const ValidFor$inboundSchema: z.ZodType<
+  ValidFor,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ValidFor);
 
 /** @internal */
-export const CredentialStatus1$inboundSchema: z.ZodNativeEnum<
-  typeof CredentialStatus1
-> = z.nativeEnum(CredentialStatus1);
+export const CredentialStatus1$inboundSchema: z.ZodType<
+  CredentialStatus1,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CredentialStatus1);
 
 /** @internal */
 export const Credential$inboundSchema: z.ZodType<
@@ -85,29 +95,30 @@ export const Credential$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
-  applies_to_company: z.boolean().optional(),
-  name: z.nullable(z.string()).optional(),
-  description: z.nullable(z.string()).optional(),
-  credential_type: CredentialType$inboundSchema.optional(),
-  valid_for: ValidFor$inboundSchema.optional(),
+  id: types.number(),
+  applies_to_company: types.optional(types.boolean()),
+  name: z.nullable(types.string()).optional(),
+  description: z.nullable(types.string()).optional(),
+  credential_type: types.optional(CredentialType$inboundSchema),
+  valid_for: types.optional(ValidFor$inboundSchema),
   status: z.nullable(CredentialStatus1$inboundSchema).optional(),
-  has_pricing: z.boolean().optional(),
-  allow_decline: z.boolean().optional(),
-  js_schema: z.nullable(z.string()).optional(),
-  ui_schema: z.nullable(z.string()).optional(),
-  behavior: z.nullable(z.string()).optional(),
-  require_electronic_signature: z.boolean().optional(),
-  accept_text: z.nullable(z.string()).optional(),
-  accept_submitting_text: z.nullable(z.string()).optional(),
-  decline_submitting_text: z.nullable(z.string()).optional(),
-  decline_description: z.nullable(z.string()).optional(),
-  require_decline_file: z.boolean().optional(),
+  has_pricing: z.nullable(types.boolean()).optional(),
+  allow_decline: types.optional(types.boolean()),
+  js_schema: z.nullable(types.string()).optional(),
+  ui_schema: z.nullable(types.string()).optional(),
+  behavior: z.nullable(types.string()).optional(),
+  require_electronic_signature: types.optional(types.boolean()),
+  accept_text: z.nullable(types.string()).optional(),
+  accept_submitting_text: z.nullable(types.string()).optional(),
+  decline_submitting_text: z.nullable(types.string()).optional(),
+  decline_description: z.nullable(types.string()).optional(),
+  require_decline_file: types.optional(types.boolean()),
   credential_documents: z.nullable(
-    z.array(z.nullable(z.lazy(() => CredentialDocument$inboundSchema))),
+    z.array(types.nullable(z.lazy(() => CredentialDocument$inboundSchema))),
   ).optional(),
-  file_url: z.nullable(z.string()).optional(),
-  decline_file_url: z.nullable(z.string()).optional(),
+  file_url: z.nullable(types.string()).optional(),
+  decline_file_url: z.nullable(types.string()).optional(),
+  invoice_after_credential: z.nullable(types.boolean()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "applies_to_company": "appliesToCompany",
@@ -126,6 +137,7 @@ export const Credential$inboundSchema: z.ZodType<
     "credential_documents": "credentialDocuments",
     "file_url": "fileUrl",
     "decline_file_url": "declineFileUrl",
+    "invoice_after_credential": "invoiceAfterCredential",
   });
 });
 

package/src/models/components/credentialdocument.ts

@@ -6,6 +6,8 @@ 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 { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { Credential, Credential$inboundSchema } from "./credential.js";
 
@@ -34,11 +36,11 @@ export type CredentialDocumentCredential = Credential | number;
 /** @internal */
 export const FileT$inboundSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
   .object({
-    file_name: z.nullable(z.string()).optional(),
-    content_type: z.nullable(z.string()).optional(),
-    file_size: z.nullable(z.number().int()).optional(),
-    updated_at: z.nullable(z.string()).optional(),
-    url: z.nullable(z.string()).optional(),
+    file_name: z.nullable(types.string()).optional(),
+    content_type: z.nullable(types.string()).optional(),
+    file_size: z.nullable(types.number()).optional(),
+    updated_at: z.nullable(types.string()).optional(),
+    url: z.nullable(types.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "file_name": "fileName",
@@ -64,13 +66,13 @@ export const CredentialDocument$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
+  id: types.number(),
   credential: z.nullable(
-    z.union([z.lazy(() => Credential$inboundSchema), z.number().int()]),
+    smartUnion([z.lazy(() => Credential$inboundSchema), types.number()]),
   ).optional(),
-  name: z.nullable(z.string()).optional(),
-  docuseal_template_id: z.nullable(z.number().int()).optional(),
-  description: z.nullable(z.string()).optional(),
+  name: z.nullable(types.string()).optional(),
+  docuseal_template_id: z.nullable(types.number()).optional(),
+  description: z.nullable(types.string()).optional(),
   file: z.nullable(z.lazy(() => FileT$inboundSchema)).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -93,7 +95,7 @@ export const CredentialDocumentCredential$inboundSchema: z.ZodType<
   CredentialDocumentCredential,
   z.ZodTypeDef,
   unknown
-> = z.union([z.lazy(() => Credential$inboundSchema), z.number().int()]);
+> = smartUnion([z.lazy(() => Credential$inboundSchema), types.number()]);
 
 export function credentialDocumentCredentialFromJSON(
   jsonString: string,

package/src/models/components/credit.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+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";
 
 export const Action = {
@@ -14,7 +16,7 @@ export const Action = {
   Debit: "debit",
   Transfer: "transfer",
 } as const;
-export type Action = ClosedEnum<typeof Action>;
+export type Action = OpenEnum<typeof Action>;
 
 export type Credit = {
   id?: number | undefined;
@@ -28,20 +30,20 @@ export type Credit = {
 };
 
 /** @internal */
-export const Action$inboundSchema: z.ZodNativeEnum<typeof Action> = z
-  .nativeEnum(Action);
+export const Action$inboundSchema: z.ZodType<Action, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Action);
 
 /** @internal */
 export const Credit$inboundSchema: z.ZodType<Credit, z.ZodTypeDef, unknown> = z
   .object({
-    id: z.number().int().optional(),
-    date: z.nullable(z.string()).optional(),
-    action: Action$inboundSchema.optional(),
-    amount: z.number().int().optional(),
-    balance: z.number().int().optional(),
-    from: z.nullable(z.string()).optional(),
-    to: z.nullable(z.string()).optional(),
-    invoice_number: z.nullable(z.string()).optional(),
+    id: types.optional(types.number()),
+    date: z.nullable(types.string()).optional(),
+    action: types.optional(Action$inboundSchema),
+    amount: types.optional(types.number()),
+    balance: types.optional(types.number()),
+    from: z.nullable(types.string()).optional(),
+    to: z.nullable(types.string()).optional(),
+    invoice_number: z.nullable(types.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "invoice_number": "invoiceNumber",

package/src/models/components/datarequest.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+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";
 
 export const DataType = {
@@ -16,7 +18,7 @@ export const DataType = {
   LongText: "Long Text",
   Date: "Date",
 } as const;
-export type DataType = ClosedEnum<typeof DataType>;
+export type DataType = OpenEnum<typeof DataType>;
 
 export type Url = {
   value?: string | null | undefined;
@@ -43,16 +45,19 @@ export type DataRequest = {
 };
 
 /** @internal */
-export const DataType$inboundSchema: z.ZodNativeEnum<typeof DataType> = z
-  .nativeEnum(DataType);
+export const DataType$inboundSchema: z.ZodType<
+  DataType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(DataType);
 
 /** @internal */
 export const Url$inboundSchema: z.ZodType<Url, z.ZodTypeDef, unknown> = z
   .object({
-    value: z.nullable(z.string()).optional(),
-    func: z.nullable(z.string()).optional(),
-    expires: z.nullable(z.string()).optional(),
-    days_valid: z.nullable(z.number().int()).optional(),
+    value: z.nullable(types.string()).optional(),
+    func: z.nullable(types.string()).optional(),
+    expires: z.nullable(types.string()).optional(),
+    days_valid: z.nullable(types.number()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "days_valid": "daysValid",
@@ -75,11 +80,11 @@ export const DataRequestFile$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  file_name: z.nullable(z.string()).optional(),
-  content_type: z.nullable(z.string()).optional(),
-  file_size: z.nullable(z.number().int()).optional(),
-  updated_at: z.nullable(z.string()).optional(),
-  url: z.nullable(z.string()).optional(),
+  file_name: z.nullable(types.string()).optional(),
+  content_type: z.nullable(types.string()).optional(),
+  file_size: z.nullable(types.number()).optional(),
+  updated_at: z.nullable(types.string()).optional(),
+  url: z.nullable(types.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "file_name": "fileName",
@@ -105,10 +110,10 @@ export const DataRequest$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  data_type: DataType$inboundSchema.optional(),
-  name: z.nullable(z.string()).optional(),
-  description: z.nullable(z.string()).optional(),
+  id: types.optional(types.number()),
+  data_type: types.optional(DataType$inboundSchema),
+  name: z.nullable(types.string()).optional(),
+  description: z.nullable(types.string()).optional(),
   url: z.nullable(z.lazy(() => Url$inboundSchema)).optional(),
   file: z.nullable(z.lazy(() => DataRequestFile$inboundSchema)).optional(),
 }).transform((v) => {

package/src/models/components/deleteapiresponse.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -20,7 +21,7 @@ export const DeleteApiResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  success: z.boolean(),
+  success: types.boolean(),
 });
 
 export function deleteApiResponseFromJSON(

package/src/models/components/department.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -21,8 +22,8 @@ export const Department$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
-  name: z.string(),
+  id: types.number(),
+  name: types.string(),
 });
 
 export function departmentFromJSON(

package/src/models/components/departmentmembership.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { Contact, Contact$inboundSchema } from "./contact.js";
 import {
@@ -30,7 +32,7 @@ export const DepartmentMembershipDepartment$inboundSchema: z.ZodType<
   DepartmentMembershipDepartment,
   z.ZodTypeDef,
   unknown
-> = z.union([DepartmentSummary$inboundSchema, z.number().int()]);
+> = smartUnion([DepartmentSummary$inboundSchema, types.number()]);
 
 export function departmentMembershipDepartmentFromJSON(
   jsonString: string,
@@ -47,7 +49,7 @@ export const DepartmentMembershipContact$inboundSchema: z.ZodType<
   DepartmentMembershipContact,
   z.ZodTypeDef,
   unknown
-> = z.union([Contact$inboundSchema, z.number().int()]);
+> = smartUnion([Contact$inboundSchema, types.number()]);
 
 export function departmentMembershipContactFromJSON(
   jsonString: string,
@@ -65,11 +67,11 @@ export const DepartmentMembership$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
+  id: types.number(),
   department: z.nullable(
-    z.union([DepartmentSummary$inboundSchema, z.number().int()]),
+    smartUnion([DepartmentSummary$inboundSchema, types.number()]),
   ).optional(),
-  contact: z.nullable(z.union([Contact$inboundSchema, z.number().int()]))
+  contact: z.nullable(smartUnion([Contact$inboundSchema, types.number()]))
     .optional(),
 });
 

package/src/models/components/departmentsummary.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -21,8 +22,8 @@ export const DepartmentSummary$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
-  name: z.string(),
+  id: types.number(),
+  name: types.string(),
 });
 
 export function departmentSummaryFromJSON(

package/src/models/components/desc.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v3";
+import { smartUnion } from "../../types/smartUnion.js";
 
 export type Desc = boolean | number;
 
@@ -11,7 +12,7 @@ export type Desc$Outbound = boolean | number;
 
 /** @internal */
 export const Desc$outboundSchema: z.ZodType<Desc$Outbound, z.ZodTypeDef, Desc> =
-  z.union([z.boolean(), z.number().int()]);
+  smartUnion([z.boolean(), z.number().int()]);
 
 export function descToJSON(desc: Desc): string {
   return JSON.stringify(Desc$outboundSchema.parse(desc));

package/src/models/components/expand.ts

@@ -85,6 +85,9 @@ export const Expand = {
     "vendor_credential_data_request.data_request",
   VendorCredentialBackgroundCheckProviderId:
     "vendor_credential.background_check_provider_id",
+  VendorCredentialRequiresInvoice: "vendor_credential.requires_invoice",
+  VendorCredentialCredentialPricingOptions:
+    "vendor_credential.credential_pricing_options",
   ZoneFacility: "zone.facility",
   ZoneDepartment: "zone.department",
   ZoneRules: "zone.rules",