@crevio/sdk 0.4.22 → 0.5.1

package/src/models/filecreateresponse.ts

@@ -5,18 +5,35 @@
 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 type FileCreateResponseKind = {};
-
-export type FileCreateResponseUploadStatus = {};
-
-export type FileCreateResponseUrl = {};
-
-export type FileCreateResponseCreatedAt = {};
-
-export type FileCreateResponseUpdatedAt = {};
+export const FileCreateResponseKind = {
+  File: "file",
+  ExternalVideo: "external_video",
+} as const;
+export type FileCreateResponseKind = ClosedEnum<typeof FileCreateResponseKind>;
+
+export const FileCreateResponseUploadStatus = {
+  Pending: "pending",
+  Processing: "processing",
+  Ready: "ready",
+  Failed: "failed",
+} as const;
+export type FileCreateResponseUploadStatus = ClosedEnum<
+  typeof FileCreateResponseUploadStatus
+>;
+
+export const FileCreateResponseSource = {
+  Upload: "upload",
+  UrlImport: "url_import",
+  ExternalVideo: "external_video",
+  Generation: "generation",
+} as const;
+export type FileCreateResponseSource = ClosedEnum<
+  typeof FileCreateResponseSource
+>;
 
 export type UploadHeaders = {};
 
@@ -25,102 +42,37 @@ export type FileCreateResponse = {
   id: string;
   kind: FileCreateResponseKind;
   uploadStatus: FileCreateResponseUploadStatus;
-  url: FileCreateResponseUrl;
-  createdAt: FileCreateResponseCreatedAt;
-  updatedAt: FileCreateResponseUpdatedAt;
-  filename: string;
-  contentType: string;
-  size: number;
-  provider: string;
-  fileUrl: string;
+  source: FileCreateResponseSource;
+  title: string | null;
+  description: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+  url: string | null;
+  tags: Array<string> | null;
+  sourceJobId: string | null;
+  filename: string | null;
+  contentType: string | null;
+  size: number | null;
+  provider: string | null;
+  fileUrl: string | null;
   uploadUrl?: string | null | undefined;
   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`,
-  );
-}
+export const FileCreateResponseKind$inboundSchema: z.ZodNativeEnum<
+  typeof FileCreateResponseKind
+> = z.nativeEnum(FileCreateResponseKind);
 
 /** @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`,
-  );
-}
+export const FileCreateResponseUploadStatus$inboundSchema: z.ZodNativeEnum<
+  typeof FileCreateResponseUploadStatus
+> = z.nativeEnum(FileCreateResponseUploadStatus);
 
 /** @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`,
-  );
-}
+export const FileCreateResponseSource$inboundSchema: z.ZodNativeEnum<
+  typeof FileCreateResponseSource
+> = z.nativeEnum(FileCreateResponseSource);
 
 /** @internal */
 export const UploadHeaders$inboundSchema: z.ZodType<
@@ -147,16 +99,21 @@ export const FileCreateResponse$inboundSchema: z.ZodType<
 > = z.object({
   object: z.string(),
   id: 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(),
-  provider: z.string(),
-  file_url: z.string(),
+  kind: FileCreateResponseKind$inboundSchema,
+  upload_status: FileCreateResponseUploadStatus$inboundSchema,
+  source: FileCreateResponseSource$inboundSchema,
+  title: z.nullable(z.string()),
+  description: 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)),
+  url: z.nullable(z.string()),
+  tags: z.nullable(z.array(z.string())),
+  source_job_id: z.nullable(z.string()),
+  filename: z.nullable(z.string()),
+  content_type: z.nullable(z.string()),
+  size: z.nullable(z.number().int()),
+  provider: z.nullable(z.string()),
+  file_url: z.nullable(z.string()),
   upload_url: z.nullable(z.string()).optional(),
   upload_headers: z.nullable(z.lazy(() => UploadHeaders$inboundSchema))
     .optional(),
@@ -165,6 +122,7 @@ export const FileCreateResponse$inboundSchema: z.ZodType<
     "upload_status": "uploadStatus",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
+    "source_job_id": "sourceJobId",
     "content_type": "contentType",
     "file_url": "fileUrl",
     "upload_url": "uploadUrl",

package/src/models/filerequest.ts

@@ -8,20 +8,20 @@ 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 = {
+export const FileRequestKind = {
   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 FileRequestKind = ClosedEnum<typeof FileRequestKind>;
 
 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;
+  kind?: FileRequestKind | null | undefined;
   /**
    * Required when kind=external_video, or for server-side URL imports of files.
    */
@@ -33,8 +33,9 @@ export type FileRequest = {
 };
 
 /** @internal */
-export const KindEnum$outboundSchema: z.ZodNativeEnum<typeof KindEnum> = z
-  .nativeEnum(KindEnum);
+export const FileRequestKind$outboundSchema: z.ZodNativeEnum<
+  typeof FileRequestKind
+> = z.nativeEnum(FileRequestKind);
 
 /** @internal */
 export type FileRequest$Outbound = {
@@ -49,7 +50,7 @@ export const FileRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FileRequest
 > = z.object({
-  kind: z.nullable(KindEnum$outboundSchema).optional(),
+  kind: z.nullable(FileRequestKind$outboundSchema).optional(),
   url: z.nullable(z.string()).optional(),
   filename: z.nullable(z.string()).optional(),
 });

package/src/models/fileupdaterequest.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type FileUpdateRequest = {
+  /**
+   * Human-readable display title. Pass null to clear it.
+   */
+  title?: string | null | undefined;
+  /**
+   * Rename the file (updates the stored blob filename). Files only.
+   */
+  filename?: string | null | undefined;
+  /**
+   * Free-text description. Pass null to clear it.
+   */
+  description?: string | null | undefined;
+  /**
+   * Replaces the tag list. Pass an empty array to clear all tags.
+   */
+  tags?: Array<string> | null | undefined;
+  /**
+   * New source URL for an external-video embed (YouTube, Vimeo, or Wistia).
+   */
+  url?: string | null | undefined;
+};
+
+/** @internal */
+export type FileUpdateRequest$Outbound = {
+  title?: string | null | undefined;
+  filename?: string | null | undefined;
+  description?: string | null | undefined;
+  tags?: Array<string> | null | undefined;
+  url?: string | null | undefined;
+};
+
+/** @internal */
+export const FileUpdateRequest$outboundSchema: z.ZodType<
+  FileUpdateRequest$Outbound,
+  z.ZodTypeDef,
+  FileUpdateRequest
+> = z.object({
+  title: z.nullable(z.string()).optional(),
+  filename: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+  tags: z.nullable(z.array(z.string())).optional(),
+  url: z.nullable(z.string()).optional(),
+});
+
+export function fileUpdateRequestToJSON(
+  fileUpdateRequest: FileUpdateRequest,
+): string {
+  return JSON.stringify(
+    FileUpdateRequest$outboundSchema.parse(fileUpdateRequest),
+  );
+}

package/src/models/formation.ts

@@ -0,0 +1,264 @@
+/*
+ * 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";
+import {
+  FormationDocument,
+  FormationDocument$inboundSchema,
+} from "./formationdocument.js";
+
+export const FormationStatus = {
+  AwaitingPayment: "awaiting_payment",
+  Pending: "pending",
+  Submitted: "submitted",
+  Completed: "completed",
+  Failed: "failed",
+} as const;
+export type FormationStatus = ClosedEnum<typeof FormationStatus>;
+
+export const EntityType = {
+  Llc: "LLC",
+} 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",
+  Refunded: "refunded",
+} as const;
+export type PaymentStatus = ClosedEnum<typeof PaymentStatus>;
+
+export type Formation = {
+  id: string;
+  object: string;
+  status: FormationStatus;
+  entityType: EntityType;
+  state: State;
+  naicsCode: NaicsCode;
+  description: Description;
+  nameOptions: Array<any>;
+  members: Array<any>;
+  responsibleParty: ResponsibleParty;
+  mailingAddress: MailingAddress;
+  ein: string | null;
+  formationFilingDate: string | null;
+  adminNotes: Array<any>;
+  doolaError: string | null;
+  stripeCheckoutSessionId: string | null;
+  submittedAt: string | null;
+  createdAt: FormationCreatedAt;
+  updatedAt: FormationUpdatedAt;
+  doolaCompanyId: string | null;
+  verificationId: string | null;
+  paymentStatus: PaymentStatus;
+  documents: Array<FormationDocument>;
+};
+
+/** @internal */
+export const FormationStatus$inboundSchema: z.ZodNativeEnum<
+  typeof FormationStatus
+> = z.nativeEnum(FormationStatus);
+
+/** @internal */
+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,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function responsiblePartyFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponsibleParty, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponsibleParty$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponsibleParty' from JSON`,
+  );
+}
+
+/** @internal */
+export const MailingAddress$inboundSchema: z.ZodType<
+  MailingAddress,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function mailingAddressFromJSON(
+  jsonString: string,
+): SafeParseResult<MailingAddress, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MailingAddress$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MailingAddress' from JSON`,
+  );
+}
+
+/** @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
+> = z.nativeEnum(PaymentStatus);
+
+/** @internal */
+export const Formation$inboundSchema: z.ZodType<
+  Formation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  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),
+  name_options: z.array(z.any()),
+  members: z.array(z.any()),
+  responsible_party: z.lazy(() => ResponsibleParty$inboundSchema),
+  mailing_address: z.lazy(() => MailingAddress$inboundSchema),
+  ein: z.nullable(z.string()),
+  formation_filing_date: z.nullable(z.string()),
+  admin_notes: z.array(z.any()),
+  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),
+  doola_company_id: z.nullable(z.string()),
+  verification_id: z.nullable(z.string()),
+  payment_status: PaymentStatus$inboundSchema,
+  documents: z.array(FormationDocument$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "entity_type": "entityType",
+    "naics_code": "naicsCode",
+    "name_options": "nameOptions",
+    "responsible_party": "responsibleParty",
+    "mailing_address": "mailingAddress",
+    "formation_filing_date": "formationFilingDate",
+    "admin_notes": "adminNotes",
+    "doola_error": "doolaError",
+    "stripe_checkout_session_id": "stripeCheckoutSessionId",
+    "submitted_at": "submittedAt",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+    "doola_company_id": "doolaCompanyId",
+    "verification_id": "verificationId",
+    "payment_status": "paymentStatus",
+  });
+});
+
+export function formationFromJSON(
+  jsonString: string,
+): SafeParseResult<Formation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Formation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Formation' from JSON`,
+  );
+}

package/src/models/formationdocument.ts

@@ -0,0 +1,107 @@
+/*
+ * 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 DocumentType = {
+  ArticlesOfOrganization: "ArticlesOfOrganization",
+  EinLetter: "EinLetter",
+  Mail: "Mail",
+} as const;
+export type DocumentType = ClosedEnum<typeof DocumentType>;
+
+export type FormationDocumentName = {};
+
+export type ContentType = {};
+
+export type FormationDocument = {
+  id: string;
+  object: string;
+  documentType: DocumentType;
+  name: FormationDocumentName;
+  contentType: ContentType;
+  doolaCreatedAt: string | null;
+  doolaLastModifiedAt: string | null;
+  doolaCompanyId: string;
+  downloadUrl: string | null;
+};
+
+/** @internal */
+export const DocumentType$inboundSchema: z.ZodNativeEnum<typeof DocumentType> =
+  z.nativeEnum(DocumentType);
+
+/** @internal */
+export const FormationDocumentName$inboundSchema: z.ZodType<
+  FormationDocumentName,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function formationDocumentNameFromJSON(
+  jsonString: string,
+): SafeParseResult<FormationDocumentName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormationDocumentName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormationDocumentName' 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,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  object: z.string(),
+  document_type: DocumentType$inboundSchema,
+  name: z.lazy(() => FormationDocumentName$inboundSchema),
+  content_type: z.lazy(() => ContentType$inboundSchema),
+  doola_created_at: z.nullable(z.string()),
+  doola_last_modified_at: z.nullable(z.string()),
+  doola_company_id: z.string(),
+  download_url: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "document_type": "documentType",
+    "content_type": "contentType",
+    "doola_created_at": "doolaCreatedAt",
+    "doola_last_modified_at": "doolaLastModifiedAt",
+    "doola_company_id": "doolaCompanyId",
+    "download_url": "downloadUrl",
+  });
+});
+
+export function formationDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<FormationDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormationDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormationDocument' from JSON`,
+  );
+}