@clientcasa/sdk 0.4.1 → 0.6.0

package/src/lib/encodings.ts

@@ -3,7 +3,7 @@
  */
 
 import { bytesToBase64 } from "./base64.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export class EncodingError extends Error {
   constructor(message: string) {

package/src/lib/env.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod/v4-mini";
-import { dlv } from "./dlv.js";
 
 export interface Env {
   CLIENTCASA_API_KEY?: string | undefined;
@@ -38,11 +37,16 @@ export function env(): Env {
     return envMemo;
   }
 
+  const globals = globalThis as {
+    Deno?: { env?: { toObject?: () => Record<string, string | undefined> } };
+    process?: { env?: Record<string, string | undefined> };
+  };
+
   let envObject: Record<string, unknown> = {};
   if (isDeno()) {
-    envObject = (globalThis as any).Deno?.env?.toObject?.() ?? {};
+    envObject = globals.Deno?.env?.toObject?.() ?? {};
   } else {
-    envObject = dlv(globalThis, "process.env") ?? {};
+    envObject = globals.process?.env ?? {};
   }
 
   envMemo = envSchema.parse(envObject);

package/src/lib/matchers.ts

@@ -6,7 +6,7 @@ import { ClientCasaDefaultError } from "../models/errors/client-casa-default-err
 import { ResponseValidationError } from "../models/errors/response-validation-error.js";
 import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export type Encoding =
   | "jsonl"

package/src/lib/primitives.ts

@@ -148,3 +148,19 @@ export function allRequired<V extends Record<string, unknown>>(
 
   return v as ReturnType<typeof allRequired<V>>;
 }
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}

package/src/lib/retries.ts

@@ -194,6 +194,14 @@ async function retryBackoff(
 }
 
 function retryIntervalFromResponse(res: Response): number {
+  const retryAfterMsVal = res.headers.get("retry-after-ms");
+  if (retryAfterMsVal) {
+    const parsedMs = Number(retryAfterMsVal);
+    if (Number.isFinite(parsedMs) && parsedMs >= 0) {
+      return parsedMs;
+    }
+  }
+
   const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
     return 0;

package/src/lib/sdks.ts

@@ -132,27 +132,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);

package/src/models/client-create.ts

@@ -4,6 +4,11 @@
 
 import * as z from "zod/v4-mini";
 import { ClosedEnum } from "../types/enums.js";
+import {
+  ClientTaxSettings,
+  ClientTaxSettings$Outbound,
+  ClientTaxSettings$outboundSchema,
+} from "./client-tax-settings.js";
 
 export const ClientCreateStatus = {
   New: "new",
@@ -20,6 +25,10 @@ export type ClientCreate = {
   name: string;
   status?: ClientCreateStatus | undefined;
   notes?: string | undefined;
+  taxSettings?: ClientTaxSettings | undefined;
+  invoiceRemindersEnabled?: boolean | undefined;
+  attachInvoicePdf?: boolean | undefined;
+  attachReceiptPdf?: boolean | undefined;
 };
 
 /** @internal */
@@ -32,6 +41,10 @@ export type ClientCreate$Outbound = {
   name: string;
   status: string;
   notes?: string | undefined;
+  taxSettings?: ClientTaxSettings$Outbound | undefined;
+  invoiceRemindersEnabled?: boolean | undefined;
+  attachInvoicePdf?: boolean | undefined;
+  attachReceiptPdf?: boolean | undefined;
 };
 
 /** @internal */
@@ -42,6 +55,10 @@ export const ClientCreate$outboundSchema: z.ZodMiniType<
   name: z.string(),
   status: z._default(ClientCreateStatus$outboundSchema, "active"),
   notes: z.optional(z.string()),
+  taxSettings: z.optional(ClientTaxSettings$outboundSchema),
+  invoiceRemindersEnabled: z.optional(z.boolean()),
+  attachInvoicePdf: z.optional(z.boolean()),
+  attachReceiptPdf: z.optional(z.boolean()),
 });
 
 export function clientCreateToJSON(clientCreate: ClientCreate): string {

package/src/models/client-tax-settings.ts

@@ -0,0 +1,58 @@
+/*
+ * 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 ClientTaxSettings = {
+  defaultTaxable: boolean;
+  overrideTaxRate: boolean;
+  taxRate: number | null;
+};
+
+/** @internal */
+export const ClientTaxSettings$inboundSchema: z.ZodMiniType<
+  ClientTaxSettings,
+  unknown
+> = z.object({
+  defaultTaxable: types.boolean(),
+  overrideTaxRate: types.boolean(),
+  taxRate: types.nullable(types.number()),
+});
+/** @internal */
+export type ClientTaxSettings$Outbound = {
+  defaultTaxable: boolean;
+  overrideTaxRate: boolean;
+  taxRate: number | null;
+};
+
+/** @internal */
+export const ClientTaxSettings$outboundSchema: z.ZodMiniType<
+  ClientTaxSettings$Outbound,
+  ClientTaxSettings
+> = z.object({
+  defaultTaxable: z.boolean(),
+  overrideTaxRate: z.boolean(),
+  taxRate: z.nullable(z.number()),
+});
+
+export function clientTaxSettingsToJSON(
+  clientTaxSettings: ClientTaxSettings,
+): string {
+  return JSON.stringify(
+    ClientTaxSettings$outboundSchema.parse(clientTaxSettings),
+  );
+}
+export function clientTaxSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<ClientTaxSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClientTaxSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClientTaxSettings' from JSON`,
+  );
+}

package/src/models/client-update.ts

@@ -4,6 +4,11 @@
 
 import * as z from "zod/v4-mini";
 import { ClosedEnum } from "../types/enums.js";
+import {
+  ClientTaxSettings,
+  ClientTaxSettings$Outbound,
+  ClientTaxSettings$outboundSchema,
+} from "./client-tax-settings.js";
 
 export const ClientUpdateStatus = {
   New: "new",
@@ -20,6 +25,10 @@ export type ClientUpdate = {
   name?: string | undefined;
   status?: ClientUpdateStatus | undefined;
   notes?: string | undefined;
+  taxSettings?: ClientTaxSettings | undefined;
+  invoiceRemindersEnabled?: boolean | undefined;
+  attachInvoicePdf?: boolean | undefined;
+  attachReceiptPdf?: boolean | undefined;
 };
 
 /** @internal */
@@ -32,6 +41,10 @@ export type ClientUpdate$Outbound = {
   name?: string | undefined;
   status: string;
   notes?: string | undefined;
+  taxSettings?: ClientTaxSettings$Outbound | undefined;
+  invoiceRemindersEnabled?: boolean | undefined;
+  attachInvoicePdf?: boolean | undefined;
+  attachReceiptPdf?: boolean | undefined;
 };
 
 /** @internal */
@@ -42,6 +55,10 @@ export const ClientUpdate$outboundSchema: z.ZodMiniType<
   name: z.optional(z.string()),
   status: z._default(ClientUpdateStatus$outboundSchema, "active"),
   notes: z.optional(z.string()),
+  taxSettings: z.optional(ClientTaxSettings$outboundSchema),
+  invoiceRemindersEnabled: z.optional(z.boolean()),
+  attachInvoicePdf: z.optional(z.boolean()),
+  attachReceiptPdf: z.optional(z.boolean()),
 });
 
 export function clientUpdateToJSON(clientUpdate: ClientUpdate): string {

package/src/models/client.ts

@@ -8,6 +8,10 @@ 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 {
+  ClientTaxSettings,
+  ClientTaxSettings$inboundSchema,
+} from "./client-tax-settings.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
 export const ClientStatus = {
@@ -21,6 +25,20 @@ export const ClientStatus = {
 } as const;
 export type ClientStatus = OpenEnum<typeof ClientStatus>;
 
+export const RecurringBillingStatus = {
+  Active: "active",
+  PastDue: "past_due",
+  Paused: "paused",
+  Suspended: "suspended",
+  PendingSetup: "pending_setup",
+} as const;
+export type RecurringBillingStatus = OpenEnum<typeof RecurringBillingStatus>;
+
+export type RecurringBilling = {
+  status: RecurringBillingStatus;
+  nextBillingDate: Date | null;
+};
+
 export type Client = {
   /**
    * UUID v4
@@ -29,6 +47,15 @@ export type Client = {
   name: string;
   status: ClientStatus;
   notes: string | null;
+  taxSettings: ClientTaxSettings;
+  invoiceRemindersEnabled: boolean;
+  attachInvoicePdf: boolean;
+  attachReceiptPdf: boolean;
+  recurringBilling: RecurringBilling | null;
+  /**
+   * UUID v4
+   */
+  sourceSubmissionId: string | null;
   /**
    * ISO 8601 timestamp (UTC)
    */
@@ -43,12 +70,45 @@ export type Client = {
 export const ClientStatus$inboundSchema: z.ZodMiniType<ClientStatus, unknown> =
   openEnums.inboundSchema(ClientStatus);
 
+/** @internal */
+export const RecurringBillingStatus$inboundSchema: z.ZodMiniType<
+  RecurringBillingStatus,
+  unknown
+> = openEnums.inboundSchema(RecurringBillingStatus);
+
+/** @internal */
+export const RecurringBilling$inboundSchema: z.ZodMiniType<
+  RecurringBilling,
+  unknown
+> = z.object({
+  status: RecurringBillingStatus$inboundSchema,
+  nextBillingDate: types.nullable(types.date()),
+});
+
+export function recurringBillingFromJSON(
+  jsonString: string,
+): SafeParseResult<RecurringBilling, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RecurringBilling$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RecurringBilling' from JSON`,
+  );
+}
+
 /** @internal */
 export const Client$inboundSchema: z.ZodMiniType<Client, unknown> = z.object({
   id: types.string(),
   name: types.string(),
   status: ClientStatus$inboundSchema,
   notes: types.nullable(types.string()),
+  taxSettings: ClientTaxSettings$inboundSchema,
+  invoiceRemindersEnabled: types.boolean(),
+  attachInvoicePdf: types.boolean(),
+  attachReceiptPdf: types.boolean(),
+  recurringBilling: types.nullable(
+    z.lazy(() => RecurringBilling$inboundSchema),
+  ),
+  sourceSubmissionId: types.nullable(types.string()),
   createdAt: types.date(),
   updatedAt: types.date(),
 });

package/src/models/document-version-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 {
+  DocumentVersion,
+  DocumentVersion$inboundSchema,
+} from "./document-version.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+} from "./pagination-meta.js";
+
+export type DocumentVersionList = {
+  data: Array<DocumentVersion>;
+  pagination: PaginationMeta;
+};
+
+/** @internal */
+export const DocumentVersionList$inboundSchema: z.ZodMiniType<
+  DocumentVersionList,
+  unknown
+> = z.object({
+  data: z.array(DocumentVersion$inboundSchema),
+  pagination: PaginationMeta$inboundSchema,
+});
+
+export function documentVersionListFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentVersionList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentVersionList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentVersionList' from JSON`,
+  );
+}

package/src/models/document-version.ts

@@ -0,0 +1,175 @@
+/*
+ * 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 DocumentType = {
+  SmartFile: "smart-file",
+  Invoice: "invoice",
+  StandaloneContract: "standalone-contract",
+} as const;
+export type DocumentType = OpenEnum<typeof DocumentType>;
+
+export type DocumentRef = {
+  relationTo: string;
+  value: string;
+};
+
+export const VersionStatus = {
+  Issued: "issued",
+  Superseded: "superseded",
+  Voided: "voided",
+} as const;
+export type VersionStatus = OpenEnum<typeof VersionStatus>;
+
+export const AcceptedBy = {
+  Client: "client",
+  Operator: "operator",
+  Signing: "signing",
+  Backfill: "backfill",
+} as const;
+export type AcceptedBy = OpenEnum<typeof AcceptedBy>;
+
+export type DocumentVersion = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  documentType: DocumentType;
+  /**
+   * UUID v4
+   */
+  documentId: string | null;
+  documentRef: DocumentRef | null;
+  versionNumber: number;
+  subVersionNumber: number;
+  versionStatus: VersionStatus;
+  contentHash: string;
+  currency: string;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  issuedAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  viewedAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  acceptedAt: Date | null;
+  acceptedBy: AcceptedBy | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  supersededAt: Date | null;
+  /**
+   * UUID v4
+   */
+  supersededByVersionId: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  voidedAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  quoteConvertedAt: Date | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  expiresAt: Date | null;
+  /**
+   * UUID v4
+   */
+  engagementProjectId: string | null;
+  /**
+   * UUID v4
+   */
+  parentVersionId: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const DocumentType$inboundSchema: z.ZodMiniType<DocumentType, unknown> =
+  openEnums.inboundSchema(DocumentType);
+
+/** @internal */
+export const DocumentRef$inboundSchema: z.ZodMiniType<DocumentRef, unknown> = z
+  .object({
+    relationTo: types.string(),
+    value: types.string(),
+  });
+
+export function documentRefFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const VersionStatus$inboundSchema: z.ZodMiniType<
+  VersionStatus,
+  unknown
+> = openEnums.inboundSchema(VersionStatus);
+
+/** @internal */
+export const AcceptedBy$inboundSchema: z.ZodMiniType<AcceptedBy, unknown> =
+  openEnums.inboundSchema(AcceptedBy);
+
+/** @internal */
+export const DocumentVersion$inboundSchema: z.ZodMiniType<
+  DocumentVersion,
+  unknown
+> = z.object({
+  id: types.string(),
+  documentType: DocumentType$inboundSchema,
+  documentId: types.nullable(types.string()),
+  documentRef: types.nullable(z.lazy(() => DocumentRef$inboundSchema)),
+  versionNumber: types.number(),
+  subVersionNumber: types.number(),
+  versionStatus: VersionStatus$inboundSchema,
+  contentHash: types.string(),
+  currency: types.string(),
+  issuedAt: types.nullable(types.date()),
+  viewedAt: types.nullable(types.date()),
+  acceptedAt: types.nullable(types.date()),
+  acceptedBy: types.nullable(AcceptedBy$inboundSchema),
+  supersededAt: types.nullable(types.date()),
+  supersededByVersionId: types.nullable(types.string()),
+  voidedAt: types.nullable(types.date()),
+  quoteConvertedAt: types.nullable(types.date()),
+  expiresAt: types.nullable(types.date()),
+  engagementProjectId: types.nullable(types.string()),
+  parentVersionId: types.nullable(types.string()),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+export function documentVersionFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentVersion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentVersion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentVersion' from JSON`,
+  );
+}