@crevio/sdk 0.3.2 → 0.4.2

package/src/models/cartupdaterequest.ts

@@ -5,23 +5,15 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 
-export type CartItemsAttribute = {
-  /**
-   * Existing item ID (for update/delete)
-   */
-  id?: number | undefined;
-  priceVariantId?: number | undefined;
+export type CartUpdateRequestCartItemsAttribute = {
+  priceVariant?: string | undefined;
   quantity?: number | undefined;
-  customAmount?: number | undefined;
-  /**
-   * Set to true to remove item
-   */
+  customAmount?: number | null | undefined;
   destroy?: boolean | undefined;
 };
 
 export type CartUpdateRequestCart = {
-  customerId?: number | undefined;
-  cartItemsAttributes?: Array<CartItemsAttribute> | undefined;
+  cartItemsAttributes?: Array<CartUpdateRequestCartItemsAttribute> | undefined;
 };
 
 export type CartUpdateRequest = {
@@ -29,45 +21,46 @@ export type CartUpdateRequest = {
 };
 
 /** @internal */
-export type CartItemsAttribute$Outbound = {
-  id?: number | undefined;
-  price_variant_id?: number | undefined;
+export type CartUpdateRequestCartItemsAttribute$Outbound = {
+  price_variant?: string | undefined;
   quantity?: number | undefined;
-  custom_amount?: number | undefined;
+  custom_amount?: number | null | undefined;
   _destroy?: boolean | undefined;
 };
 
 /** @internal */
-export const CartItemsAttribute$outboundSchema: z.ZodType<
-  CartItemsAttribute$Outbound,
+export const CartUpdateRequestCartItemsAttribute$outboundSchema: z.ZodType<
+  CartUpdateRequestCartItemsAttribute$Outbound,
   z.ZodTypeDef,
-  CartItemsAttribute
+  CartUpdateRequestCartItemsAttribute
 > = z.object({
-  id: z.number().int().optional(),
-  priceVariantId: z.number().int().optional(),
+  priceVariant: z.string().optional(),
   quantity: z.number().int().optional(),
-  customAmount: z.number().int().optional(),
+  customAmount: z.nullable(z.number().int()).optional(),
   destroy: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
-    priceVariantId: "price_variant_id",
+    priceVariant: "price_variant",
     customAmount: "custom_amount",
     destroy: "_destroy",
   });
 });
 
-export function cartItemsAttributeToJSON(
-  cartItemsAttribute: CartItemsAttribute,
+export function cartUpdateRequestCartItemsAttributeToJSON(
+  cartUpdateRequestCartItemsAttribute: CartUpdateRequestCartItemsAttribute,
 ): string {
   return JSON.stringify(
-    CartItemsAttribute$outboundSchema.parse(cartItemsAttribute),
+    CartUpdateRequestCartItemsAttribute$outboundSchema.parse(
+      cartUpdateRequestCartItemsAttribute,
+    ),
   );
 }
 
 /** @internal */
 export type CartUpdateRequestCart$Outbound = {
-  customer_id?: number | undefined;
-  cart_items_attributes?: Array<CartItemsAttribute$Outbound> | undefined;
+  cart_items_attributes?:
+    | Array<CartUpdateRequestCartItemsAttribute$Outbound>
+    | undefined;
 };
 
 /** @internal */
@@ -76,12 +69,11 @@ export const CartUpdateRequestCart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CartUpdateRequestCart
 > = z.object({
-  customerId: z.number().int().optional(),
-  cartItemsAttributes: z.array(z.lazy(() => CartItemsAttribute$outboundSchema))
-    .optional(),
+  cartItemsAttributes: z.array(
+    z.lazy(() => CartUpdateRequestCartItemsAttribute$outboundSchema),
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
-    customerId: "customer_id",
     cartItemsAttributes: "cart_items_attributes",
   });
 });

package/src/models/checkout.ts

@@ -5,56 +5,59 @@
 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 { Result as SafeParseResult } from "../types/fp.js";
-import { AccountSlim, AccountSlim$inboundSchema } from "./accountslim.js";
 import { CheckoutItem, CheckoutItem$inboundSchema } from "./checkoutitem.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export const CheckoutStatus = {
+  Open: "open",
+  Complete: "complete",
+  Abandoned: "abandoned",
+  Expired: "expired",
+} as const;
+export type CheckoutStatus = ClosedEnum<typeof CheckoutStatus>;
+
 export type Checkout = {
-  id?: number | undefined;
-  status?: string | undefined;
-  processorId?: string | null | undefined;
-  clientSecret?: string | null | undefined;
-  prefixId?: string | undefined;
-  mode?: string | undefined;
-  currency?: string | undefined;
-  /**
-   * Total in cents
-   */
-  total?: number | undefined;
-  isFree?: boolean | undefined;
-  prefilledEmail?: string | null | undefined;
-  checkoutItems?: Array<CheckoutItem> | undefined;
-  sellerAccount?: AccountSlim | undefined;
+  id: string;
+  object: string;
+  status: CheckoutStatus;
+  createdAt: Date;
+  updatedAt: Date;
+  mode: string;
+  currency: string | null;
+  total: number;
+  clientSecret: string | null;
+  checkoutItems: Array<CheckoutItem>;
 };
 
+/** @internal */
+export const CheckoutStatus$inboundSchema: z.ZodNativeEnum<
+  typeof CheckoutStatus
+> = z.nativeEnum(CheckoutStatus);
+
 /** @internal */
 export const Checkout$inboundSchema: z.ZodType<
   Checkout,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  status: z.string().optional(),
-  processor_id: z.nullable(z.string()).optional(),
-  client_secret: z.nullable(z.string()).optional(),
-  prefix_id: z.string().optional(),
-  mode: z.string().optional(),
-  currency: z.string().optional(),
-  total: z.number().int().optional(),
-  is_free: z.boolean().optional(),
-  prefilled_email: z.nullable(z.string()).optional(),
-  checkout_items: z.array(CheckoutItem$inboundSchema).optional(),
-  seller_account: AccountSlim$inboundSchema.optional(),
+  id: z.string(),
+  object: z.string(),
+  status: CheckoutStatus$inboundSchema,
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  mode: z.string(),
+  currency: z.nullable(z.string()),
+  total: z.number(),
+  client_secret: z.nullable(z.string()),
+  checkout_items: z.array(CheckoutItem$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
-    "processor_id": "processorId",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
     "client_secret": "clientSecret",
-    "prefix_id": "prefixId",
-    "is_free": "isFree",
-    "prefilled_email": "prefilledEmail",
     "checkout_items": "checkoutItems",
-    "seller_account": "sellerAccount",
   });
 });
 

package/src/models/checkoutcreaterequest.ts

@@ -5,21 +5,19 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 
-export type CheckoutItemsAttribute = {
-  priceVariantId: number;
+export type LineItem = {
+  priceVariant: string;
   quantity?: number | undefined;
-  /**
-   * Custom amount in cents (pay-what-you-want)
-   */
-  customAmount?: number | undefined;
 };
 
 export type CheckoutCreateRequestCheckout = {
-  email?: string | undefined;
-  returnUrl?: string | undefined;
-  cancelUrl?: string | undefined;
-  discountCode?: string | undefined;
-  checkoutItemsAttributes: Array<CheckoutItemsAttribute>;
+  email?: string | null | undefined;
+  /**
+   * Customer prefix ID
+   */
+  customer?: string | null | undefined;
+  discountCode?: string | null | undefined;
+  lineItems?: Array<LineItem> | undefined;
 };
 
 export type CheckoutCreateRequest = {
@@ -27,43 +25,35 @@ export type CheckoutCreateRequest = {
 };
 
 /** @internal */
-export type CheckoutItemsAttribute$Outbound = {
-  price_variant_id: number;
+export type LineItem$Outbound = {
+  price_variant: string;
   quantity?: number | undefined;
-  custom_amount?: number | undefined;
 };
 
 /** @internal */
-export const CheckoutItemsAttribute$outboundSchema: z.ZodType<
-  CheckoutItemsAttribute$Outbound,
+export const LineItem$outboundSchema: z.ZodType<
+  LineItem$Outbound,
   z.ZodTypeDef,
-  CheckoutItemsAttribute
+  LineItem
 > = z.object({
-  priceVariantId: z.number().int(),
+  priceVariant: z.string(),
   quantity: z.number().int().optional(),
-  customAmount: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
-    priceVariantId: "price_variant_id",
-    customAmount: "custom_amount",
+    priceVariant: "price_variant",
   });
 });
 
-export function checkoutItemsAttributeToJSON(
-  checkoutItemsAttribute: CheckoutItemsAttribute,
-): string {
-  return JSON.stringify(
-    CheckoutItemsAttribute$outboundSchema.parse(checkoutItemsAttribute),
-  );
+export function lineItemToJSON(lineItem: LineItem): string {
+  return JSON.stringify(LineItem$outboundSchema.parse(lineItem));
 }
 
 /** @internal */
 export type CheckoutCreateRequestCheckout$Outbound = {
-  email?: string | undefined;
-  return_url?: string | undefined;
-  cancel_url?: string | undefined;
-  discount_code?: string | undefined;
-  checkout_items_attributes: Array<CheckoutItemsAttribute$Outbound>;
+  email?: string | null | undefined;
+  customer?: string | null | undefined;
+  discount_code?: string | null | undefined;
+  line_items?: Array<LineItem$Outbound> | undefined;
 };
 
 /** @internal */
@@ -72,19 +62,14 @@ export const CheckoutCreateRequestCheckout$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CheckoutCreateRequestCheckout
 > = z.object({
-  email: z.string().optional(),
-  returnUrl: z.string().optional(),
-  cancelUrl: z.string().optional(),
-  discountCode: z.string().optional(),
-  checkoutItemsAttributes: z.array(
-    z.lazy(() => CheckoutItemsAttribute$outboundSchema),
-  ),
+  email: z.nullable(z.string()).optional(),
+  customer: z.nullable(z.string()).optional(),
+  discountCode: z.nullable(z.string()).optional(),
+  lineItems: z.array(z.lazy(() => LineItem$outboundSchema)).optional(),
 }).transform((v) => {
   return remap$(v, {
-    returnUrl: "return_url",
-    cancelUrl: "cancel_url",
     discountCode: "discount_code",
-    checkoutItemsAttributes: "checkout_items_attributes",
+    lineItems: "line_items",
   });
 });
 

package/src/models/checkoutitem.ts

@@ -7,12 +7,12 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { PriceVariant, PriceVariant$inboundSchema } from "./pricevariant.js";
 
 export type CheckoutItem = {
-  id?: number | undefined;
-  quantity?: number | undefined;
-  priceVariant?: PriceVariant | undefined;
+  object: string;
+  quantity: number;
+  priceVariant: string;
+  product: string | null;
 };
 
 /** @internal */
@@ -21,9 +21,10 @@ export const CheckoutItem$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  quantity: z.number().int().optional(),
-  price_variant: PriceVariant$inboundSchema.optional(),
+  object: z.string(),
+  quantity: z.number().int(),
+  price_variant: z.string(),
+  product: z.nullable(z.string()),
 }).transform((v) => {
   return remap$(v, {
     "price_variant": "priceVariant",

package/src/models/checkoutlink.ts

@@ -10,42 +10,65 @@ import { Discount, Discount$inboundSchema } from "./discount.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { PriceVariant, PriceVariant$inboundSchema } from "./pricevariant.js";
 
+/**
+ * Prefix ID by default, full object when expanded
+ */
+export type DiscountUnion = Discount | string;
+
 export type CheckoutLink = {
-  id?: number | undefined;
-  name?: string | undefined;
-  url?: string | undefined;
-  successUrl?: string | null | undefined;
-  allowDiscountCodes?: boolean | undefined;
-  prefixId?: string | undefined;
-  createdAt?: Date | undefined;
-  updatedAt?: Date | undefined;
-  discount?: Discount | undefined;
+  id: string;
+  object: string;
+  name: string | null;
+  successUrl: string | null;
+  allowDiscountCodes: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  url: string;
+  /**
+   * Prefix ID by default, full object when expanded
+   */
+  discount?: Discount | string | null | undefined;
   priceVariants?: Array<PriceVariant> | undefined;
 };
 
+/** @internal */
+export const DiscountUnion$inboundSchema: z.ZodType<
+  DiscountUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([Discount$inboundSchema, z.string()]);
+
+export function discountUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DiscountUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiscountUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiscountUnion' from JSON`,
+  );
+}
+
 /** @internal */
 export const CheckoutLink$inboundSchema: z.ZodType<
   CheckoutLink,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  name: z.string().optional(),
-  url: z.string().optional(),
-  success_url: z.nullable(z.string()).optional(),
-  allow_discount_codes: z.boolean().optional(),
-  prefix_id: z.string().optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+  id: z.string(),
+  object: z.string(),
+  name: z.nullable(z.string()),
+  success_url: z.nullable(z.string()),
+  allow_discount_codes: z.boolean(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  url: z.string(),
+  discount: z.nullable(z.union([Discount$inboundSchema, z.string()]))
     .optional(),
-  discount: Discount$inboundSchema.optional(),
   price_variants: z.array(PriceVariant$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "success_url": "successUrl",
     "allow_discount_codes": "allowDiscountCodes",
-    "prefix_id": "prefixId",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
     "price_variants": "priceVariants",

package/src/models/checkoutlinkrequest.ts

@@ -5,25 +5,46 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 
+export type Metadata = {};
+
 export type CheckoutLinkRequestCheckoutLink = {
-  name?: string | undefined;
-  discountId?: number | null | undefined;
+  name?: string | null | undefined;
+  /**
+   * Discount prefix ID
+   */
+  discount?: string | null | undefined;
   allowDiscountCodes?: boolean | undefined;
-  successUrl?: string | undefined;
-  priceVariantIds: Array<number>;
+  successUrl?: string | null | undefined;
+  metadata?: Metadata | null | undefined;
+  priceVariants?: Array<string> | undefined;
 };
 
 export type CheckoutLinkRequest = {
   checkoutLink: CheckoutLinkRequestCheckoutLink;
 };
 
+/** @internal */
+export type Metadata$Outbound = {};
+
+/** @internal */
+export const Metadata$outboundSchema: z.ZodType<
+  Metadata$Outbound,
+  z.ZodTypeDef,
+  Metadata
+> = z.object({});
+
+export function metadataToJSON(metadata: Metadata): string {
+  return JSON.stringify(Metadata$outboundSchema.parse(metadata));
+}
+
 /** @internal */
 export type CheckoutLinkRequestCheckoutLink$Outbound = {
-  name?: string | undefined;
-  discount_id?: number | null | undefined;
+  name?: string | null | undefined;
+  discount?: string | null | undefined;
   allow_discount_codes?: boolean | undefined;
-  success_url?: string | undefined;
-  price_variant_ids: Array<number>;
+  success_url?: string | null | undefined;
+  metadata?: Metadata$Outbound | null | undefined;
+  price_variants?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -32,17 +53,17 @@ export const CheckoutLinkRequestCheckoutLink$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CheckoutLinkRequestCheckoutLink
 > = z.object({
-  name: z.string().optional(),
-  discountId: z.nullable(z.number().int()).optional(),
+  name: z.nullable(z.string()).optional(),
+  discount: z.nullable(z.string()).optional(),
   allowDiscountCodes: z.boolean().optional(),
-  successUrl: z.string().optional(),
-  priceVariantIds: z.array(z.number().int()),
+  successUrl: z.nullable(z.string()).optional(),
+  metadata: z.nullable(z.lazy(() => Metadata$outboundSchema)).optional(),
+  priceVariants: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    discountId: "discount_id",
     allowDiscountCodes: "allow_discount_codes",
     successUrl: "success_url",
-    priceVariantIds: "price_variant_ids",
+    priceVariants: "price_variants",
   });
 });
 

package/src/models/checkoutupdaterequest.ts

@@ -6,8 +6,8 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 
 export type CheckoutUpdateRequestCheckout = {
-  email?: string | undefined;
-  discountCode?: string | undefined;
+  email?: string | null | undefined;
+  discountCode?: string | null | undefined;
 };
 
 export type CheckoutUpdateRequest = {
@@ -16,8 +16,8 @@ export type CheckoutUpdateRequest = {
 
 /** @internal */
 export type CheckoutUpdateRequestCheckout$Outbound = {
-  email?: string | undefined;
-  discount_code?: string | undefined;
+  email?: string | null | undefined;
+  discount_code?: string | null | undefined;
 };
 
 /** @internal */
@@ -26,8 +26,8 @@ export const CheckoutUpdateRequestCheckout$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CheckoutUpdateRequestCheckout
 > = z.object({
-  email: z.string().optional(),
-  discountCode: z.string().optional(),
+  email: z.nullable(z.string()).optional(),
+  discountCode: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     discountCode: "discount_code",

package/src/models/customer.ts

@@ -10,26 +10,24 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const CustomerCustomerType = {
+  Paid: "paid",
+  Free: "free",
   Lead: "lead",
-  Buyer: "buyer",
 } as const;
 export type CustomerCustomerType = ClosedEnum<typeof CustomerCustomerType>;
 
 export type Customer = {
-  id?: number | undefined;
-  email?: string | undefined;
-  name?: string | undefined;
-  firstName?: string | undefined;
-  lastName?: string | undefined;
-  customerType?: CustomerCustomerType | undefined;
-  prefixId?: string | undefined;
-  ordersCount?: number | undefined;
-  /**
-   * Total spend in cents
-   */
-  totalSpend?: number | undefined;
-  createdAt?: Date | undefined;
-  updatedAt?: Date | undefined;
+  id: string;
+  object: string;
+  email: string;
+  name: string | null;
+  firstName: string | null;
+  lastName: string | null;
+  customerType: CustomerCustomerType;
+  createdAt: Date;
+  updatedAt: Date;
+  ordersCount: number;
+  totalSpend: number;
 };
 
 /** @internal */
@@ -43,29 +41,26 @@ export const Customer$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  email: z.string().optional(),
-  name: z.string().optional(),
-  first_name: z.string().optional(),
-  last_name: z.string().optional(),
-  customer_type: CustomerCustomerType$inboundSchema.optional(),
-  prefix_id: z.string().optional(),
-  orders_count: z.number().int().optional(),
-  total_spend: z.number().int().optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
+  id: z.string(),
+  object: z.string(),
+  email: z.string(),
+  name: z.nullable(z.string()),
+  first_name: z.nullable(z.string()),
+  last_name: z.nullable(z.string()),
+  customer_type: CustomerCustomerType$inboundSchema,
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  orders_count: z.number().int(),
+  total_spend: z.number(),
 }).transform((v) => {
   return remap$(v, {
     "first_name": "firstName",
     "last_name": "lastName",
     "customer_type": "customerType",
-    "prefix_id": "prefixId",
-    "orders_count": "ordersCount",
-    "total_spend": "totalSpend",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
+    "orders_count": "ordersCount",
+    "total_spend": "totalSpend",
   });
 });