@clientcasa/sdk 0.3.0 → 0.4.1

package/src/lib/config.ts

@@ -61,7 +61,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.3.0",
-  genVersion: "2.885.1",
-  userAgent: "speakeasy-sdk/typescript 0.3.0 2.885.1 1.0.0 @clientcasa/sdk",
+  sdkVersion: "0.4.1",
+  genVersion: "2.900.0",
+  userAgent: "speakeasy-sdk/typescript 0.4.1 2.900.0 1.0.0 @clientcasa/sdk",
 } as const;

package/src/lib/sdks.ts

@@ -24,6 +24,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -197,9 +198,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -246,10 +246,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );

package/src/models/api-error.ts

@@ -17,6 +17,7 @@ export const Code = {
   InvalidRequest: "invalid_request",
   RateLimited: "rate_limited",
   Conflict: "conflict",
+  Gone: "gone",
   InternalError: "internal_error",
 } as const;
 export type Code = OpenEnum<typeof Code>;

package/src/models/catalog-item.ts

@@ -40,6 +40,18 @@ export const CatalogItemPricingMode = {
 } as const;
 export type CatalogItemPricingMode = OpenEnum<typeof CatalogItemPricingMode>;
 
+export const Composition = {
+  Atom: "atom",
+  Bundle: "bundle",
+} as const;
+export type Composition = OpenEnum<typeof Composition>;
+
+export const BundlePriceMode = {
+  Sum: "sum",
+  Fixed: "fixed",
+} as const;
+export type BundlePriceMode = OpenEnum<typeof BundlePriceMode>;
+
 export const CatalogItemStatus = {
   Active: "active",
   Paused: "paused",
@@ -61,6 +73,9 @@ export type CatalogItem = {
   defaultFrequency: CatalogItemDefaultFrequency;
   type: CatalogItemType;
   pricingMode: CatalogItemPricingMode;
+  composition: Composition;
+  bundlePriceMode: BundlePriceMode | null;
+  bundleFixedPrice: number | null;
   /**
    * UUID v4
    */
@@ -104,6 +119,16 @@ export const CatalogItemPricingMode$inboundSchema: z.ZodMiniType<
   unknown
 > = openEnums.inboundSchema(CatalogItemPricingMode);
 
+/** @internal */
+export const Composition$inboundSchema: z.ZodMiniType<Composition, unknown> =
+  openEnums.inboundSchema(Composition);
+
+/** @internal */
+export const BundlePriceMode$inboundSchema: z.ZodMiniType<
+  BundlePriceMode,
+  unknown
+> = openEnums.inboundSchema(BundlePriceMode);
+
 /** @internal */
 export const CatalogItemStatus$inboundSchema: z.ZodMiniType<
   CatalogItemStatus,
@@ -123,6 +148,9 @@ export const CatalogItem$inboundSchema: z.ZodMiniType<CatalogItem, unknown> = z
     defaultFrequency: CatalogItemDefaultFrequency$inboundSchema,
     type: CatalogItemType$inboundSchema,
     pricingMode: CatalogItemPricingMode$inboundSchema,
+    composition: Composition$inboundSchema,
+    bundlePriceMode: types.nullable(BundlePriceMode$inboundSchema),
+    bundleFixedPrice: types.nullable(types.number()),
     taxCategoryId: types.nullable(types.string()),
     status: CatalogItemStatus$inboundSchema,
     clientId: types.nullable(types.string()),

package/src/models/client-create.ts

@@ -6,9 +6,13 @@ import * as z from "zod/v4-mini";
 import { ClosedEnum } from "../types/enums.js";
 
 export const ClientCreateStatus = {
-  Prospect: "prospect",
+  New: "new",
+  Contacted: "contacted",
+  Qualified: "qualified",
   Active: "active",
   Inactive: "inactive",
+  Declined: "declined",
+  Spam: "spam",
 } as const;
 export type ClientCreateStatus = ClosedEnum<typeof ClientCreateStatus>;
 

package/src/models/client-document-list.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  ClientDocument,
+  ClientDocument$inboundSchema,
+} from "./client-document.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+} from "./pagination-meta.js";
+
+export type ClientDocumentList = {
+  data: Array<ClientDocument>;
+  pagination: PaginationMeta;
+};
+
+/** @internal */
+export const ClientDocumentList$inboundSchema: z.ZodMiniType<
+  ClientDocumentList,
+  unknown
+> = z.object({
+  data: z.array(ClientDocument$inboundSchema),
+  pagination: PaginationMeta$inboundSchema,
+});
+
+export function clientDocumentListFromJSON(
+  jsonString: string,
+): SafeParseResult<ClientDocumentList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClientDocumentList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClientDocumentList' from JSON`,
+  );
+}

package/src/models/client-document.ts

@@ -0,0 +1,114 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const ClientDocumentKind = {
+  SmartFile: "smart-file",
+} as const;
+export type ClientDocumentKind = ClosedEnum<typeof ClientDocumentKind>;
+
+export const ClientDocumentStatus = {
+  Draft: "draft",
+  Sent: "sent",
+  Viewed: "viewed",
+  InProgress: "in_progress",
+  Accepted: "accepted",
+  Completed: "completed",
+  Expired: "expired",
+  Void: "void",
+} as const;
+export type ClientDocumentStatus = OpenEnum<typeof ClientDocumentStatus>;
+
+export type ClientDocument = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  kind: ClientDocumentKind;
+  title: string | null;
+  status: ClientDocumentStatus;
+  /**
+   * UUID v4
+   */
+  contactId: string | null;
+  /**
+   * UUID v4
+   */
+  clientId: string | null;
+  /**
+   * UUID v4
+   */
+  projectId: string | null;
+  /**
+   * UUID v4
+   */
+  engagementProjectId: string | null;
+  isTemplate: boolean;
+  clientUrl: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  quoteConvertedAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  expiresAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ClientDocumentKind$inboundSchema: z.ZodMiniEnum<
+  typeof ClientDocumentKind
+> = z.enum(ClientDocumentKind);
+
+/** @internal */
+export const ClientDocumentStatus$inboundSchema: z.ZodMiniType<
+  ClientDocumentStatus,
+  unknown
+> = openEnums.inboundSchema(ClientDocumentStatus);
+
+/** @internal */
+export const ClientDocument$inboundSchema: z.ZodMiniType<
+  ClientDocument,
+  unknown
+> = z.object({
+  id: types.string(),
+  kind: ClientDocumentKind$inboundSchema,
+  title: types.nullable(types.string()),
+  status: ClientDocumentStatus$inboundSchema,
+  contactId: types.nullable(types.string()),
+  clientId: types.nullable(types.string()),
+  projectId: types.nullable(types.string()),
+  engagementProjectId: types.nullable(types.string()),
+  isTemplate: types.boolean(),
+  clientUrl: types.nullable(types.string()),
+  quoteConvertedAt: types.nullable(types.date()),
+  expiresAt: types.nullable(types.date()),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+export function clientDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<ClientDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClientDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClientDocument' from JSON`,
+  );
+}

package/src/models/client-update.ts

@@ -6,9 +6,13 @@ import * as z from "zod/v4-mini";
 import { ClosedEnum } from "../types/enums.js";
 
 export const ClientUpdateStatus = {
-  Prospect: "prospect",
+  New: "new",
+  Contacted: "contacted",
+  Qualified: "qualified",
   Active: "active",
   Inactive: "inactive",
+  Declined: "declined",
+  Spam: "spam",
 } as const;
 export type ClientUpdateStatus = ClosedEnum<typeof ClientUpdateStatus>;
 

package/src/models/client.ts

@@ -11,9 +11,13 @@ import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
 export const ClientStatus = {
-  Prospect: "prospect",
+  New: "new",
+  Contacted: "contacted",
+  Qualified: "qualified",
   Active: "active",
   Inactive: "inactive",
+  Declined: "declined",
+  Spam: "spam",
 } as const;
 export type ClientStatus = OpenEnum<typeof ClientStatus>;
 

package/src/models/contact.ts

@@ -35,7 +35,7 @@ export type Contact = {
   /**
    * UUID v4
    */
-  inquiryId: string | null;
+  sourceSubmissionId: string | null;
   /**
    * ISO 8601 timestamp (UTC)
    */
@@ -60,7 +60,7 @@ export const Contact$inboundSchema: z.ZodMiniType<Contact, unknown> = z.object({
   role: ContactRole$inboundSchema,
   isPrimary: types.boolean(),
   clientId: types.nullable(types.string()),
-  inquiryId: types.nullable(types.string()),
+  sourceSubmissionId: types.nullable(types.string()),
   createdAt: types.date(),
   updatedAt: types.date(),
 });

package/src/models/contract-create.ts

@@ -14,10 +14,6 @@ export type ContractCreate = {
    * UUID v4
    */
   billingContactId?: string | undefined;
-  /**
-   * UUID v4
-   */
-  proposalId?: string | undefined;
   /**
    * UUID v4
    */
@@ -37,7 +33,6 @@ export type ContractCreate$Outbound = {
   title: string;
   clientId: string;
   billingContactId?: string | undefined;
-  proposalId?: string | undefined;
   projectId?: string | undefined;
   sourceTemplateId?: string | undefined;
   issueDate?: string | undefined;
@@ -54,7 +49,6 @@ export const ContractCreate$outboundSchema: z.ZodMiniType<
   title: z.string(),
   clientId: z.string(),
   billingContactId: z.optional(z.string()),
-  proposalId: z.optional(z.string()),
   projectId: z.optional(z.string()),
   sourceTemplateId: z.optional(z.string()),
   issueDate: z.optional(

package/src/models/contract.ts

@@ -73,10 +73,6 @@ export type Contract = {
    * UUID v4
    */
   billingContactId: string | null;
-  /**
-   * UUID v4
-   */
-  proposalId: string | null;
   /**
    * UUID v4
    */
@@ -173,7 +169,6 @@ export const Contract$inboundSchema: z.ZodMiniType<Contract, unknown> = z
     title: types.string(),
     clientId: types.string(),
     billingContactId: types.nullable(types.string()),
-    proposalId: types.nullable(types.string()),
     projectId: types.nullable(types.string()),
     sourceTemplateId: types.nullable(types.string()),
     status: ContractStatus$inboundSchema,

package/src/models/{inquiry-list.ts → form-list.ts}

@@ -6,30 +6,30 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
-import { Inquiry, Inquiry$inboundSchema } from "./inquiry.js";
+import { Form, Form$inboundSchema } from "./form.js";
 import {
   PaginationMeta,
   PaginationMeta$inboundSchema,
 } from "./pagination-meta.js";
 
-export type InquiryList = {
-  data: Array<Inquiry>;
+export type FormList = {
+  data: Array<Form>;
   pagination: PaginationMeta;
 };
 
 /** @internal */
-export const InquiryList$inboundSchema: z.ZodMiniType<InquiryList, unknown> = z
+export const FormList$inboundSchema: z.ZodMiniType<FormList, unknown> = z
   .object({
-    data: z.array(Inquiry$inboundSchema),
+    data: z.array(Form$inboundSchema),
     pagination: PaginationMeta$inboundSchema,
   });
 
-export function inquiryListFromJSON(
+export function formListFromJSON(
   jsonString: string,
-): SafeParseResult<InquiryList, SDKValidationError> {
+): SafeParseResult<FormList, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => InquiryList$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'InquiryList' from JSON`,
+    (x) => FormList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormList' from JSON`,
   );
 }

package/src/models/form-submission-answer.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type FormSubmissionAnswer = {
+  fieldId: string;
+  question: string;
+  answer: string;
+};
+
+/** @internal */
+export const FormSubmissionAnswer$inboundSchema: z.ZodMiniType<
+  FormSubmissionAnswer,
+  unknown
+> = z.object({
+  fieldId: types.string(),
+  question: types.string(),
+  answer: types.string(),
+});
+
+export function formSubmissionAnswerFromJSON(
+  jsonString: string,
+): SafeParseResult<FormSubmissionAnswer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormSubmissionAnswer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormSubmissionAnswer' from JSON`,
+  );
+}

package/src/models/form-submission-list.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  FormSubmission,
+  FormSubmission$inboundSchema,
+} from "./form-submission.js";
+import {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+} from "./pagination-meta.js";
+
+export type FormSubmissionList = {
+  data: Array<FormSubmission>;
+  pagination: PaginationMeta;
+};
+
+/** @internal */
+export const FormSubmissionList$inboundSchema: z.ZodMiniType<
+  FormSubmissionList,
+  unknown
+> = z.object({
+  data: z.array(FormSubmission$inboundSchema),
+  pagination: PaginationMeta$inboundSchema,
+});
+
+export function formSubmissionListFromJSON(
+  jsonString: string,
+): SafeParseResult<FormSubmissionList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FormSubmissionList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FormSubmissionList' from JSON`,
+  );
+}

package/src/models/form-submission.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  FormSubmissionAnswer,
+  FormSubmissionAnswer$inboundSchema,
+} from "./form-submission-answer.js";
+
+export const FormSubmissionKind = {
+  Inquiry: "inquiry",
+  Questionnaire: "questionnaire",
+} as const;
+export type FormSubmissionKind = OpenEnum<typeof FormSubmissionKind>;
+
+export const FormSubmissionStatus = {
+  InProgress: "in_progress",
+  Submitted: "submitted",
+} as const;
+export type FormSubmissionStatus = OpenEnum<typeof FormSubmissionStatus>;
+
+export type FormSubmission = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  /**
+   * UUID v4
+   */
+  formId: string;
+  kind: FormSubmissionKind | null;
+  status: FormSubmissionStatus;
+  /**
+   * UUID v4
+   */
+  contactId: string | null;
+  /**
+   * UUID v4
+   */
+  clientId: string | null;
+  source: string | null;
+  submittedAt: Date | null;
+  answers: Array<FormSubmissionAnswer> | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const FormSubmissionKind$inboundSchema: z.ZodMiniType<
+  FormSubmissionKind,
+  unknown
+> = openEnums.inboundSchema(FormSubmissionKind);
+
+/** @internal */
+export const FormSubmissionStatus$inboundSchema: z.ZodMiniType<
+  FormSubmissionStatus,
+  unknown
+> = openEnums.inboundSchema(FormSubmissionStatus);
+
+/** @internal */
+export const FormSubmission$inboundSchema: z.ZodMiniType<
+  FormSubmission,
+  unknown
+> = z.object({
+  id: types.string(),
+  formId: types.string(),
+  kind: types.nullable(FormSubmissionKind$inboundSchema),
+  status: FormSubmissionStatus$inboundSchema,
+  contactId: types.nullable(types.string()),
+  clientId: types.nullable(types.string()),
+  source: types.nullable(types.string()),
+  submittedAt: types.nullable(types.date()),
+  answers: types.nullable(z.array(FormSubmissionAnswer$inboundSchema)),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+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/form.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const FormKind = {
+  Inquiry: "inquiry",
+  Questionnaire: "questionnaire",
+} as const;
+export type FormKind = OpenEnum<typeof FormKind>;
+
+export type Form = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  name: string;
+  title: string | null;
+  description: string | null;
+  kind: FormKind;
+  slug: string | null;
+  enabled: boolean;
+  isDefault: boolean;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const FormKind$inboundSchema: z.ZodMiniType<FormKind, unknown> =
+  openEnums.inboundSchema(FormKind);
+
+/** @internal */
+export const Form$inboundSchema: z.ZodMiniType<Form, unknown> = z.object({
+  id: types.string(),
+  name: types.string(),
+  title: types.nullable(types.string()),
+  description: types.nullable(types.string()),
+  kind: FormKind$inboundSchema,
+  slug: types.nullable(types.string()),
+  enabled: types.boolean(),
+  isDefault: types.boolean(),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+export function formFromJSON(
+  jsonString: string,
+): SafeParseResult<Form, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Form$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Form' from JSON`,
+  );
+}