@crevio/sdk 0.4.12 → 0.4.14

package/src/models/emailresponse.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 EmailResponseObject = {
+  Email: "email",
+} as const;
+export type EmailResponseObject = ClosedEnum<typeof EmailResponseObject>;
+
+export const EmailResponseStatus = {
+  Queued: "queued",
+} as const;
+export type EmailResponseStatus = ClosedEnum<typeof EmailResponseStatus>;
+
+export type EmailResponse = {
+  object: EmailResponseObject;
+  /**
+   * Number of recipients
+   */
+  recipients: number;
+  subject: string;
+  status: EmailResponseStatus;
+};
+
+/** @internal */
+export const EmailResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof EmailResponseObject
+> = z.nativeEnum(EmailResponseObject);
+
+/** @internal */
+export const EmailResponseStatus$inboundSchema: z.ZodNativeEnum<
+  typeof EmailResponseStatus
+> = z.nativeEnum(EmailResponseStatus);
+
+/** @internal */
+export const EmailResponse$inboundSchema: z.ZodType<
+  EmailResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: EmailResponseObject$inboundSchema,
+  recipients: z.number().int(),
+  subject: z.string(),
+  status: EmailResponseStatus$inboundSchema,
+});
+
+export function emailResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EmailResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmailResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmailResponse' from JSON`,
+  );
+}

package/src/models/file.ts

@@ -8,14 +8,24 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export type FileKind = {};
+
+export type FileUploadStatus = {};
+
+export type FileUrl = {};
+
+export type FileCreatedAt = {};
+
+export type FileUpdatedAt = {};
+
 export type FileT = {
   object: string;
   id: string;
-  sourceType: string;
-  uploadStatus: string;
-  url: string;
-  createdAt: string;
-  updatedAt: string;
+  kind: FileKind;
+  uploadStatus: FileUploadStatus;
+  url: FileUrl;
+  createdAt: FileCreatedAt;
+  updatedAt: FileUpdatedAt;
   filename: string;
   contentType: string;
   size: number;
@@ -23,16 +33,98 @@ export type FileT = {
   fileUrl: string;
 };
 
+/** @internal */
+export const FileKind$inboundSchema: z.ZodType<
+  FileKind,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileKindFromJSON(
+  jsonString: string,
+): SafeParseResult<FileKind, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileKind$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileKind' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileUploadStatus$inboundSchema: z.ZodType<
+  FileUploadStatus,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileUploadStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<FileUploadStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileUploadStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileUploadStatus' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileUrl$inboundSchema: z.ZodType<FileUrl, z.ZodTypeDef, unknown> =
+  z.object({});
+
+export function fileUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<FileUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileCreatedAt$inboundSchema: z.ZodType<
+  FileCreatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreatedAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileUpdatedAt$inboundSchema: z.ZodType<
+  FileUpdatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileUpdatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<FileUpdatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileUpdatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileUpdatedAt' from JSON`,
+  );
+}
+
 /** @internal */
 export const FileT$inboundSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
   .object({
     object: z.string(),
     id: z.string(),
-    source_type: z.string(),
-    upload_status: z.string(),
-    url: z.string(),
-    created_at: z.string(),
-    updated_at: z.string(),
+    kind: z.lazy(() => FileKind$inboundSchema),
+    upload_status: z.lazy(() => FileUploadStatus$inboundSchema),
+    url: z.lazy(() => FileUrl$inboundSchema),
+    created_at: z.lazy(() => FileCreatedAt$inboundSchema),
+    updated_at: z.lazy(() => FileUpdatedAt$inboundSchema),
     filename: z.string(),
     content_type: z.string(),
     size: z.number().int(),
@@ -40,7 +132,6 @@ export const FileT$inboundSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
     file_url: z.string(),
   }).transform((v) => {
     return remap$(v, {
-      "source_type": "sourceType",
       "upload_status": "uploadStatus",
       "created_at": "createdAt",
       "updated_at": "updatedAt",

package/src/models/filecreateresponse.ts

@@ -8,16 +8,26 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export type FileCreateResponseKind = {};
+
+export type FileCreateResponseUploadStatus = {};
+
+export type FileCreateResponseUrl = {};
+
+export type FileCreateResponseCreatedAt = {};
+
+export type FileCreateResponseUpdatedAt = {};
+
 export type UploadHeaders = {};
 
 export type FileCreateResponse = {
   object: string;
   id: string;
-  sourceType: string;
-  uploadStatus: string;
-  url: string;
-  createdAt: string;
-  updatedAt: string;
+  kind: FileCreateResponseKind;
+  uploadStatus: FileCreateResponseUploadStatus;
+  url: FileCreateResponseUrl;
+  createdAt: FileCreateResponseCreatedAt;
+  updatedAt: FileCreateResponseUpdatedAt;
   filename: string;
   contentType: string;
   size: number;
@@ -27,6 +37,91 @@ export type FileCreateResponse = {
   uploadHeaders?: UploadHeaders | null | undefined;
 };
 
+/** @internal */
+export const FileCreateResponseKind$inboundSchema: z.ZodType<
+  FileCreateResponseKind,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreateResponseKindFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreateResponseKind, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreateResponseKind$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreateResponseKind' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileCreateResponseUploadStatus$inboundSchema: z.ZodType<
+  FileCreateResponseUploadStatus,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreateResponseUploadStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreateResponseUploadStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreateResponseUploadStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreateResponseUploadStatus' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileCreateResponseUrl$inboundSchema: z.ZodType<
+  FileCreateResponseUrl,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreateResponseUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreateResponseUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreateResponseUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreateResponseUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileCreateResponseCreatedAt$inboundSchema: z.ZodType<
+  FileCreateResponseCreatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreateResponseCreatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreateResponseCreatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreateResponseCreatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreateResponseCreatedAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileCreateResponseUpdatedAt$inboundSchema: z.ZodType<
+  FileCreateResponseUpdatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function fileCreateResponseUpdatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<FileCreateResponseUpdatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileCreateResponseUpdatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileCreateResponseUpdatedAt' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadHeaders$inboundSchema: z.ZodType<
   UploadHeaders,
@@ -52,11 +147,11 @@ export const FileCreateResponse$inboundSchema: z.ZodType<
 > = z.object({
   object: z.string(),
   id: z.string(),
-  source_type: z.string(),
-  upload_status: z.string(),
-  url: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
+  kind: z.lazy(() => FileCreateResponseKind$inboundSchema),
+  upload_status: z.lazy(() => FileCreateResponseUploadStatus$inboundSchema),
+  url: z.lazy(() => FileCreateResponseUrl$inboundSchema),
+  created_at: z.lazy(() => FileCreateResponseCreatedAt$inboundSchema),
+  updated_at: z.lazy(() => FileCreateResponseUpdatedAt$inboundSchema),
   filename: z.string(),
   content_type: z.string(),
   size: z.number().int(),
@@ -67,7 +162,6 @@ export const FileCreateResponse$inboundSchema: z.ZodType<
     .optional(),
 }).transform((v) => {
   return remap$(v, {
-    "source_type": "sourceType",
     "upload_status": "uploadStatus",
     "created_at": "createdAt",
     "updated_at": "updatedAt",

package/src/models/filerequest.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Defaults to 'file'. Set to 'external_video' to pin a YouTube, Vimeo, or Wistia URL as an embed.
+ */
+export const KindEnum = {
+  File: "file",
+  ExternalVideo: "external_video",
+} as const;
+/**
+ * Defaults to 'file'. Set to 'external_video' to pin a YouTube, Vimeo, or Wistia URL as an embed.
+ */
+export type KindEnum = ClosedEnum<typeof KindEnum>;
+
+export type FileRequest = {
+  /**
+   * Defaults to 'file'. Set to 'external_video' to pin a YouTube, Vimeo, or Wistia URL as an embed.
+   */
+  kind?: KindEnum | null | undefined;
+  /**
+   * Required when kind=external_video, or for server-side URL imports of files.
+   */
+  url?: string | null | undefined;
+  /**
+   * Required for presigned uploads. Optional for URL imports.
+   */
+  filename?: string | null | undefined;
+};
+
+/** @internal */
+export const KindEnum$outboundSchema: z.ZodNativeEnum<typeof KindEnum> = z
+  .nativeEnum(KindEnum);
+
+/** @internal */
+export type FileRequest$Outbound = {
+  kind?: string | null | undefined;
+  url?: string | null | undefined;
+  filename?: string | null | undefined;
+};
+
+/** @internal */
+export const FileRequest$outboundSchema: z.ZodType<
+  FileRequest$Outbound,
+  z.ZodTypeDef,
+  FileRequest
+> = z.object({
+  kind: z.nullable(KindEnum$outboundSchema).optional(),
+  url: z.nullable(z.string()).optional(),
+  filename: z.nullable(z.string()).optional(),
+});
+
+export function fileRequestToJSON(fileRequest: FileRequest): string {
+  return JSON.stringify(FileRequest$outboundSchema.parse(fileRequest));
+}

package/src/models/form.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 Purpose = {
+  Newsletter: "newsletter",
+  Contact: "contact",
+  LeadMagnet: "lead_magnet",
+  Custom: "custom",
+} as const;
+export type Purpose = ClosedEnum<typeof Purpose>;
+
+export type FormSettings = {};
+
+export type Form = {
+  id: string;
+  object: string;
+  purpose: Purpose;
+  name: string;
+  isPrimary: boolean;
+  confirmationRequired: boolean;
+  settings: FormSettings;
+  tagIds: Array<number>;
+  archivedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+  formFields: Array<any>;
+};
+
+/** @internal */
+export const Purpose$inboundSchema: z.ZodNativeEnum<typeof Purpose> = z
+  .nativeEnum(Purpose);
+
+/** @internal */
+export const FormSettings$inboundSchema: z.ZodType<
+  FormSettings,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function formSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<FormSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormSettings' from JSON`,
+  );
+}
+
+/** @internal */
+export const Form$inboundSchema: z.ZodType<Form, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    object: z.string(),
+    purpose: Purpose$inboundSchema,
+    name: z.string(),
+    is_primary: z.boolean(),
+    confirmation_required: z.boolean(),
+    settings: z.lazy(() => FormSettings$inboundSchema),
+    tag_ids: z.array(z.number().int()),
+    archived_at: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    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_fields: z.array(z.any()),
+  }).transform((v) => {
+    return remap$(v, {
+      "is_primary": "isPrimary",
+      "confirmation_required": "confirmationRequired",
+      "tag_ids": "tagIds",
+      "archived_at": "archivedAt",
+      "created_at": "createdAt",
+      "updated_at": "updatedAt",
+      "form_fields": "formFields",
+    });
+  });
+
+export function formFromJSON(
+  jsonString: string,
+): SafeParseResult<Form, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Form$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Form' from JSON`,
+  );
+}

package/src/models/formrequest.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 FormRequestSettings = {};
+
+export type FormRequest = {
+  name?: string | null | undefined;
+  isPrimary?: boolean | null | undefined;
+  confirmationRequired?: boolean | null | undefined;
+  settings?: FormRequestSettings | null | undefined;
+  tagIds?: Array<string> | undefined;
+  archivedAt?: Date | null | undefined;
+};
+
+/** @internal */
+export type FormRequestSettings$Outbound = {};
+
+/** @internal */
+export const FormRequestSettings$outboundSchema: z.ZodType<
+  FormRequestSettings$Outbound,
+  z.ZodTypeDef,
+  FormRequestSettings
+> = z.object({});
+
+export function formRequestSettingsToJSON(
+  formRequestSettings: FormRequestSettings,
+): string {
+  return JSON.stringify(
+    FormRequestSettings$outboundSchema.parse(formRequestSettings),
+  );
+}
+
+/** @internal */
+export type FormRequest$Outbound = {
+  name?: string | null | undefined;
+  is_primary?: boolean | null | undefined;
+  confirmation_required?: boolean | null | undefined;
+  settings?: FormRequestSettings$Outbound | null | undefined;
+  tag_ids?: Array<string> | undefined;
+  archived_at?: string | null | undefined;
+};
+
+/** @internal */
+export const FormRequest$outboundSchema: z.ZodType<
+  FormRequest$Outbound,
+  z.ZodTypeDef,
+  FormRequest
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+  isPrimary: z.nullable(z.boolean()).optional(),
+  confirmationRequired: z.nullable(z.boolean()).optional(),
+  settings: z.nullable(z.lazy(() => FormRequestSettings$outboundSchema))
+    .optional(),
+  tagIds: z.array(z.string()).optional(),
+  archivedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    isPrimary: "is_primary",
+    confirmationRequired: "confirmation_required",
+    tagIds: "tag_ids",
+    archivedAt: "archived_at",
+  });
+});
+
+export function formRequestToJSON(formRequest: FormRequest): string {
+  return JSON.stringify(FormRequest$outboundSchema.parse(formRequest));
+}

package/src/models/formsubmission.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+
+export type Answers = {};
+
+export type FormSubmission = {
+  id: string;
+  object: string;
+  answers: Answers;
+  respondentType: string;
+  createdAt: Date;
+  respondentId: number;
+  formId: number | null;
+};
+
+/** @internal */
+export const Answers$inboundSchema: z.ZodType<Answers, z.ZodTypeDef, unknown> =
+  z.object({});
+
+export function answersFromJSON(
+  jsonString: string,
+): SafeParseResult<Answers, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Answers$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Answers' from JSON`,
+  );
+}
+
+/** @internal */
+export const FormSubmission$inboundSchema: z.ZodType<
+  FormSubmission,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  object: z.string(),
+  answers: z.lazy(() => Answers$inboundSchema),
+  respondent_type: z.string(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  respondent_id: z.number().int(),
+  form_id: z.nullable(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    "respondent_type": "respondentType",
+    "created_at": "createdAt",
+    "respondent_id": "respondentId",
+    "form_id": "formId",
+  });
+});
+
+export function formSubmissionFromJSON(
+  jsonString: string,
+): SafeParseResult<FormSubmission, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormSubmission$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormSubmission' from JSON`,
+  );
+}

package/src/models/formsubmissionrequest.ts

@@ -0,0 +1,57 @@
+/*
+ * 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 FormSubmissionRequest = {
+  /**
+   * ID of the Form being submitted
+   */
+  formId: string;
+  /**
+   * Email of the respondent
+   */
+  email: string;
+  /**
+   * Optional name of the respondent
+   */
+  name?: string | null | undefined;
+  /**
+   * Map of form_field_id → answer value
+   */
+  answers: { [k: string]: any };
+};
+
+/** @internal */
+export type FormSubmissionRequest$Outbound = {
+  form_id: string;
+  email: string;
+  name?: string | null | undefined;
+  answers: { [k: string]: any };
+};
+
+/** @internal */
+export const FormSubmissionRequest$outboundSchema: z.ZodType<
+  FormSubmissionRequest$Outbound,
+  z.ZodTypeDef,
+  FormSubmissionRequest
+> = z.object({
+  formId: z.string(),
+  email: z.string(),
+  name: z.nullable(z.string()).optional(),
+  answers: z.record(z.any()),
+}).transform((v) => {
+  return remap$(v, {
+    formId: "form_id",
+  });
+});
+
+export function formSubmissionRequestToJSON(
+  formSubmissionRequest: FormSubmissionRequest,
+): string {
+  return JSON.stringify(
+    FormSubmissionRequest$outboundSchema.parse(formSubmissionRequest),
+  );
+}