@crevio/sdk 0.6.0 → 0.6.5

package/src/models/booking.ts

@@ -20,7 +20,7 @@ export const BookingStatus = {
 } as const;
 export type BookingStatus = ClosedEnum<typeof BookingStatus>;
 
-export type IntakeAnswers = {};
+export type IntakeAnswer = {};
 
 /**
  * ID by default, full object when expanded
@@ -35,9 +35,9 @@ export type CheckoutUnion = Checkout | string;
 export type Booking = {
   object: string;
   id: string;
-  eventTypeId: number;
-  customerId: number | null;
-  orderId: number | null;
+  eventTypeId: string;
+  customerId: string | null;
+  orderId: string | null;
   status: BookingStatus;
   timeZone: string;
   attendeeName: string | null;
@@ -48,7 +48,7 @@ export type Booking = {
   cancelReason: string | null;
   createdAt: Date;
   updatedAt: Date;
-  intakeAnswers: IntakeAnswers;
+  intakeAnswers: Array<IntakeAnswer>;
   startTime: Date;
   endTime: Date;
   cancelledAt: Date | null;
@@ -68,19 +68,19 @@ export const BookingStatus$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(BookingStatus);
 
 /** @internal */
-export const IntakeAnswers$inboundSchema: z.ZodType<
-  IntakeAnswers,
+export const IntakeAnswer$inboundSchema: z.ZodType<
+  IntakeAnswer,
   z.ZodTypeDef,
   unknown
 > = z.object({});
 
-export function intakeAnswersFromJSON(
+export function intakeAnswerFromJSON(
   jsonString: string,
-): SafeParseResult<IntakeAnswers, SDKValidationError> {
+): SafeParseResult<IntakeAnswer, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => IntakeAnswers$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'IntakeAnswers' from JSON`,
+    (x) => IntakeAnswer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IntakeAnswer' from JSON`,
   );
 }
 
@@ -123,9 +123,9 @@ export const Booking$inboundSchema: z.ZodType<Booking, z.ZodTypeDef, unknown> =
   z.object({
     object: z.string(),
     id: z.string(),
-    event_type_id: z.number().int(),
-    customer_id: z.nullable(z.number().int()),
-    order_id: z.nullable(z.number().int()),
+    event_type_id: z.string(),
+    customer_id: z.nullable(z.string()),
+    order_id: z.nullable(z.string()),
     status: BookingStatus$inboundSchema,
     time_zone: z.string(),
     attendee_name: z.nullable(z.string()),
@@ -140,7 +140,7 @@ export const Booking$inboundSchema: z.ZodType<Booking, z.ZodTypeDef, unknown> =
     updated_at: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ),
-    intake_answers: z.lazy(() => IntakeAnswers$inboundSchema),
+    intake_answers: z.array(z.lazy(() => IntakeAnswer$inboundSchema)),
     start_time: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ),

package/src/models/eventtype.ts

@@ -5,30 +5,20 @@
 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 { Form, Form$inboundSchema } from "./form.js";
 import { PriceVariant, PriceVariant$inboundSchema } from "./pricevariant.js";
 
-export type DurationMinutes = {};
-
-export type BufferBeforeMinutes = {};
-
-export type BufferAfterMinutes = {};
-
-export type MinNoticeMinutes = {};
-
-export type BookingWindowDays = {};
-
-export type MaxPerDay = {};
-
-export type EventTypeLocationType = {};
-
-export type LocationDetails = {};
-
-export type EventTypeCreatedAt = {};
-
-export type EventTypeUpdatedAt = {};
+export const EventTypeLocationType = {
+  GoogleMeet: "google_meet",
+  Zoom: "zoom",
+  CustomLink: "custom_link",
+  Physical: "physical",
+  Phone: "phone",
+} as const;
+export type EventTypeLocationType = ClosedEnum<typeof EventTypeLocationType>;
 
 /**
  * ID by default, full object when expanded
@@ -40,197 +30,32 @@ export type EventType = {
   id: string;
   name: string;
   slug: string;
-  durationMinutes: DurationMinutes;
-  bufferBeforeMinutes: BufferBeforeMinutes;
-  bufferAfterMinutes: BufferAfterMinutes;
-  minNoticeMinutes: MinNoticeMinutes;
-  bookingWindowDays: BookingWindowDays;
-  maxPerDay: MaxPerDay;
+  durationMinutes: number;
+  bufferBeforeMinutes: number;
+  bufferAfterMinutes: number;
+  minNoticeMinutes: number;
+  bookingWindowDays: number;
+  maxPerDay: number | null;
   reminderMinutes: Array<number>;
   locationType: EventTypeLocationType;
-  locationDetails: LocationDetails;
-  createdAt: EventTypeCreatedAt;
-  updatedAt: EventTypeUpdatedAt;
-  formId: string;
+  locationDetails: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+  formId: string | null;
   /**
    * ID by default, full object when expanded
    */
   form?: Form | string | null | undefined;
   free: boolean;
-  scheduleId: string;
-  productId: string;
+  scheduleId: string | null;
+  productId: string | null;
   priceVariants: Array<PriceVariant>;
 };
 
 /** @internal */
-export const DurationMinutes$inboundSchema: z.ZodType<
-  DurationMinutes,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function durationMinutesFromJSON(
-  jsonString: string,
-): SafeParseResult<DurationMinutes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DurationMinutes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DurationMinutes' from JSON`,
-  );
-}
-
-/** @internal */
-export const BufferBeforeMinutes$inboundSchema: z.ZodType<
-  BufferBeforeMinutes,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function bufferBeforeMinutesFromJSON(
-  jsonString: string,
-): SafeParseResult<BufferBeforeMinutes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BufferBeforeMinutes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BufferBeforeMinutes' from JSON`,
-  );
-}
-
-/** @internal */
-export const BufferAfterMinutes$inboundSchema: z.ZodType<
-  BufferAfterMinutes,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function bufferAfterMinutesFromJSON(
-  jsonString: string,
-): SafeParseResult<BufferAfterMinutes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BufferAfterMinutes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BufferAfterMinutes' from JSON`,
-  );
-}
-
-/** @internal */
-export const MinNoticeMinutes$inboundSchema: z.ZodType<
-  MinNoticeMinutes,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function minNoticeMinutesFromJSON(
-  jsonString: string,
-): SafeParseResult<MinNoticeMinutes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MinNoticeMinutes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MinNoticeMinutes' from JSON`,
-  );
-}
-
-/** @internal */
-export const BookingWindowDays$inboundSchema: z.ZodType<
-  BookingWindowDays,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function bookingWindowDaysFromJSON(
-  jsonString: string,
-): SafeParseResult<BookingWindowDays, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BookingWindowDays$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BookingWindowDays' from JSON`,
-  );
-}
-
-/** @internal */
-export const MaxPerDay$inboundSchema: z.ZodType<
-  MaxPerDay,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function maxPerDayFromJSON(
-  jsonString: string,
-): SafeParseResult<MaxPerDay, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MaxPerDay$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MaxPerDay' from JSON`,
-  );
-}
-
-/** @internal */
-export const EventTypeLocationType$inboundSchema: z.ZodType<
-  EventTypeLocationType,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function eventTypeLocationTypeFromJSON(
-  jsonString: string,
-): SafeParseResult<EventTypeLocationType, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EventTypeLocationType$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EventTypeLocationType' from JSON`,
-  );
-}
-
-/** @internal */
-export const LocationDetails$inboundSchema: z.ZodType<
-  LocationDetails,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function locationDetailsFromJSON(
-  jsonString: string,
-): SafeParseResult<LocationDetails, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => LocationDetails$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'LocationDetails' from JSON`,
-  );
-}
-
-/** @internal */
-export const EventTypeCreatedAt$inboundSchema: z.ZodType<
-  EventTypeCreatedAt,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function eventTypeCreatedAtFromJSON(
-  jsonString: string,
-): SafeParseResult<EventTypeCreatedAt, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EventTypeCreatedAt$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EventTypeCreatedAt' from JSON`,
-  );
-}
-
-/** @internal */
-export const EventTypeUpdatedAt$inboundSchema: z.ZodType<
-  EventTypeUpdatedAt,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function eventTypeUpdatedAtFromJSON(
-  jsonString: string,
-): SafeParseResult<EventTypeUpdatedAt, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EventTypeUpdatedAt$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EventTypeUpdatedAt' from JSON`,
-  );
-}
+export const EventTypeLocationType$inboundSchema: z.ZodNativeEnum<
+  typeof EventTypeLocationType
+> = z.nativeEnum(EventTypeLocationType);
 
 /** @internal */
 export const FormUnion$inboundSchema: z.ZodType<
@@ -259,22 +84,22 @@ export const EventType$inboundSchema: z.ZodType<
   id: z.string(),
   name: z.string(),
   slug: z.string(),
-  duration_minutes: z.lazy(() => DurationMinutes$inboundSchema),
-  buffer_before_minutes: z.lazy(() => BufferBeforeMinutes$inboundSchema),
-  buffer_after_minutes: z.lazy(() => BufferAfterMinutes$inboundSchema),
-  min_notice_minutes: z.lazy(() => MinNoticeMinutes$inboundSchema),
-  booking_window_days: z.lazy(() => BookingWindowDays$inboundSchema),
-  max_per_day: z.lazy(() => MaxPerDay$inboundSchema),
+  duration_minutes: z.number().int(),
+  buffer_before_minutes: z.number().int(),
+  buffer_after_minutes: z.number().int(),
+  min_notice_minutes: z.number().int(),
+  booking_window_days: z.number().int(),
+  max_per_day: z.nullable(z.number().int()),
   reminder_minutes: z.array(z.number()),
-  location_type: z.lazy(() => EventTypeLocationType$inboundSchema),
-  location_details: z.lazy(() => LocationDetails$inboundSchema),
-  created_at: z.lazy(() => EventTypeCreatedAt$inboundSchema),
-  updated_at: z.lazy(() => EventTypeUpdatedAt$inboundSchema),
-  form_id: z.string(),
+  location_type: EventTypeLocationType$inboundSchema,
+  location_details: z.nullable(z.string()),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  form_id: z.nullable(z.string()),
   form: z.nullable(z.union([Form$inboundSchema, z.string()])).optional(),
   free: z.boolean(),
-  schedule_id: z.string(),
-  product_id: z.string(),
+  schedule_id: z.nullable(z.string()),
+  product_id: z.nullable(z.string()),
   price_variants: z.array(PriceVariant$inboundSchema),
 }).transform((v) => {
   return remap$(v, {

package/src/models/formation.ts

@@ -27,20 +27,10 @@ export const EntityType = {
 } as const;
 export type EntityType = ClosedEnum<typeof EntityType>;
 
-export type State = {};
-
-export type NaicsCode = {};
-
-export type Description = {};
-
 export type ResponsibleParty = {};
 
 export type MailingAddress = {};
 
-export type FormationCreatedAt = {};
-
-export type FormationUpdatedAt = {};
-
 export const PaymentStatus = {
   Unpaid: "unpaid",
   Paid: "paid",
@@ -53,9 +43,9 @@ export type Formation = {
   object: string;
   status: FormationStatus;
   entityType: EntityType;
-  state: State;
-  naicsCode: NaicsCode;
-  description: Description;
+  state: string;
+  naicsCode: string;
+  description: string;
   nameOptions: Array<any>;
   members: Array<any>;
   responsibleParty: ResponsibleParty;
@@ -66,8 +56,8 @@ export type Formation = {
   doolaError: string | null;
   stripeCheckoutSessionId: string | null;
   submittedAt: string | null;
-  createdAt: FormationCreatedAt;
-  updatedAt: FormationUpdatedAt;
+  createdAt: Date;
+  updatedAt: Date;
   doolaCompanyId: string | null;
   verificationId: string | null;
   paymentStatus: PaymentStatus;
@@ -83,54 +73,6 @@ export const FormationStatus$inboundSchema: z.ZodNativeEnum<
 export const EntityType$inboundSchema: z.ZodNativeEnum<typeof EntityType> = z
   .nativeEnum(EntityType);
 
-/** @internal */
-export const State$inboundSchema: z.ZodType<State, z.ZodTypeDef, unknown> = z
-  .object({});
-
-export function stateFromJSON(
-  jsonString: string,
-): SafeParseResult<State, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => State$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'State' from JSON`,
-  );
-}
-
-/** @internal */
-export const NaicsCode$inboundSchema: z.ZodType<
-  NaicsCode,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function naicsCodeFromJSON(
-  jsonString: string,
-): SafeParseResult<NaicsCode, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => NaicsCode$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'NaicsCode' from JSON`,
-  );
-}
-
-/** @internal */
-export const Description$inboundSchema: z.ZodType<
-  Description,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function descriptionFromJSON(
-  jsonString: string,
-): SafeParseResult<Description, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Description$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Description' from JSON`,
-  );
-}
-
 /** @internal */
 export const ResponsibleParty$inboundSchema: z.ZodType<
   ResponsibleParty,
@@ -165,40 +107,6 @@ export function mailingAddressFromJSON(
   );
 }
 
-/** @internal */
-export const FormationCreatedAt$inboundSchema: z.ZodType<
-  FormationCreatedAt,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function formationCreatedAtFromJSON(
-  jsonString: string,
-): SafeParseResult<FormationCreatedAt, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FormationCreatedAt$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FormationCreatedAt' from JSON`,
-  );
-}
-
-/** @internal */
-export const FormationUpdatedAt$inboundSchema: z.ZodType<
-  FormationUpdatedAt,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function formationUpdatedAtFromJSON(
-  jsonString: string,
-): SafeParseResult<FormationUpdatedAt, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FormationUpdatedAt$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FormationUpdatedAt' from JSON`,
-  );
-}
-
 /** @internal */
 export const PaymentStatus$inboundSchema: z.ZodNativeEnum<
   typeof PaymentStatus
@@ -214,9 +122,9 @@ export const Formation$inboundSchema: z.ZodType<
   object: z.string(),
   status: FormationStatus$inboundSchema,
   entity_type: EntityType$inboundSchema,
-  state: z.lazy(() => State$inboundSchema),
-  naics_code: z.lazy(() => NaicsCode$inboundSchema),
-  description: z.lazy(() => Description$inboundSchema),
+  state: z.string(),
+  naics_code: z.string(),
+  description: z.string(),
   name_options: z.array(z.any()),
   members: z.array(z.any()),
   responsible_party: z.lazy(() => ResponsibleParty$inboundSchema),
@@ -227,8 +135,8 @@ export const Formation$inboundSchema: z.ZodType<
   doola_error: z.nullable(z.string()),
   stripe_checkout_session_id: z.nullable(z.string()),
   submitted_at: z.nullable(z.string()),
-  created_at: z.lazy(() => FormationCreatedAt$inboundSchema),
-  updated_at: z.lazy(() => FormationUpdatedAt$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)),
   doola_company_id: z.nullable(z.string()),
   verification_id: z.nullable(z.string()),
   payment_status: PaymentStatus$inboundSchema,

package/src/models/formationdocument.ts

@@ -16,16 +16,12 @@ export const DocumentType = {
 } as const;
 export type DocumentType = ClosedEnum<typeof DocumentType>;
 
-export type Name = {};
-
-export type ContentType = {};
-
 export type FormationDocument = {
   id: string;
   object: string;
   documentType: DocumentType;
-  name: Name;
-  contentType: ContentType;
+  name: string;
+  contentType: string | null;
   doolaCreatedAt: string | null;
   doolaLastModifiedAt: string | null;
   doolaCompanyId: string;
@@ -36,37 +32,6 @@ export type FormationDocument = {
 export const DocumentType$inboundSchema: z.ZodNativeEnum<typeof DocumentType> =
   z.nativeEnum(DocumentType);
 
-/** @internal */
-export const Name$inboundSchema: z.ZodType<Name, z.ZodTypeDef, unknown> = z
-  .object({});
-
-export function nameFromJSON(
-  jsonString: string,
-): SafeParseResult<Name, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Name$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Name' from JSON`,
-  );
-}
-
-/** @internal */
-export const ContentType$inboundSchema: z.ZodType<
-  ContentType,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function contentTypeFromJSON(
-  jsonString: string,
-): SafeParseResult<ContentType, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ContentType$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ContentType' from JSON`,
-  );
-}
-
 /** @internal */
 export const FormationDocument$inboundSchema: z.ZodType<
   FormationDocument,
@@ -76,8 +41,8 @@ export const FormationDocument$inboundSchema: z.ZodType<
   id: z.string(),
   object: z.string(),
   document_type: DocumentType$inboundSchema,
-  name: z.lazy(() => Name$inboundSchema),
-  content_type: z.lazy(() => ContentType$inboundSchema),
+  name: z.string(),
+  content_type: z.nullable(z.string()),
   doola_created_at: z.nullable(z.string()),
   doola_last_modified_at: z.nullable(z.string()),
   doola_company_id: z.string(),

package/src/models/index.ts

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./accesscheck.js";
 export * from "./account.js";
 export * from "./accountrequest.js";
 export * from "./aisite.js";
@@ -199,6 +200,7 @@ export * from "./usageoperationspend.js";
 export * from "./usageplan.js";
 export * from "./usagespend.js";
 export * from "./usagetransaction.js";
+export * from "./user.js";
 export * from "./videogeneraterequest.js";
 export * from "./webhookendpoint.js";
 export * from "./webhookendpointrequest.js";

package/src/models/me.ts

@@ -14,7 +14,7 @@ export type Me = {
   name: string | null;
   username: string;
   email: string;
-  preferredLanguage: string | null;
+  preferredLanguage: string;
   timeZone: string | null;
   createdAt: Date;
   avatarUrl: string | null;
@@ -28,7 +28,7 @@ export const Me$inboundSchema: z.ZodType<Me, z.ZodTypeDef, unknown> = z.object({
   name: z.nullable(z.string()),
   username: z.string(),
   email: z.string(),
-  preferred_language: z.nullable(z.string()),
+  preferred_language: z.string(),
   time_zone: z.nullable(z.string()),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   avatar_url: z.nullable(z.string()),

package/src/models/operations/checkaccess.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type CheckAccessRequest = {
+  /**
+   * The resource ID (e.g., "prod_abc123") or slug (e.g., "my-product")
+   */
+  id: string;
+  /**
+   * The resource to check access to: the account id (acct_…), a product (prod_…) or an experience (exp_…).
+   */
+  resourceId: string;
+};
+
+/** @internal */
+export type CheckAccessRequest$Outbound = {
+  id: string;
+  resource_id: string;
+};
+
+/** @internal */
+export const CheckAccessRequest$outboundSchema: z.ZodType<
+  CheckAccessRequest$Outbound,
+  z.ZodTypeDef,
+  CheckAccessRequest
+> = z.object({
+  id: z.string(),
+  resourceId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    resourceId: "resource_id",
+  });
+});
+
+export function checkAccessRequestToJSON(
+  checkAccessRequest: CheckAccessRequest,
+): string {
+  return JSON.stringify(
+    CheckAccessRequest$outboundSchema.parse(checkAccessRequest),
+  );
+}