@crevio/sdk 0.3.5 → 0.4.7

package/src/models/checkoutlinkrequest.ts

@@ -3,26 +3,48 @@
  */
 
 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> | undefined;
+  successUrl?: string | null | undefined;
+  metadata?: Metadata | null | undefined;
+  priceVariants?: Array<string> | undefined;
 };
 
 export type CheckoutLinkRequest = {
-  checkoutLink?: CheckoutLinkRequestCheckoutLink | undefined;
+  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;
-  discountId?: number | null | undefined;
-  allowDiscountCodes?: boolean | undefined;
-  successUrl?: string | undefined;
-  priceVariantIds?: Array<number> | undefined;
+  name?: string | null | undefined;
+  discount?: string | null | undefined;
+  allow_discount_codes?: boolean | undefined;
+  success_url?: string | null | undefined;
+  metadata?: Metadata$Outbound | null | undefined;
+  price_variants?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -31,11 +53,18 @@ 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()).optional(),
+  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, {
+    allowDiscountCodes: "allow_discount_codes",
+    successUrl: "success_url",
+    priceVariants: "price_variants",
+  });
 });
 
 export function checkoutLinkRequestCheckoutLinkToJSON(
@@ -50,7 +79,7 @@ export function checkoutLinkRequestCheckoutLinkToJSON(
 
 /** @internal */
 export type CheckoutLinkRequest$Outbound = {
-  checkoutLink?: CheckoutLinkRequestCheckoutLink$Outbound | undefined;
+  checkout_link: CheckoutLinkRequestCheckoutLink$Outbound;
 };
 
 /** @internal */
@@ -59,8 +88,11 @@ export const CheckoutLinkRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CheckoutLinkRequest
 > = z.object({
-  checkoutLink: z.lazy(() => CheckoutLinkRequestCheckoutLink$outboundSchema)
-    .optional(),
+  checkoutLink: z.lazy(() => CheckoutLinkRequestCheckoutLink$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    checkoutLink: "checkout_link",
+  });
 });
 
 export function checkoutLinkRequestToJSON(

package/src/models/checkoutupdaterequest.ts

@@ -3,10 +3,11 @@
  */
 
 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 = {
@@ -15,8 +16,8 @@ export type CheckoutUpdateRequest = {
 
 /** @internal */
 export type CheckoutUpdateRequestCheckout$Outbound = {
-  email?: string | undefined;
-  discountCode?: string | undefined;
+  email?: string | null | undefined;
+  discount_code?: string | null | undefined;
 };
 
 /** @internal */
@@ -25,8 +26,12 @@ 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",
+  });
 });
 
 export function checkoutUpdateRequestCheckoutToJSON(

package/src/models/customer.ts

@@ -3,33 +3,31 @@
  */
 
 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const CustomerCustomerType = {
-  Lead: "lead",
-  Free: "free",
   Paid: "paid",
+  Free: "free",
+  Lead: "lead",
 } 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 | null | 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,19 +41,27 @@ export const Customer$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  email: z.string().optional(),
-  name: z.string().optional(),
-  firstName: z.string().optional(),
-  lastName: z.nullable(z.string()).optional(),
-  customerType: CustomerCustomerType$inboundSchema.optional(),
-  prefixId: z.string().optional(),
-  ordersCount: z.number().int().optional(),
-  totalSpend: z.number().int().optional(),
-  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  updatedAt: 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",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+    "orders_count": "ordersCount",
+    "total_spend": "totalSpend",
+  });
 });
 
 export function customerFromJSON(

package/src/models/customerrequest.ts

@@ -3,22 +3,23 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
 import { ClosedEnum } from "../types/enums.js";
 
 export const CustomerRequestCustomerType = {
-  Lead: "lead",
-  Free: "free",
   Paid: "paid",
+  Free: "free",
+  Lead: "lead",
 } as const;
 export type CustomerRequestCustomerType = ClosedEnum<
   typeof CustomerRequestCustomerType
 >;
 
 export type CustomerRequestCustomer = {
-  email: string;
-  name?: string | undefined;
-  firstName?: string | undefined;
-  lastName?: string | undefined;
+  email?: string | undefined;
+  name?: string | null | undefined;
+  firstName?: string | null | undefined;
+  lastName?: string | null | undefined;
   customerType?: CustomerRequestCustomerType | undefined;
 };
 
@@ -33,11 +34,11 @@ export const CustomerRequestCustomerType$outboundSchema: z.ZodNativeEnum<
 
 /** @internal */
 export type CustomerRequestCustomer$Outbound = {
-  email: string;
-  name?: string | undefined;
-  firstName?: string | undefined;
-  lastName?: string | undefined;
-  customerType?: string | undefined;
+  email?: string | undefined;
+  name?: string | null | undefined;
+  first_name?: string | null | undefined;
+  last_name?: string | null | undefined;
+  customer_type?: string | undefined;
 };
 
 /** @internal */
@@ -46,11 +47,17 @@ export const CustomerRequestCustomer$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CustomerRequestCustomer
 > = z.object({
-  email: z.string(),
-  name: z.string().optional(),
-  firstName: z.string().optional(),
-  lastName: z.string().optional(),
+  email: z.string().optional(),
+  name: z.nullable(z.string()).optional(),
+  firstName: z.nullable(z.string()).optional(),
+  lastName: z.nullable(z.string()).optional(),
   customerType: CustomerRequestCustomerType$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    firstName: "first_name",
+    lastName: "last_name",
+    customerType: "customer_type",
+  });
 });
 
 export function customerRequestCustomerToJSON(

package/src/models/deleteresponse.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type DeleteResponse = {
+  id: string;
+  object: string;
+  deleted: true;
+};
+
+/** @internal */
+export const DeleteResponse$inboundSchema: z.ZodType<
+  DeleteResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  object: z.string(),
+  deleted: z.literal(true),
+});
+
+export function deleteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteResponse' from JSON`,
+  );
+}

package/src/models/discount.ts

@@ -3,53 +3,47 @@
  */
 
 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { PriceVariant, PriceVariant$inboundSchema } from "./pricevariant.js";
 
 export const DiscountStatus = {
   Active: "active",
-  Expired: "expired",
-  Scheduled: "scheduled",
+  Inactive: "inactive",
 } as const;
 export type DiscountStatus = ClosedEnum<typeof DiscountStatus>;
 
 export const DiscountDiscountType = {
-  AmountOff: "amount_off",
-  PercentOff: "percent_off",
+  Percentage: "percentage",
+  Fixed: "fixed",
 } as const;
 export type DiscountDiscountType = ClosedEnum<typeof DiscountDiscountType>;
 
 export const DiscountDuration = {
-  Once: "once",
   Forever: "forever",
+  Once: "once",
   Repeating: "repeating",
 } as const;
 export type DiscountDuration = ClosedEnum<typeof DiscountDuration>;
 
 export type Discount = {
-  id?: number | undefined;
-  status?: DiscountStatus | undefined;
-  discountType?: DiscountDiscountType | undefined;
-  code?: string | undefined;
-  redeemBy?: Date | null | undefined;
-  maxRedemptions?: number | null | undefined;
-  timesRedeemed?: number | undefined;
-  duration?: DiscountDuration | null | undefined;
-  durationInMonths?: number | null | undefined;
-  /**
-   * Discount amount in cents
-   */
-  amountOff?: number | null | undefined;
-  percentOff?: number | null | undefined;
-  currency?: string | null | undefined;
-  prefixId?: string | undefined;
-  destroyable?: boolean | undefined;
-  createdAt?: Date | undefined;
-  updatedAt?: Date | undefined;
-  priceVariants?: Array<PriceVariant> | undefined;
+  id: string;
+  object: string;
+  status: DiscountStatus;
+  discountType: DiscountDiscountType;
+  code: string;
+  amountOff: number | null;
+  duration: DiscountDuration;
+  durationInMonths: number | null;
+  maxRedemptions: number | null;
+  timesRedeemed: number;
+  redeemBy: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+  percentOff: number | null;
+  currency: string | null;
 };
 
 /** @internal */
@@ -73,27 +67,35 @@ export const Discount$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  status: DiscountStatus$inboundSchema.optional(),
-  discountType: DiscountDiscountType$inboundSchema.optional(),
-  code: z.string().optional(),
-  redeemBy: z.nullable(
+  id: z.string(),
+  object: z.string(),
+  status: DiscountStatus$inboundSchema,
+  discount_type: DiscountDiscountType$inboundSchema,
+  code: z.string(),
+  amount_off: z.nullable(z.number().int()),
+  duration: DiscountDuration$inboundSchema,
+  duration_in_months: z.nullable(z.number().int()),
+  max_redemptions: z.nullable(z.number().int()),
+  times_redeemed: z.number().int(),
+  redeem_by: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
-  ).optional(),
-  maxRedemptions: z.nullable(z.number().int()).optional(),
-  timesRedeemed: z.number().int().optional(),
-  duration: z.nullable(DiscountDuration$inboundSchema).optional(),
-  durationInMonths: z.nullable(z.number().int()).optional(),
-  amountOff: z.nullable(z.number().int()).optional(),
-  percentOff: z.nullable(z.number()).optional(),
-  currency: z.nullable(z.string()).optional(),
-  prefixId: z.string().optional(),
-  destroyable: z.boolean().optional(),
-  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  priceVariants: z.array(PriceVariant$inboundSchema).optional(),
+  ),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  percent_off: z.nullable(z.number()),
+  currency: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "discount_type": "discountType",
+    "amount_off": "amountOff",
+    "duration_in_months": "durationInMonths",
+    "max_redemptions": "maxRedemptions",
+    "times_redeemed": "timesRedeemed",
+    "redeem_by": "redeemBy",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+    "percent_off": "percentOff",
+  });
 });
 
 export function discountFromJSON(

package/src/models/discountrequest.ts

@@ -3,19 +3,20 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
 import { ClosedEnum } from "../types/enums.js";
 
 export const DiscountRequestDiscountType = {
-  AmountOff: "amount_off",
-  PercentOff: "percent_off",
+  Percentage: "percentage",
+  Fixed: "fixed",
 } as const;
 export type DiscountRequestDiscountType = ClosedEnum<
   typeof DiscountRequestDiscountType
 >;
 
 export const DiscountRequestDuration = {
-  Once: "once",
   Forever: "forever",
+  Once: "once",
   Repeating: "repeating",
 } as const;
 export type DiscountRequestDuration = ClosedEnum<
@@ -23,25 +24,16 @@ export type DiscountRequestDuration = ClosedEnum<
 >;
 
 export type DiscountRequestDiscount = {
-  code: string;
+  code?: string | undefined;
   discountType?: DiscountRequestDiscountType | undefined;
-  /**
-   * Discount amount in cents (required if discount_type=amount_off)
-   */
-  amountOff?: number | undefined;
-  /**
-   * Discount percentage 0-100 (required if discount_type=percent_off)
-   */
-  percentOff?: number | undefined;
-  currency?: string | undefined;
+  amountOff?: number | null | undefined;
+  percentOff?: number | null | undefined;
+  currency?: string | null | undefined;
   duration?: DiscountRequestDuration | undefined;
-  durationInMonths?: number | undefined;
-  redeemBy?: Date | undefined;
-  maxRedemptions?: number | undefined;
-  /**
-   * Limit discount to specific price variant IDs
-   */
-  priceVariants?: Array<number> | undefined;
+  durationInMonths?: number | null | undefined;
+  redeemBy?: Date | null | undefined;
+  maxRedemptions?: number | null | undefined;
+  priceVariants?: Array<string> | undefined;
 };
 
 export type DiscountRequest = {
@@ -60,16 +52,16 @@ export const DiscountRequestDuration$outboundSchema: z.ZodNativeEnum<
 
 /** @internal */
 export type DiscountRequestDiscount$Outbound = {
-  code: string;
-  discountType?: string | undefined;
-  amountOff?: number | undefined;
-  percentOff?: number | undefined;
-  currency?: string | undefined;
+  code?: string | undefined;
+  discount_type?: string | undefined;
+  amount_off?: number | null | undefined;
+  percent_off?: number | null | undefined;
+  currency?: string | null | undefined;
   duration?: string | undefined;
-  durationInMonths?: number | undefined;
-  redeemBy?: string | undefined;
-  maxRedemptions?: number | undefined;
-  priceVariants?: Array<number> | undefined;
+  duration_in_months?: number | null | undefined;
+  redeem_by?: string | null | undefined;
+  max_redemptions?: number | null | undefined;
+  price_variants?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -78,16 +70,26 @@ export const DiscountRequestDiscount$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DiscountRequestDiscount
 > = z.object({
-  code: z.string(),
+  code: z.string().optional(),
   discountType: DiscountRequestDiscountType$outboundSchema.optional(),
-  amountOff: z.number().int().optional(),
-  percentOff: z.number().optional(),
-  currency: z.string().optional(),
+  amountOff: z.nullable(z.number().int()).optional(),
+  percentOff: z.nullable(z.number()).optional(),
+  currency: z.nullable(z.string()).optional(),
   duration: DiscountRequestDuration$outboundSchema.optional(),
-  durationInMonths: z.number().int().optional(),
-  redeemBy: z.date().transform(v => v.toISOString()).optional(),
-  maxRedemptions: z.number().int().optional(),
-  priceVariants: z.array(z.number().int()).optional(),
+  durationInMonths: z.nullable(z.number().int()).optional(),
+  redeemBy: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  maxRedemptions: z.nullable(z.number().int()).optional(),
+  priceVariants: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    discountType: "discount_type",
+    amountOff: "amount_off",
+    percentOff: "percent_off",
+    durationInMonths: "duration_in_months",
+    redeemBy: "redeem_by",
+    maxRedemptions: "max_redemptions",
+    priceVariants: "price_variants",
+  });
 });
 
 export function discountRequestDiscountToJSON(

package/src/models/error.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const Type = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  ValidationError: "validation_error",
+} as const;
+export type Type = ClosedEnum<typeof Type>;
+
+export type Errors = {};
+
+export type ErrorT = {
+  type: Type;
+  code?: string | undefined;
+  message: string;
+  param?: string | undefined;
+  errors?: Errors | undefined;
+};
+
+/** @internal */
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
+
+/** @internal */
+export const Errors$inboundSchema: z.ZodType<Errors, z.ZodTypeDef, unknown> = z
+  .object({});
+
+export function errorsFromJSON(
+  jsonString: string,
+): SafeParseResult<Errors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Errors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Errors' from JSON`,
+  );
+}
+
+/** @internal */
+export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
+  .object({
+    type: Type$inboundSchema,
+    code: z.string().optional(),
+    message: z.string(),
+    param: z.string().optional(),
+    errors: z.lazy(() => Errors$inboundSchema).optional(),
+  });
+
+export function errorFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}