@apideck/unify 0.36.1 → 0.37.0

package/src/models/components/paymentsfilter.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const PaymentsFilterType = {
   AccountsReceivable: "accounts_receivable",
@@ -16,25 +17,32 @@ export const PaymentsFilterType = {
   AccountsReceivablePrepayment: "accounts_receivable_prepayment",
   AccountsPayablePrepayment: "accounts_payable_prepayment",
 } as const;
-export type PaymentsFilterType = ClosedEnum<typeof PaymentsFilterType>;
+export type PaymentsFilterType = OpenEnum<typeof PaymentsFilterType>;
 
 export type PaymentsFilter = {
   updatedSince?: Date | undefined;
   invoiceId?: string | undefined;
   supplierId?: string | undefined;
+  /**
+   * Filter by customer id
+   */
+  customerId?: string | undefined;
   type?: PaymentsFilterType | undefined;
 };
 
 /** @internal */
-export const PaymentsFilterType$outboundSchema: z.ZodNativeEnum<
-  typeof PaymentsFilterType
-> = z.nativeEnum(PaymentsFilterType);
+export const PaymentsFilterType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PaymentsFilterType
+> = openEnums.outboundSchema(PaymentsFilterType);
 
 /** @internal */
 export type PaymentsFilter$Outbound = {
   updated_since?: string | undefined;
   invoice_id?: string | undefined;
   supplier_id?: string | undefined;
+  customer_id?: string | undefined;
   type?: string | undefined;
 };
 
@@ -47,12 +55,14 @@ export const PaymentsFilter$outboundSchema: z.ZodType<
   updatedSince: z.date().transform(v => v.toISOString()).optional(),
   invoiceId: z.string().optional(),
   supplierId: z.string().optional(),
+  customerId: z.string().optional(),
   type: PaymentsFilterType$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     updatedSince: "updated_since",
     invoiceId: "invoice_id",
     supplierId: "supplier_id",
+    customerId: "customer_id",
   });
 });
 

package/src/models/components/paymentssort.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import {
   SortDirection,
   SortDirection$outboundSchema,
@@ -19,7 +20,7 @@ export const PaymentsSortBy = {
 /**
  * The field on which to sort the Payments
  */
-export type PaymentsSortBy = ClosedEnum<typeof PaymentsSortBy>;
+export type PaymentsSortBy = OpenEnum<typeof PaymentsSortBy>;
 
 export type PaymentsSort = {
   /**
@@ -33,9 +34,11 @@ export type PaymentsSort = {
 };
 
 /** @internal */
-export const PaymentsSortBy$outboundSchema: z.ZodNativeEnum<
-  typeof PaymentsSortBy
-> = z.nativeEnum(PaymentsSortBy);
+export const PaymentsSortBy$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PaymentsSortBy
+> = openEnums.outboundSchema(PaymentsSortBy);
 
 /** @internal */
 export type PaymentsSort$Outbound = {

package/src/models/components/paymentstatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * Status of payment
@@ -19,13 +20,17 @@ export const PaymentStatus = {
 /**
  * Status of payment
  */
-export type PaymentStatus = ClosedEnum<typeof PaymentStatus>;
+export type PaymentStatus = OpenEnum<typeof PaymentStatus>;
 
 /** @internal */
-export const PaymentStatus$inboundSchema: z.ZodNativeEnum<
-  typeof PaymentStatus
-> = z.nativeEnum(PaymentStatus);
+export const PaymentStatus$inboundSchema: z.ZodType<
+  PaymentStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PaymentStatus);
 /** @internal */
-export const PaymentStatus$outboundSchema: z.ZodNativeEnum<
-  typeof PaymentStatus
-> = PaymentStatus$inboundSchema;
+export const PaymentStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PaymentStatus
+> = openEnums.outboundSchema(PaymentStatus);

package/src/models/components/paymenttype.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * Type of payment
@@ -21,11 +22,17 @@ export const PaymentType = {
 /**
  * Type of payment
  */
-export type PaymentType = ClosedEnum<typeof PaymentType>;
+export type PaymentType = OpenEnum<typeof PaymentType>;
 
 /** @internal */
-export const PaymentType$inboundSchema: z.ZodNativeEnum<typeof PaymentType> = z
-  .nativeEnum(PaymentType);
+export const PaymentType$inboundSchema: z.ZodType<
+  PaymentType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PaymentType);
 /** @internal */
-export const PaymentType$outboundSchema: z.ZodNativeEnum<typeof PaymentType> =
-  PaymentType$inboundSchema;
+export const PaymentType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PaymentType
+> = openEnums.outboundSchema(PaymentType);

package/src/models/components/paymentunit.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * Unit of measurement for employee compensation.
@@ -19,11 +20,17 @@ export const PaymentUnit = {
 /**
  * Unit of measurement for employee compensation.
  */
-export type PaymentUnit = ClosedEnum<typeof PaymentUnit>;
+export type PaymentUnit = OpenEnum<typeof PaymentUnit>;
 
 /** @internal */
-export const PaymentUnit$inboundSchema: z.ZodNativeEnum<typeof PaymentUnit> = z
-  .nativeEnum(PaymentUnit);
+export const PaymentUnit$inboundSchema: z.ZodType<
+  PaymentUnit,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PaymentUnit);
 /** @internal */
-export const PaymentUnit$outboundSchema: z.ZodNativeEnum<typeof PaymentUnit> =
-  PaymentUnit$inboundSchema;
+export const PaymentUnit$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PaymentUnit
+> = openEnums.outboundSchema(PaymentUnit);

package/src/models/components/phonenumber.ts

@@ -5,7 +5,8 @@
 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -29,7 +30,7 @@ export const PhoneNumberType = {
 /**
  * The type of phone number
  */
-export type PhoneNumberType = ClosedEnum<typeof PhoneNumberType>;
+export type PhoneNumberType = OpenEnum<typeof PhoneNumberType>;
 
 export type PhoneNumber = {
   /**
@@ -59,13 +60,17 @@ export type PhoneNumber = {
 };
 
 /** @internal */
-export const PhoneNumberType$inboundSchema: z.ZodNativeEnum<
-  typeof PhoneNumberType
-> = z.nativeEnum(PhoneNumberType);
+export const PhoneNumberType$inboundSchema: z.ZodType<
+  PhoneNumberType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PhoneNumberType);
 /** @internal */
-export const PhoneNumberType$outboundSchema: z.ZodNativeEnum<
-  typeof PhoneNumberType
-> = PhoneNumberType$inboundSchema;
+export const PhoneNumberType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PhoneNumberType
+> = openEnums.outboundSchema(PhoneNumberType);
 
 /** @internal */
 export const PhoneNumber$inboundSchema: z.ZodType<

package/src/models/components/profitandlossfilter.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * The accounting method used for the report: cash or accrual.
@@ -16,7 +17,7 @@ export const ProfitAndLossFilterAccountingMethod = {
 /**
  * The accounting method used for the report: cash or accrual.
  */
-export type ProfitAndLossFilterAccountingMethod = ClosedEnum<
+export type ProfitAndLossFilterAccountingMethod = OpenEnum<
   typeof ProfitAndLossFilterAccountingMethod
 >;
 
@@ -44,10 +45,11 @@ export type ProfitAndLossFilter = {
 };
 
 /** @internal */
-export const ProfitAndLossFilterAccountingMethod$outboundSchema:
-  z.ZodNativeEnum<typeof ProfitAndLossFilterAccountingMethod> = z.nativeEnum(
-    ProfitAndLossFilterAccountingMethod,
-  );
+export const ProfitAndLossFilterAccountingMethod$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProfitAndLossFilterAccountingMethod
+> = openEnums.outboundSchema(ProfitAndLossFilterAccountingMethod);
 
 /** @internal */
 export type ProfitAndLossFilter$Outbound = {

package/src/models/components/profitandlosstype.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * The type of profit and loss
@@ -15,9 +16,11 @@ export const ProfitAndLossType = {
 /**
  * The type of profit and loss
  */
-export type ProfitAndLossType = ClosedEnum<typeof ProfitAndLossType>;
+export type ProfitAndLossType = OpenEnum<typeof ProfitAndLossType>;
 
 /** @internal */
-export const ProfitAndLossType$inboundSchema: z.ZodNativeEnum<
-  typeof ProfitAndLossType
-> = z.nativeEnum(ProfitAndLossType);
+export const ProfitAndLossType$inboundSchema: z.ZodType<
+  ProfitAndLossType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ProfitAndLossType);

package/src/models/components/project.ts

@@ -5,7 +5,8 @@
 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 { RFCDate } from "../../types/rfcdate.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -64,7 +65,7 @@ export const ProjectProjectStatus = {
 /**
  * Current status of the project
  */
-export type ProjectProjectStatus = ClosedEnum<typeof ProjectProjectStatus>;
+export type ProjectProjectStatus = OpenEnum<typeof ProjectProjectStatus>;
 
 /**
  * Type or category of the project
@@ -80,7 +81,7 @@ export const ProjectType = {
 /**
  * Type or category of the project
  */
-export type ProjectType = ClosedEnum<typeof ProjectType>;
+export type ProjectType = OpenEnum<typeof ProjectType>;
 
 /**
  * Priority level of the project
@@ -94,7 +95,7 @@ export const Priority = {
 /**
  * Priority level of the project
  */
-export type Priority = ClosedEnum<typeof Priority>;
+export type Priority = OpenEnum<typeof Priority>;
 
 /**
  * Department or organizational unit associated with the project
@@ -137,7 +138,7 @@ export const BillingMethod = {
 /**
  * Method used for billing this project
  */
-export type BillingMethod = ClosedEnum<typeof BillingMethod>;
+export type BillingMethod = OpenEnum<typeof BillingMethod>;
 
 /**
  * Current phase of the project lifecycle
@@ -153,7 +154,7 @@ export const ProjectPhase = {
 /**
  * Current phase of the project lifecycle
  */
-export type ProjectPhase = ClosedEnum<typeof ProjectPhase>;
+export type ProjectPhase = OpenEnum<typeof ProjectPhase>;
 
 /**
  * Current status of project schedule compared to plan
@@ -167,7 +168,7 @@ export const ScheduleStatus = {
 /**
  * Current status of project schedule compared to plan
  */
-export type ScheduleStatus = ClosedEnum<typeof ScheduleStatus>;
+export type ScheduleStatus = OpenEnum<typeof ScheduleStatus>;
 
 export type Project = {
   /**
@@ -277,7 +278,7 @@ export type Project = {
   /**
    * Indicates if the project is billable to the customer
    */
-  isBillable?: boolean | null | undefined;
+  isBillable: boolean | null;
   /**
    * Current phase of the project lifecycle
    */
@@ -476,27 +477,43 @@ export type ProjectInput = {
 };
 
 /** @internal */
-export const ProjectProjectStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ProjectProjectStatus
-> = z.nativeEnum(ProjectProjectStatus);
+export const ProjectProjectStatus$inboundSchema: z.ZodType<
+  ProjectProjectStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ProjectProjectStatus);
 /** @internal */
-export const ProjectProjectStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ProjectProjectStatus
-> = ProjectProjectStatus$inboundSchema;
+export const ProjectProjectStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProjectProjectStatus
+> = openEnums.outboundSchema(ProjectProjectStatus);
 
 /** @internal */
-export const ProjectType$inboundSchema: z.ZodNativeEnum<typeof ProjectType> = z
-  .nativeEnum(ProjectType);
+export const ProjectType$inboundSchema: z.ZodType<
+  ProjectType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ProjectType);
 /** @internal */
-export const ProjectType$outboundSchema: z.ZodNativeEnum<typeof ProjectType> =
-  ProjectType$inboundSchema;
+export const ProjectType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProjectType
+> = openEnums.outboundSchema(ProjectType);
 
 /** @internal */
-export const Priority$inboundSchema: z.ZodNativeEnum<typeof Priority> = z
-  .nativeEnum(Priority);
+export const Priority$inboundSchema: z.ZodType<
+  Priority,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Priority);
 /** @internal */
-export const Priority$outboundSchema: z.ZodNativeEnum<typeof Priority> =
-  Priority$inboundSchema;
+export const Priority$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  Priority
+> = openEnums.outboundSchema(Priority);
 
 /** @internal */
 export const ProjectDepartment$inboundSchema: z.ZodType<
@@ -579,29 +596,43 @@ export function parentProjectFromJSON(
 }
 
 /** @internal */
-export const BillingMethod$inboundSchema: z.ZodNativeEnum<
-  typeof BillingMethod
-> = z.nativeEnum(BillingMethod);
+export const BillingMethod$inboundSchema: z.ZodType<
+  BillingMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(BillingMethod);
 /** @internal */
-export const BillingMethod$outboundSchema: z.ZodNativeEnum<
-  typeof BillingMethod
-> = BillingMethod$inboundSchema;
+export const BillingMethod$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  BillingMethod
+> = openEnums.outboundSchema(BillingMethod);
 
 /** @internal */
-export const ProjectPhase$inboundSchema: z.ZodNativeEnum<typeof ProjectPhase> =
-  z.nativeEnum(ProjectPhase);
+export const ProjectPhase$inboundSchema: z.ZodType<
+  ProjectPhase,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ProjectPhase);
 /** @internal */
-export const ProjectPhase$outboundSchema: z.ZodNativeEnum<typeof ProjectPhase> =
-  ProjectPhase$inboundSchema;
+export const ProjectPhase$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProjectPhase
+> = openEnums.outboundSchema(ProjectPhase);
 
 /** @internal */
-export const ScheduleStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ScheduleStatus
-> = z.nativeEnum(ScheduleStatus);
+export const ScheduleStatus$inboundSchema: z.ZodType<
+  ScheduleStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ScheduleStatus);
 /** @internal */
-export const ScheduleStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ScheduleStatus
-> = ScheduleStatus$inboundSchema;
+export const ScheduleStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ScheduleStatus
+> = openEnums.outboundSchema(ScheduleStatus);
 
 /** @internal */
 export const Project$inboundSchema: z.ZodType<Project, z.ZodTypeDef, unknown> =

package/src/models/components/projectsfilter.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * Status of projects to filter by
@@ -19,7 +20,7 @@ export const ProjectStatus = {
 /**
  * Status of projects to filter by
  */
-export type ProjectStatus = ClosedEnum<typeof ProjectStatus>;
+export type ProjectStatus = OpenEnum<typeof ProjectStatus>;
 
 export type ProjectsFilter = {
   /**
@@ -41,9 +42,11 @@ export type ProjectsFilter = {
 };
 
 /** @internal */
-export const ProjectStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ProjectStatus
-> = z.nativeEnum(ProjectStatus);
+export const ProjectStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProjectStatus
+> = openEnums.outboundSchema(ProjectStatus);
 
 /** @internal */
 export type ProjectsFilter$Outbound = {

package/src/models/components/projectssort.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import {
   SortDirection,
   SortDirection$outboundSchema,
@@ -25,7 +26,7 @@ export const ProjectsSortSortBy = {
 /**
  * The field to sort by
  */
-export type ProjectsSortSortBy = ClosedEnum<typeof ProjectsSortSortBy>;
+export type ProjectsSortSortBy = OpenEnum<typeof ProjectsSortSortBy>;
 
 export type ProjectsSort = {
   /**
@@ -39,9 +40,11 @@ export type ProjectsSort = {
 };
 
 /** @internal */
-export const ProjectsSortSortBy$outboundSchema: z.ZodNativeEnum<
-  typeof ProjectsSortSortBy
-> = z.nativeEnum(ProjectsSortSortBy);
+export const ProjectsSortSortBy$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ProjectsSortSortBy
+> = openEnums.outboundSchema(ProjectsSortSortBy);
 
 /** @internal */
 export type ProjectsSort$Outbound = {