@maesn/typescript-sdk 0.6.0 → 0.6.2

package/src/models/offer-response-dto.ts

@@ -4,8 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { AddressOffer, AddressOffer$inboundSchema } from "./address-offer.js";
@@ -23,7 +22,7 @@ export const OfferResponseDtoStatus = {
   Voided: "VOIDED",
   Declined: "DECLINED",
 } as const;
-export type OfferResponseDtoStatus = OpenEnum<typeof OfferResponseDtoStatus>;
+export type OfferResponseDtoStatus = ClosedEnum<typeof OfferResponseDtoStatus>;
 
 export type OfferResponseDto = {
   id: string | null;
@@ -48,10 +47,9 @@ export type OfferResponseDto = {
 };
 
 /** @internal */
-export const OfferResponseDtoStatus$inboundSchema: z.ZodMiniType<
-  OfferResponseDtoStatus,
-  unknown
-> = openEnums.inboundSchema(OfferResponseDtoStatus);
+export const OfferResponseDtoStatus$inboundSchema: z.ZodMiniEnum<
+  typeof OfferResponseDtoStatus
+> = z.enum(OfferResponseDtoStatus);
 
 /** @internal */
 export const OfferResponseDto$inboundSchema: z.ZodMiniType<

package/src/models/open-item-entry-response-dto.ts

@@ -4,8 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
@@ -14,7 +13,7 @@ export const OpenItemEntryResponseDtoDebitCreditIndicator = {
   Debit: "DEBIT",
   Credit: "CREDIT",
 } as const;
-export type OpenItemEntryResponseDtoDebitCreditIndicator = OpenEnum<
+export type OpenItemEntryResponseDtoDebitCreditIndicator = ClosedEnum<
   typeof OpenItemEntryResponseDtoDebitCreditIndicator
 >;
 
@@ -29,8 +28,9 @@ export type OpenItemEntryResponseDto = {
 
 /** @internal */
 export const OpenItemEntryResponseDtoDebitCreditIndicator$inboundSchema:
-  z.ZodMiniType<OpenItemEntryResponseDtoDebitCreditIndicator, unknown> =
-    openEnums.inboundSchema(OpenItemEntryResponseDtoDebitCreditIndicator);
+  z.ZodMiniEnum<typeof OpenItemEntryResponseDtoDebitCreditIndicator> = z.enum(
+    OpenItemEntryResponseDtoDebitCreditIndicator,
+  );
 
 /** @internal */
 export const OpenItemEntryResponseDto$inboundSchema: z.ZodMiniType<

package/src/models/open-item-response-dto.ts

@@ -4,8 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
@@ -18,7 +17,7 @@ export const OpenItemResponseDtoDebitCreditIndicator = {
   Debit: "DEBIT",
   Credit: "CREDIT",
 } as const;
-export type OpenItemResponseDtoDebitCreditIndicator = OpenEnum<
+export type OpenItemResponseDtoDebitCreditIndicator = ClosedEnum<
   typeof OpenItemResponseDtoDebitCreditIndicator
 >;
 
@@ -31,7 +30,9 @@ export const OpenItemResponseDtoType = {
   Bill: "BILL",
   Invoice: "INVOICE",
 } as const;
-export type OpenItemResponseDtoType = OpenEnum<typeof OpenItemResponseDtoType>;
+export type OpenItemResponseDtoType = ClosedEnum<
+  typeof OpenItemResponseDtoType
+>;
 
 export type OpenItemResponseDto = {
   id: string | null;
@@ -52,8 +53,9 @@ export type OpenItemResponseDto = {
 
 /** @internal */
 export const OpenItemResponseDtoDebitCreditIndicator$inboundSchema:
-  z.ZodMiniType<OpenItemResponseDtoDebitCreditIndicator, unknown> = openEnums
-    .inboundSchema(OpenItemResponseDtoDebitCreditIndicator);
+  z.ZodMiniEnum<typeof OpenItemResponseDtoDebitCreditIndicator> = z.enum(
+    OpenItemResponseDtoDebitCreditIndicator,
+  );
 
 /** @internal */
 export const OpenBalance$inboundSchema: z.ZodMiniType<OpenBalance, unknown> = z
@@ -75,10 +77,9 @@ export function openBalanceFromJSON(
 }
 
 /** @internal */
-export const OpenItemResponseDtoType$inboundSchema: z.ZodMiniType<
-  OpenItemResponseDtoType,
-  unknown
-> = openEnums.inboundSchema(OpenItemResponseDtoType);
+export const OpenItemResponseDtoType$inboundSchema: z.ZodMiniEnum<
+  typeof OpenItemResponseDtoType
+> = z.enum(OpenItemResponseDtoType);
 
 /** @internal */
 export const OpenItemResponseDto$inboundSchema: z.ZodMiniType<

package/src/models/operations/create-booking-proposal-v2.ts

@@ -4,8 +4,10 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
@@ -19,6 +21,16 @@ export type CreateBookingProposalV2File = {
   content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
 };
 
+export const CreateBookingProposalV2BookingType = {
+  Invoice: "INVOICE",
+  Bill: "BILL",
+  CreditNote: "CREDIT_NOTE",
+  VendorCredit: "VENDOR_CREDIT",
+} as const;
+export type CreateBookingProposalV2BookingType = ClosedEnum<
+  typeof CreateBookingProposalV2BookingType
+>;
+
 export type CreateBookingProposalV2FolderManagement = {
   category?: string | undefined;
   folder?: string | undefined;
@@ -27,7 +39,7 @@ export type CreateBookingProposalV2FolderManagement = {
 
 export type CreateBookingProposalV2RequestBody = {
   files?: Array<CreateBookingProposalV2File> | undefined;
-  bookingType?: string | undefined;
+  bookingType?: CreateBookingProposalV2BookingType | undefined;
   bookingProposal?: models.CreateBookingProposalRequestDtoV2 | undefined;
   folderManagement?: CreateBookingProposalV2FolderManagement | undefined;
 };
@@ -48,32 +60,62 @@ export type CreateBookingProposalV2Request = {
   body: CreateBookingProposalV2RequestBody;
 };
 
-export type CreateBookingProposalV2Pagination = {
+export type CreateBookingProposalV2Pagination2 = {
   total: number;
   perPage: number;
   currentPage: number;
   totalPages: number;
 };
 
-export type CreateBookingProposalV2Meta = {
+export type CreateBookingProposalV2Meta2 = {
   warnings?: Array<string> | null | undefined;
-  pagination?: CreateBookingProposalV2Pagination | null | undefined;
+  pagination?: CreateBookingProposalV2Pagination2 | null | undefined;
 };
 
-export type CreateBookingProposalV2Errors = {};
+export type CreateBookingProposalV2Errors2 = {};
 
-export type CreateBookingProposalV2RawData = {};
+export type CreateBookingProposalV2RawData2 = {};
 
 /**
  * Booking proposal queued successfully. Processed asynchronously and returns 202 with taskId.
  */
-export type CreateBookingProposalV2Response = {
-  meta?: CreateBookingProposalV2Meta | null | undefined;
+export type CreateBookingProposalV2ResponseBody2 = {
+  meta?: CreateBookingProposalV2Meta2 | null | undefined;
   data: models.TaskIdResponseDto;
-  errors: CreateBookingProposalV2Errors | null;
-  rawData: CreateBookingProposalV2RawData | null;
+  errors: CreateBookingProposalV2Errors2 | null;
+  rawData: CreateBookingProposalV2RawData2 | null;
 };
 
+export type CreateBookingProposalV2Pagination1 = {
+  total: number;
+  perPage: number;
+  currentPage: number;
+  totalPages: number;
+};
+
+export type CreateBookingProposalV2Meta1 = {
+  warnings?: Array<string> | null | undefined;
+  pagination?: CreateBookingProposalV2Pagination1 | null | undefined;
+};
+
+export type CreateBookingProposalV2Errors1 = {};
+
+export type CreateBookingProposalV2RawData1 = {};
+
+/**
+ * Booking proposal created successfully (synchronous).
+ */
+export type CreateBookingProposalV2ResponseBody1 = {
+  meta?: CreateBookingProposalV2Meta1 | null | undefined;
+  data: models.BookingProposalResponseDtoV2;
+  errors: CreateBookingProposalV2Errors1 | null;
+  rawData: CreateBookingProposalV2RawData1 | null;
+};
+
+export type CreateBookingProposalV2Response =
+  | CreateBookingProposalV2ResponseBody1
+  | CreateBookingProposalV2ResponseBody2;
+
 /** @internal */
 export type CreateBookingProposalV2File$Outbound = {
   fileName: string;
@@ -104,6 +146,11 @@ export function createBookingProposalV2FileToJSON(
   );
 }
 
+/** @internal */
+export const CreateBookingProposalV2BookingType$outboundSchema: z.ZodMiniEnum<
+  typeof CreateBookingProposalV2BookingType
+> = z.enum(CreateBookingProposalV2BookingType);
+
 /** @internal */
 export type CreateBookingProposalV2FolderManagement$Outbound = {
   category?: string | undefined;
@@ -153,7 +200,7 @@ export const CreateBookingProposalV2RequestBody$outboundSchema: z.ZodMiniType<
   files: z.optional(
     z.array(z.lazy(() => CreateBookingProposalV2File$outboundSchema)),
   ),
-  bookingType: z.optional(z.string()),
+  bookingType: z.optional(CreateBookingProposalV2BookingType$outboundSchema),
   bookingProposal: z.optional(
     models.CreateBookingProposalRequestDtoV2$outboundSchema,
   ),
@@ -202,8 +249,8 @@ export function createBookingProposalV2RequestToJSON(
 }
 
 /** @internal */
-export const CreateBookingProposalV2Pagination$inboundSchema: z.ZodMiniType<
-  CreateBookingProposalV2Pagination,
+export const CreateBookingProposalV2Pagination2$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Pagination2,
   unknown
 > = z.object({
   total: types.number(),
@@ -212,86 +259,210 @@ export const CreateBookingProposalV2Pagination$inboundSchema: z.ZodMiniType<
   totalPages: types.number(),
 });
 
-export function createBookingProposalV2PaginationFromJSON(
+export function createBookingProposalV2Pagination2FromJSON(
   jsonString: string,
-): SafeParseResult<CreateBookingProposalV2Pagination, SDKValidationError> {
+): SafeParseResult<CreateBookingProposalV2Pagination2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CreateBookingProposalV2Pagination$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateBookingProposalV2Pagination' from JSON`,
+    (x) =>
+      CreateBookingProposalV2Pagination2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Pagination2' from JSON`,
   );
 }
 
 /** @internal */
-export const CreateBookingProposalV2Meta$inboundSchema: z.ZodMiniType<
-  CreateBookingProposalV2Meta,
+export const CreateBookingProposalV2Meta2$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Meta2,
   unknown
 > = z.object({
   warnings: z.optional(z.nullable(z.array(types.string()))),
   pagination: z.optional(
-    z.nullable(z.lazy(() => CreateBookingProposalV2Pagination$inboundSchema)),
+    z.nullable(z.lazy(() => CreateBookingProposalV2Pagination2$inboundSchema)),
   ),
 });
 
-export function createBookingProposalV2MetaFromJSON(
+export function createBookingProposalV2Meta2FromJSON(
   jsonString: string,
-): SafeParseResult<CreateBookingProposalV2Meta, SDKValidationError> {
+): SafeParseResult<CreateBookingProposalV2Meta2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CreateBookingProposalV2Meta$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateBookingProposalV2Meta' from JSON`,
+    (x) => CreateBookingProposalV2Meta2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Meta2' from JSON`,
   );
 }
 
 /** @internal */
-export const CreateBookingProposalV2Errors$inboundSchema: z.ZodMiniType<
-  CreateBookingProposalV2Errors,
+export const CreateBookingProposalV2Errors2$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Errors2,
   unknown
 > = z.object({});
 
-export function createBookingProposalV2ErrorsFromJSON(
+export function createBookingProposalV2Errors2FromJSON(
   jsonString: string,
-): SafeParseResult<CreateBookingProposalV2Errors, SDKValidationError> {
+): SafeParseResult<CreateBookingProposalV2Errors2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CreateBookingProposalV2Errors$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateBookingProposalV2Errors' from JSON`,
+    (x) => CreateBookingProposalV2Errors2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Errors2' from JSON`,
   );
 }
 
 /** @internal */
-export const CreateBookingProposalV2RawData$inboundSchema: z.ZodMiniType<
-  CreateBookingProposalV2RawData,
+export const CreateBookingProposalV2RawData2$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2RawData2,
   unknown
 > = z.object({});
 
-export function createBookingProposalV2RawDataFromJSON(
+export function createBookingProposalV2RawData2FromJSON(
   jsonString: string,
-): SafeParseResult<CreateBookingProposalV2RawData, SDKValidationError> {
+): SafeParseResult<CreateBookingProposalV2RawData2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CreateBookingProposalV2RawData$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateBookingProposalV2RawData' from JSON`,
+    (x) => CreateBookingProposalV2RawData2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2RawData2' from JSON`,
   );
 }
 
 /** @internal */
-export const CreateBookingProposalV2Response$inboundSchema: z.ZodMiniType<
-  CreateBookingProposalV2Response,
+export const CreateBookingProposalV2ResponseBody2$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2ResponseBody2,
   unknown
 > = z.object({
   meta: z.optional(
-    z.nullable(z.lazy(() => CreateBookingProposalV2Meta$inboundSchema)),
+    z.nullable(z.lazy(() => CreateBookingProposalV2Meta2$inboundSchema)),
   ),
   data: models.TaskIdResponseDto$inboundSchema,
   errors: types.nullable(
-    z.lazy(() => CreateBookingProposalV2Errors$inboundSchema),
+    z.lazy(() => CreateBookingProposalV2Errors2$inboundSchema),
   ),
   rawData: types.nullable(
-    z.lazy(() => CreateBookingProposalV2RawData$inboundSchema),
+    z.lazy(() => CreateBookingProposalV2RawData2$inboundSchema),
   ),
 });
 
+export function createBookingProposalV2ResponseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2ResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateBookingProposalV2ResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2ResponseBody2' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2Pagination1$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Pagination1,
+  unknown
+> = z.object({
+  total: types.number(),
+  perPage: types.number(),
+  currentPage: types.number(),
+  totalPages: types.number(),
+});
+
+export function createBookingProposalV2Pagination1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2Pagination1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateBookingProposalV2Pagination1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Pagination1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2Meta1$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Meta1,
+  unknown
+> = z.object({
+  warnings: z.optional(z.nullable(z.array(types.string()))),
+  pagination: z.optional(
+    z.nullable(z.lazy(() => CreateBookingProposalV2Pagination1$inboundSchema)),
+  ),
+});
+
+export function createBookingProposalV2Meta1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2Meta1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBookingProposalV2Meta1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Meta1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2Errors1$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Errors1,
+  unknown
+> = z.object({});
+
+export function createBookingProposalV2Errors1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2Errors1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBookingProposalV2Errors1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2Errors1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2RawData1$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2RawData1,
+  unknown
+> = z.object({});
+
+export function createBookingProposalV2RawData1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2RawData1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBookingProposalV2RawData1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2RawData1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2ResponseBody1$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2ResponseBody1,
+  unknown
+> = z.object({
+  meta: z.optional(
+    z.nullable(z.lazy(() => CreateBookingProposalV2Meta1$inboundSchema)),
+  ),
+  data: models.BookingProposalResponseDtoV2$inboundSchema,
+  errors: types.nullable(
+    z.lazy(() => CreateBookingProposalV2Errors1$inboundSchema),
+  ),
+  rawData: types.nullable(
+    z.lazy(() => CreateBookingProposalV2RawData1$inboundSchema),
+  ),
+});
+
+export function createBookingProposalV2ResponseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBookingProposalV2ResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateBookingProposalV2ResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBookingProposalV2ResponseBody1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBookingProposalV2Response$inboundSchema: z.ZodMiniType<
+  CreateBookingProposalV2Response,
+  unknown
+> = smartUnion([
+  z.lazy(() => CreateBookingProposalV2ResponseBody1$inboundSchema),
+  z.lazy(() => CreateBookingProposalV2ResponseBody2$inboundSchema),
+]);
+
 export function createBookingProposalV2ResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<CreateBookingProposalV2Response, SDKValidationError> {

package/src/models/operations/get-booking-proposals.ts

@@ -29,7 +29,7 @@ export type GetBookingProposalsLimit = ClosedEnum<
 /**
  * Filter booking proposals by booking type
  */
-export const BookingType = {
+export const GetBookingProposalsBookingType = {
   Invoice: "INVOICE",
   Bill: "BILL",
   CreditNote: "CREDIT_NOTE",
@@ -43,7 +43,9 @@ export const BookingType = {
 /**
  * Filter booking proposals by booking type
  */
-export type BookingType = ClosedEnum<typeof BookingType>;
+export type GetBookingProposalsBookingType = ClosedEnum<
+  typeof GetBookingProposalsBookingType
+>;
 
 /**
  * Filter booking proposals by status
@@ -114,7 +116,7 @@ export type GetBookingProposalsRequest = {
   /**
    * Filter booking proposals by booking type
    */
-  bookingType?: BookingType | undefined;
+  bookingType?: GetBookingProposalsBookingType | undefined;
   /**
    * Filter booking proposals by status
    */
@@ -173,8 +175,9 @@ export const GetBookingProposalsLimit$outboundSchema: z.ZodMiniEnum<
 > = z.enum(GetBookingProposalsLimit);
 
 /** @internal */
-export const BookingType$outboundSchema: z.ZodMiniEnum<typeof BookingType> = z
-  .enum(BookingType);
+export const GetBookingProposalsBookingType$outboundSchema: z.ZodMiniEnum<
+  typeof GetBookingProposalsBookingType
+> = z.enum(GetBookingProposalsBookingType);
 
 /** @internal */
 export const GetBookingProposalsStatus$outboundSchema: z.ZodMiniEnum<
@@ -217,7 +220,7 @@ export const GetBookingProposalsRequest$outboundSchema: z.ZodMiniType<
   lastModifiedAt: z.optional(z.string()),
   environmentName: z.optional(z.string()),
   companyId: z.optional(z.string()),
-  bookingType: z.optional(BookingType$outboundSchema),
+  bookingType: z.optional(GetBookingProposalsBookingType$outboundSchema),
   status: z.optional(GetBookingProposalsStatus$outboundSchema),
   rawData: z.optional(z.boolean()),
   orderField: z.optional(GetBookingProposalsOrderField$outboundSchema),