@clientcasa/sdk 0.1.0

package/src/sdk/sdk.ts

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { CalendarEvents } from "./calendar-events.js";
+import { CatalogItems } from "./catalog-items.js";
+import { Clients } from "./clients.js";
+import { Contacts } from "./contacts.js";
+import { Contracts } from "./contracts.js";
+import { Inquiries } from "./inquiries.js";
+import { Invoices } from "./invoices.js";
+import { Milestones } from "./milestones.js";
+import { Payments } from "./payments.js";
+import { Payouts } from "./payouts.js";
+import { Projects } from "./projects.js";
+import { Proposals } from "./proposals.js";
+import { TimeEntries } from "./time-entries.js";
+import { Transactions } from "./transactions.js";
+import { Webhooks } from "./webhooks.js";
+
+export class ClientCasa extends ClientSDK {
+  private _clients?: Clients;
+  get clients(): Clients {
+    return (this._clients ??= new Clients(this._options));
+  }
+
+  private _contacts?: Contacts;
+  get contacts(): Contacts {
+    return (this._contacts ??= new Contacts(this._options));
+  }
+
+  private _projects?: Projects;
+  get projects(): Projects {
+    return (this._projects ??= new Projects(this._options));
+  }
+
+  private _invoices?: Invoices;
+  get invoices(): Invoices {
+    return (this._invoices ??= new Invoices(this._options));
+  }
+
+  private _proposals?: Proposals;
+  get proposals(): Proposals {
+    return (this._proposals ??= new Proposals(this._options));
+  }
+
+  private _contracts?: Contracts;
+  get contracts(): Contracts {
+    return (this._contracts ??= new Contracts(this._options));
+  }
+
+  private _payments?: Payments;
+  get payments(): Payments {
+    return (this._payments ??= new Payments(this._options));
+  }
+
+  private _payouts?: Payouts;
+  get payouts(): Payouts {
+    return (this._payouts ??= new Payouts(this._options));
+  }
+
+  private _timeEntries?: TimeEntries;
+  get timeEntries(): TimeEntries {
+    return (this._timeEntries ??= new TimeEntries(this._options));
+  }
+
+  private _milestones?: Milestones;
+  get milestones(): Milestones {
+    return (this._milestones ??= new Milestones(this._options));
+  }
+
+  private _calendarEvents?: CalendarEvents;
+  get calendarEvents(): CalendarEvents {
+    return (this._calendarEvents ??= new CalendarEvents(this._options));
+  }
+
+  private _inquiries?: Inquiries;
+  get inquiries(): Inquiries {
+    return (this._inquiries ??= new Inquiries(this._options));
+  }
+
+  private _transactions?: Transactions;
+  get transactions(): Transactions {
+    return (this._transactions ??= new Transactions(this._options));
+  }
+
+  private _catalogItems?: CatalogItems;
+  get catalogItems(): CatalogItems {
+    return (this._catalogItems ??= new CatalogItems(this._options));
+  }
+
+  private _webhooks?: Webhooks;
+  get webhooks(): Webhooks {
+    return (this._webhooks ??= new Webhooks(this._options));
+  }
+}

package/src/sdk/time-entries.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { timeEntriesCreateTimeEntry } from "../funcs/time-entries-create-time-entry.js";
+import { timeEntriesDeleteTimeEntry } from "../funcs/time-entries-delete-time-entry.js";
+import { timeEntriesGetTimeEntry } from "../funcs/time-entries-get-time-entry.js";
+import { timeEntriesListTimeEntries } from "../funcs/time-entries-list-time-entries.js";
+import { timeEntriesUpdateTimeEntry } from "../funcs/time-entries-update-time-entry.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class TimeEntries extends ClientSDK {
+  /**
+   * List time entries
+   */
+  async listTimeEntries(
+    security: operations.ListTimeEntriesSecurity,
+    request?: operations.ListTimeEntriesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListTimeEntriesResponse> {
+    return unwrapAsync(timeEntriesListTimeEntries(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a time entry
+   */
+  async createTimeEntry(
+    security: operations.CreateTimeEntrySecurity,
+    request: models.TimeEntryCreate,
+    options?: RequestOptions,
+  ): Promise<models.TimeEntry> {
+    return unwrapAsync(timeEntriesCreateTimeEntry(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a time entry
+   */
+  async getTimeEntry(
+    security: operations.GetTimeEntrySecurity,
+    request: operations.GetTimeEntryRequest,
+    options?: RequestOptions,
+  ): Promise<models.TimeEntry> {
+    return unwrapAsync(timeEntriesGetTimeEntry(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a time entry
+   *
+   * @remarks
+   * Time entries billed to a paid invoice cannot be edited (the date field is immutable in that case).
+   */
+  async updateTimeEntry(
+    security: operations.UpdateTimeEntrySecurity,
+    request: operations.UpdateTimeEntryRequest,
+    options?: RequestOptions,
+  ): Promise<models.TimeEntry> {
+    return unwrapAsync(timeEntriesUpdateTimeEntry(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a time entry
+   *
+   * @remarks
+   * Time entries billed to a paid invoice cannot be deleted.
+   */
+  async deleteTimeEntry(
+    security: operations.DeleteTimeEntrySecurity,
+    request: operations.DeleteTimeEntryRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(timeEntriesDeleteTimeEntry(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/transactions.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { transactionsCreateTransaction } from "../funcs/transactions-create-transaction.js";
+import { transactionsDeleteTransaction } from "../funcs/transactions-delete-transaction.js";
+import { transactionsGetTransaction } from "../funcs/transactions-get-transaction.js";
+import { transactionsListTransactions } from "../funcs/transactions-list-transactions.js";
+import { transactionsUpdateTransaction } from "../funcs/transactions-update-transaction.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Transactions extends ClientSDK {
+  /**
+   * List transactions
+   */
+  async listTransactions(
+    security: operations.ListTransactionsSecurity,
+    request?: operations.ListTransactionsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListTransactionsResponse> {
+    return unwrapAsync(transactionsListTransactions(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a transaction (expense or charge)
+   */
+  async createTransaction(
+    security: operations.CreateTransactionSecurity,
+    request: models.TransactionCreate,
+    options?: RequestOptions,
+  ): Promise<models.Transaction> {
+    return unwrapAsync(transactionsCreateTransaction(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a transaction
+   */
+  async getTransaction(
+    security: operations.GetTransactionSecurity,
+    request: operations.GetTransactionRequest,
+    options?: RequestOptions,
+  ): Promise<models.Transaction> {
+    return unwrapAsync(transactionsGetTransaction(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a transaction
+   *
+   * @remarks
+   * Transactions billed to a sent/paid invoice may be frozen — the server will return 409 if so.
+   */
+  async updateTransaction(
+    security: operations.UpdateTransactionSecurity,
+    request: operations.UpdateTransactionRequest,
+    options?: RequestOptions,
+  ): Promise<models.Transaction> {
+    return unwrapAsync(transactionsUpdateTransaction(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a transaction
+   *
+   * @remarks
+   * Transactions billed to a sent/paid invoice cannot be deleted.
+   */
+  async deleteTransaction(
+    security: operations.DeleteTransactionSecurity,
+    request: operations.DeleteTransactionRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(transactionsDeleteTransaction(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/webhooks.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { webhooksCreateWebhook } from "../funcs/webhooks-create-webhook.js";
+import { webhooksDeleteWebhook } from "../funcs/webhooks-delete-webhook.js";
+import { webhooksGetWebhook } from "../funcs/webhooks-get-webhook.js";
+import { webhooksListWebhooks } from "../funcs/webhooks-list-webhooks.js";
+import { webhooksUpdateWebhook } from "../funcs/webhooks-update-webhook.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Webhooks extends ClientSDK {
+  /**
+   * List webhook subscriptions
+   */
+  async listWebhooks(
+    security: operations.ListWebhooksSecurity,
+    request?: operations.ListWebhooksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListWebhooksResponse> {
+    return unwrapAsync(webhooksListWebhooks(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Subscribe to events
+   *
+   * @remarks
+   * Creates a webhook endpoint. URL must be HTTPS. If `secret` is provided, every delivery includes an `X-Signature: sha256=…` header computed over `${X-Webhook-Timestamp}.${body}`.
+   */
+  async createWebhook(
+    security: operations.CreateWebhookSecurity,
+    request: models.WebhookCreate,
+    options?: RequestOptions,
+  ): Promise<models.Webhook> {
+    return unwrapAsync(webhooksCreateWebhook(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a webhook
+   */
+  async getWebhook(
+    security: operations.GetWebhookSecurity,
+    request: operations.GetWebhookRequest,
+    options?: RequestOptions,
+  ): Promise<models.Webhook> {
+    return unwrapAsync(webhooksGetWebhook(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a webhook
+   *
+   * @remarks
+   * Pass `secret: null` to remove the signing secret. Pass a new string to rotate.
+   */
+  async updateWebhook(
+    security: operations.UpdateWebhookSecurity,
+    request: operations.UpdateWebhookRequest,
+    options?: RequestOptions,
+  ): Promise<models.Webhook> {
+    return unwrapAsync(webhooksUpdateWebhook(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a webhook
+   */
+  async deleteWebhook(
+    security: operations.DeleteWebhookSecurity,
+    request: operations.DeleteWebhookRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(webhooksDeleteWebhook(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export const blobLikeSchema: z.ZodMiniType<Blob, Blob> = z.custom<Blob>(
+  isBlobLike,
+  {
+    message: "expected a Blob, File or Blob-like object",
+    abort: true,
+  },
+);
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/types/const-date-time.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export function constDateTime(
+  val: string,
+): z.ZodMiniType<string, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivalent to ${val}`);
+}

package/src/types/default-to-zero-value.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { type Unrecognized, unrecognized } from "./unrecognized.js";
+
+let globalCount = 0;
+let refCount = 0;
+
+export function defaultToZeroValue<T>(value: T): Unrecognized<T> {
+  globalCount++;
+  return unrecognized(value);
+}
+
+export function startCountingDefaultToZeroValue() {
+  refCount++;
+  const start = globalCount;
+  return {
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number) => {
+      const count = globalCount - start;
+      // Reset globalCount back to start, then add only the specified delta
+      globalCount = start + (delta ?? count);
+      if (--refCount === 0) globalCount = 0;
+      return count;
+    },
+  };
+}

package/src/types/enums.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { Unrecognized, unrecognized } from "./unrecognized.js";
+
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.string(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.int(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodMiniType<string, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodMiniType<number, OpenEnum<T>> {
+  return z.int() as any;
+}

package/src/types/fp.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * A monad that captures the result of a function call or an error if it was not
+ * successful. Railway programming, enabled by this type, can be a nicer
+ * alternative to traditional exception throwing because it allows functions to
+ * declare all _known_ errors with static types and then check for them
+ * exhaustively in application code. Thrown exception have a type of `unknown`
+ * and break out of regular control flow of programs making them harder to
+ * inspect and more verbose work with due to try-catch blocks.
+ */
+export type Result<T, E = unknown> =
+  | { ok: true; value: T; error?: never }
+  | { ok: false; value?: never; error: E };
+
+export function OK<V>(value: V): Result<V, never> {
+  return { ok: true, value };
+}
+
+export function ERR<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+/**
+ * unwrap is a convenience function for extracting a value from a result or
+ * throwing if there was an error.
+ */
+export function unwrap<T>(r: Result<T, unknown>): T {
+  if (!r.ok) {
+    throw r.error;
+  }
+  return r.value;
+}
+
+/**
+ * unwrapAsync is a convenience function for resolving a value from a Promise
+ * of a result or rejecting if an error occurred.
+ */
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
+  const r = await pr;
+  if (!r.ok) {
+    throw r.error;
+  }
+
+  return r.value;
+}

package/src/types/index.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export * from "./default-to-zero-value.js";
+export type { ClosedEnum, OpenEnum } from "./enums.js";
+export type { Result } from "./fp.js";
+export type { PageIterator, Paginator } from "./operations.js";
+export { createPageIterator } from "./operations.js";
+export * from "./primitives.js";
+export { RFCDate } from "./rfcdate.js";
+export * from "./unrecognized.js";