@clientcasa/sdk 0.1.3 → 0.4.0

package/src/funcs/webhooks-update.ts

@@ -0,0 +1,206 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClientCasaCore } from "../core.js";
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { resolveSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { ClientCasaError } from "../models/errors/client-casa-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Update a webhook
+ *
+ * @remarks
+ * Pass `secret: null` to remove the signing secret. Pass a new string to rotate.
+ */
+export function webhooksUpdate(
+  client: ClientCasaCore,
+  security: operations.UpdateWebhookSecurity,
+  request: operations.UpdateWebhookRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    models.Webhook,
+    | errors.ApiError
+    | ClientCasaError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    security,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: ClientCasaCore,
+  security: operations.UpdateWebhookSecurity,
+  request: operations.UpdateWebhookRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      models.Webhook,
+      | errors.ApiError
+      | ClientCasaError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => z.parse(operations.UpdateWebhookRequest$outboundSchema, value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.body, { explode: true });
+
+  const pathParams = {
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+  const path = pathToFunc("/api/v1/webhooks/{id}")(pathParams);
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const requestSecurity = resolveSecurity(
+    [
+      {
+        fieldName: "x-api-key",
+        type: "apiKey:header",
+        value: security?.apiKey,
+      },
+    ],
+    [
+      {
+        fieldName: "Authorization",
+        type: "http:bearer",
+        value: security?.bearer,
+      },
+    ],
+  );
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "updateWebhook",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 30000,
+          exponent: 1.5,
+          maxElapsedTime: 30000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "5XX"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    models.Webhook,
+    | errors.ApiError
+    | ClientCasaError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, models.Webhook$inboundSchema),
+    M.jsonErr([400, 401, 403, 404, 429], errors.ApiError$inboundSchema),
+    M.jsonErr(500, errors.ApiError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/hooks/types.ts

@@ -15,6 +15,7 @@ export type HookContext = {
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;
   options: SDKOptions;
+  timeoutMs?: number;
 };
 
 export type Awaitable<T> = T | Promise<T>;

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.1.3",
-  genVersion: "2.885.1",
-  userAgent: "speakeasy-sdk/typescript 0.1.3 2.885.1 1.0.0 @clientcasa/sdk",
+  sdkVersion: "0.4.0",
+  genVersion: "2.899.0",
+  userAgent: "speakeasy-sdk/typescript 0.4.0 2.899.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

@@ -0,0 +1,52 @@
+/*
+ * 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 Code = {
+  Unauthorized: "unauthorized",
+  Forbidden: "forbidden",
+  NotFound: "not_found",
+  InvalidRequest: "invalid_request",
+  RateLimited: "rate_limited",
+  Conflict: "conflict",
+  Gone: "gone",
+  InternalError: "internal_error",
+} as const;
+export type Code = OpenEnum<typeof Code>;
+
+export type ErrorT = {
+  code: Code;
+  message: string;
+  requestId: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Code$inboundSchema: z.ZodMiniType<Code, unknown> = openEnums
+  .inboundSchema(Code);
+
+/** @internal */
+export const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown> = z.object({
+  code: Code$inboundSchema,
+  message: types.string(),
+  requestId: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function errorFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}

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

package/src/models/catalog-item-list.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { CatalogItem, CatalogItem$inboundSchema } from "./catalog-item.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+} from "./pagination-meta.js";
+
+export type CatalogItemList = {
+  data: Array<CatalogItem>;
+  pagination: PaginationMeta;
+};
+
+/** @internal */
+export const CatalogItemList$inboundSchema: z.ZodMiniType<
+  CatalogItemList,
+  unknown
+> = z.object({
+  data: z.array(CatalogItem$inboundSchema),
+  pagination: PaginationMeta$inboundSchema,
+});
+
+export function catalogItemListFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogItemList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogItemList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogItemList' from JSON`,
+  );
+}

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