@clientcasa/sdk 0.1.2 → 0.3.0

package/src/funcs/{webhooks-list-webhooks.ts → webhooks-list.ts}

@@ -4,6 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { ClientCasaCore } from "../core.js";
+import { dlv } from "../lib/dlv.js";
 import { encodeFormQuery } from "../lib/encodings.js";
 import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
@@ -20,31 +21,42 @@ import {
   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 operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
+import {
+  createPageIterator,
+  haltIterator,
+  PageIterator,
+  Paginator,
+} from "../types/operations.js";
 
 /**
  * List webhook subscriptions
  */
-export function webhooksListWebhooks(
+export function webhooksList(
   client: ClientCasaCore,
   security: operations.ListWebhooksSecurity,
   request?: operations.ListWebhooksRequest | undefined,
   options?: RequestOptions,
 ): APIPromise<
-  Result<
-    operations.ListWebhooksResponse,
-    | ClientCasaError
-    | ResponseValidationError
-    | ConnectionError
-    | RequestAbortedError
-    | RequestTimeoutError
-    | InvalidRequestError
-    | UnexpectedClientError
-    | SDKValidationError
+  PageIterator<
+    Result<
+      operations.ListWebhooksResponse,
+      | errors.ApiError
+      | ClientCasaError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    { page: number }
   >
 > {
   return new APIPromise($do(
@@ -62,16 +74,20 @@ async function $do(
   options?: RequestOptions,
 ): Promise<
   [
-    Result<
-      operations.ListWebhooksResponse,
-      | ClientCasaError
-      | ResponseValidationError
-      | ConnectionError
-      | RequestAbortedError
-      | RequestTimeoutError
-      | InvalidRequestError
-      | UnexpectedClientError
-      | SDKValidationError
+    PageIterator<
+      Result<
+        operations.ListWebhooksResponse,
+        | errors.ApiError
+        | ClientCasaError
+        | ResponseValidationError
+        | ConnectionError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | InvalidRequestError
+        | UnexpectedClientError
+        | SDKValidationError
+      >,
+      { page: number }
     >,
     APICall,
   ]
@@ -83,7 +99,7 @@ async function $do(
     "Input validation failed",
   );
   if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
+    return [haltIterator(parsed), { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
@@ -129,8 +145,18 @@ async function $do(
     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", "500", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["429", "5XX"],
   };
 
   const requestRes = client._createRequest(context, {
@@ -145,7 +171,7 @@ async function $do(
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
   }, options);
   if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
+    return [haltIterator(requestRes), { status: "invalid" }];
   }
   const req = requestRes.value;
 
@@ -157,12 +183,17 @@ async function $do(
     retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
+    return [haltIterator(doResult), { status: "request-error", request: req }];
   }
   const response = doResult.value;
 
-  const [result] = await M.match<
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result, raw] = await M.match<
     operations.ListWebhooksResponse,
+    | errors.ApiError
     | ClientCasaError
     | ResponseValidationError
     | ConnectionError
@@ -172,13 +203,74 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(200, operations.ListWebhooksResponse$inboundSchema),
+    M.json(200, operations.ListWebhooksResponse$inboundSchema, {
+      key: "Result",
+    }),
+    M.jsonErr([400, 401, 403, 429], errors.ApiError$inboundSchema),
+    M.jsonErr(500, errors.ApiError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req);
+  )(response, req, { extraFields: responseFields });
   if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response,
+    }];
   }
 
-  return [result, { status: "complete", request: req, response }];
+  const nextFunc = (
+    responseData: unknown,
+  ): {
+    next: Paginator<
+      Result<
+        operations.ListWebhooksResponse,
+        | errors.ApiError
+        | ClientCasaError
+        | ResponseValidationError
+        | ConnectionError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | InvalidRequestError
+        | UnexpectedClientError
+        | SDKValidationError
+      >
+    >;
+    "~next"?: { page: number };
+  } => {
+    const page = request?.page ?? 1;
+    const nextPage = page + 1;
+
+    if (!responseData) {
+      return { next: () => null };
+    }
+    const results = dlv(responseData, "data");
+    if (!Array.isArray(results) || !results.length) {
+      return { next: () => null };
+    }
+    const limit = request?.pageSize ?? 25;
+    if (results.length < limit) {
+      return { next: () => null };
+    }
+
+    const nextVal = () =>
+      webhooksList(
+        client,
+        security,
+        {
+          ...request!,
+          page: nextPage,
+        },
+        options,
+      );
+
+    return { next: nextVal, "~next": { page: nextPage } };
+  };
+
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v) => !v.ok) }, {
+    status: "complete",
+    request: req,
+    response,
+  }];
 }

package/src/funcs/{webhooks-update-webhook.ts → webhooks-update.ts}

@@ -20,6 +20,7 @@ import {
   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";
@@ -33,7 +34,7 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Pass `secret: null` to remove the signing secret. Pass a new string to rotate.
  */
-export function webhooksUpdateWebhook(
+export function webhooksUpdate(
   client: ClientCasaCore,
   security: operations.UpdateWebhookSecurity,
   request: operations.UpdateWebhookRequest,
@@ -41,6 +42,7 @@ export function webhooksUpdateWebhook(
 ): APIPromise<
   Result<
     models.Webhook,
+    | errors.ApiError
     | ClientCasaError
     | ResponseValidationError
     | ConnectionError
@@ -68,6 +70,7 @@ async function $do(
   [
     Result<
       models.Webhook,
+      | errors.ApiError
       | ClientCasaError
       | ResponseValidationError
       | ConnectionError
@@ -132,8 +135,18 @@ async function $do(
     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", "500", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["429", "5XX"],
   };
 
   const requestRes = client._createRequest(context, {
@@ -163,8 +176,13 @@ async function $do(
   }
   const response = doResult.value;
 
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
   const [result] = await M.match<
     models.Webhook,
+    | errors.ApiError
     | ClientCasaError
     | ResponseValidationError
     | ConnectionError
@@ -175,9 +193,11 @@ async function $do(
     | 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);
+  )(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }

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.2",
-  genVersion: "2.884.4",
-  userAgent: "speakeasy-sdk/typescript 0.1.2 2.884.4 1.0.0 @clientcasa/sdk",
+  sdkVersion: "0.3.0",
+  genVersion: "2.885.1",
+  userAgent: "speakeasy-sdk/typescript 0.3.0 2.885.1 1.0.0 @clientcasa/sdk",
 } as const;

package/src/models/api-error.ts

@@ -0,0 +1,51 @@
+/*
+ * 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",
+  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-create.ts

@@ -28,6 +28,15 @@ export const CatalogItemCreateType = {
 } as const;
 export type CatalogItemCreateType = ClosedEnum<typeof CatalogItemCreateType>;
 
+export const CatalogItemCreatePricingMode = {
+  Fixed: "fixed",
+  Hourly: "hourly",
+  Bom: "bom",
+} as const;
+export type CatalogItemCreatePricingMode = ClosedEnum<
+  typeof CatalogItemCreatePricingMode
+>;
+
 export const CatalogItemCreateStatus = {
   Active: "active",
   Paused: "paused",
@@ -46,6 +55,7 @@ export type CatalogItemCreate = {
   unit?: CatalogItemCreateUnit | undefined;
   defaultFrequency?: CatalogItemCreateDefaultFrequency | undefined;
   type: CatalogItemCreateType;
+  pricingMode?: CatalogItemCreatePricingMode | undefined;
   /**
    * UUID v4
    */
@@ -72,6 +82,11 @@ export const CatalogItemCreateType$outboundSchema: z.ZodMiniEnum<
   typeof CatalogItemCreateType
 > = z.enum(CatalogItemCreateType);
 
+/** @internal */
+export const CatalogItemCreatePricingMode$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemCreatePricingMode
+> = z.enum(CatalogItemCreatePricingMode);
+
 /** @internal */
 export const CatalogItemCreateStatus$outboundSchema: z.ZodMiniEnum<
   typeof CatalogItemCreateStatus
@@ -87,6 +102,7 @@ export type CatalogItemCreate$Outbound = {
   unit: string;
   defaultFrequency: string;
   type: string;
+  pricingMode: string;
   taxCategoryId?: string | undefined;
   status: string;
   clientId?: string | undefined;
@@ -108,6 +124,7 @@ export const CatalogItemCreate$outboundSchema: z.ZodMiniType<
     "one-time",
   ),
   type: CatalogItemCreateType$outboundSchema,
+  pricingMode: z._default(CatalogItemCreatePricingMode$outboundSchema, "fixed"),
   taxCategoryId: z.optional(z.string()),
   status: z._default(CatalogItemCreateStatus$outboundSchema, "active"),
   clientId: z.optional(z.string()),

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-update.ts

@@ -28,6 +28,15 @@ export const CatalogItemUpdateType = {
 } as const;
 export type CatalogItemUpdateType = ClosedEnum<typeof CatalogItemUpdateType>;
 
+export const CatalogItemUpdatePricingMode = {
+  Fixed: "fixed",
+  Hourly: "hourly",
+  Bom: "bom",
+} as const;
+export type CatalogItemUpdatePricingMode = ClosedEnum<
+  typeof CatalogItemUpdatePricingMode
+>;
+
 export const CatalogItemUpdateStatus = {
   Active: "active",
   Paused: "paused",
@@ -46,6 +55,7 @@ export type CatalogItemUpdate = {
   unit?: CatalogItemUpdateUnit | undefined;
   defaultFrequency?: CatalogItemUpdateDefaultFrequency | undefined;
   type?: CatalogItemUpdateType | undefined;
+  pricingMode?: CatalogItemUpdatePricingMode | undefined;
   /**
    * UUID v4
    */
@@ -72,6 +82,11 @@ export const CatalogItemUpdateType$outboundSchema: z.ZodMiniEnum<
   typeof CatalogItemUpdateType
 > = z.enum(CatalogItemUpdateType);
 
+/** @internal */
+export const CatalogItemUpdatePricingMode$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemUpdatePricingMode
+> = z.enum(CatalogItemUpdatePricingMode);
+
 /** @internal */
 export const CatalogItemUpdateStatus$outboundSchema: z.ZodMiniEnum<
   typeof CatalogItemUpdateStatus
@@ -87,6 +102,7 @@ export type CatalogItemUpdate$Outbound = {
   unit: string;
   defaultFrequency: string;
   type?: string | undefined;
+  pricingMode: string;
   taxCategoryId?: string | undefined;
   status: string;
   clientId?: string | undefined;
@@ -108,6 +124,7 @@ export const CatalogItemUpdate$outboundSchema: z.ZodMiniType<
     "one-time",
   ),
   type: z.optional(CatalogItemUpdateType$outboundSchema),
+  pricingMode: z._default(CatalogItemUpdatePricingMode$outboundSchema, "fixed"),
   taxCategoryId: z.optional(z.string()),
   status: z._default(CatalogItemUpdateStatus$outboundSchema, "active"),
   clientId: z.optional(z.string()),

package/src/models/catalog-item.ts

@@ -33,6 +33,13 @@ export const CatalogItemType = {
 } as const;
 export type CatalogItemType = OpenEnum<typeof CatalogItemType>;
 
+export const CatalogItemPricingMode = {
+  Fixed: "fixed",
+  Hourly: "hourly",
+  Bom: "bom",
+} as const;
+export type CatalogItemPricingMode = OpenEnum<typeof CatalogItemPricingMode>;
+
 export const CatalogItemStatus = {
   Active: "active",
   Paused: "paused",
@@ -53,6 +60,7 @@ export type CatalogItem = {
   unit: CatalogItemUnit;
   defaultFrequency: CatalogItemDefaultFrequency;
   type: CatalogItemType;
+  pricingMode: CatalogItemPricingMode;
   /**
    * UUID v4
    */
@@ -90,6 +98,12 @@ export const CatalogItemType$inboundSchema: z.ZodMiniType<
   unknown
 > = openEnums.inboundSchema(CatalogItemType);
 
+/** @internal */
+export const CatalogItemPricingMode$inboundSchema: z.ZodMiniType<
+  CatalogItemPricingMode,
+  unknown
+> = openEnums.inboundSchema(CatalogItemPricingMode);
+
 /** @internal */
 export const CatalogItemStatus$inboundSchema: z.ZodMiniType<
   CatalogItemStatus,
@@ -108,6 +122,7 @@ export const CatalogItem$inboundSchema: z.ZodMiniType<CatalogItem, unknown> = z
     unit: CatalogItemUnit$inboundSchema,
     defaultFrequency: CatalogItemDefaultFrequency$inboundSchema,
     type: CatalogItemType$inboundSchema,
+    pricingMode: CatalogItemPricingMode$inboundSchema,
     taxCategoryId: types.nullable(types.string()),
     status: CatalogItemStatus$inboundSchema,
     clientId: types.nullable(types.string()),

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