@clientcasa/sdk 0.1.0

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

@@ -0,0 +1,122 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const CatalogItemUpdateUnit = {
+  Flat: "flat",
+  Hour: "hour",
+  Each: "each",
+} as const;
+export type CatalogItemUpdateUnit = ClosedEnum<typeof CatalogItemUpdateUnit>;
+
+export const CatalogItemUpdateDefaultFrequency = {
+  OneTime: "one-time",
+  Monthly: "monthly",
+  Quarterly: "quarterly",
+  Annual: "annual",
+} as const;
+export type CatalogItemUpdateDefaultFrequency = ClosedEnum<
+  typeof CatalogItemUpdateDefaultFrequency
+>;
+
+export const CatalogItemUpdateType = {
+  Expense: "expense",
+  Charge: "charge",
+} as const;
+export type CatalogItemUpdateType = ClosedEnum<typeof CatalogItemUpdateType>;
+
+export const CatalogItemUpdateStatus = {
+  Active: "active",
+  Paused: "paused",
+  Archived: "archived",
+} as const;
+export type CatalogItemUpdateStatus = ClosedEnum<
+  typeof CatalogItemUpdateStatus
+>;
+
+export type CatalogItemUpdate = {
+  name?: string | undefined;
+  invoiceLabel?: string | undefined;
+  description?: string | undefined;
+  invoiceDescription?: string | undefined;
+  defaultRate?: number | undefined;
+  unit?: CatalogItemUpdateUnit | undefined;
+  defaultFrequency?: CatalogItemUpdateDefaultFrequency | undefined;
+  type?: CatalogItemUpdateType | undefined;
+  /**
+   * UUID v4
+   */
+  taxCategoryId?: string | undefined;
+  status?: CatalogItemUpdateStatus | undefined;
+  /**
+   * UUID v4
+   */
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const CatalogItemUpdateUnit$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemUpdateUnit
+> = z.enum(CatalogItemUpdateUnit);
+
+/** @internal */
+export const CatalogItemUpdateDefaultFrequency$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemUpdateDefaultFrequency
+> = z.enum(CatalogItemUpdateDefaultFrequency);
+
+/** @internal */
+export const CatalogItemUpdateType$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemUpdateType
+> = z.enum(CatalogItemUpdateType);
+
+/** @internal */
+export const CatalogItemUpdateStatus$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogItemUpdateStatus
+> = z.enum(CatalogItemUpdateStatus);
+
+/** @internal */
+export type CatalogItemUpdate$Outbound = {
+  name?: string | undefined;
+  invoiceLabel?: string | undefined;
+  description?: string | undefined;
+  invoiceDescription?: string | undefined;
+  defaultRate?: number | undefined;
+  unit: string;
+  defaultFrequency: string;
+  type?: string | undefined;
+  taxCategoryId?: string | undefined;
+  status: string;
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const CatalogItemUpdate$outboundSchema: z.ZodMiniType<
+  CatalogItemUpdate$Outbound,
+  CatalogItemUpdate
+> = z.object({
+  name: z.optional(z.string()),
+  invoiceLabel: z.optional(z.string()),
+  description: z.optional(z.string()),
+  invoiceDescription: z.optional(z.string()),
+  defaultRate: z.optional(z.number()),
+  unit: z._default(CatalogItemUpdateUnit$outboundSchema, "flat"),
+  defaultFrequency: z._default(
+    CatalogItemUpdateDefaultFrequency$outboundSchema,
+    "one-time",
+  ),
+  type: z.optional(CatalogItemUpdateType$outboundSchema),
+  taxCategoryId: z.optional(z.string()),
+  status: z._default(CatalogItemUpdateStatus$outboundSchema, "active"),
+  clientId: z.optional(z.string()),
+});
+
+export function catalogItemUpdateToJSON(
+  catalogItemUpdate: CatalogItemUpdate,
+): string {
+  return JSON.stringify(
+    CatalogItemUpdate$outboundSchema.parse(catalogItemUpdate),
+  );
+}

package/src/models/catalog-item.ts

@@ -0,0 +1,126 @@
+/*
+ * 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 CatalogItemUnit = {
+  Flat: "flat",
+  Hour: "hour",
+  Each: "each",
+} as const;
+export type CatalogItemUnit = OpenEnum<typeof CatalogItemUnit>;
+
+export const CatalogItemDefaultFrequency = {
+  OneTime: "one-time",
+  Monthly: "monthly",
+  Quarterly: "quarterly",
+  Annual: "annual",
+} as const;
+export type CatalogItemDefaultFrequency = OpenEnum<
+  typeof CatalogItemDefaultFrequency
+>;
+
+export const CatalogItemType = {
+  Expense: "expense",
+  Charge: "charge",
+} as const;
+export type CatalogItemType = OpenEnum<typeof CatalogItemType>;
+
+export const CatalogItemStatus = {
+  Active: "active",
+  Paused: "paused",
+  Archived: "archived",
+} as const;
+export type CatalogItemStatus = OpenEnum<typeof CatalogItemStatus>;
+
+export type CatalogItem = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  name: string;
+  invoiceLabel: string | null;
+  description: string | null;
+  invoiceDescription: string | null;
+  defaultRate: number | null;
+  unit: CatalogItemUnit;
+  defaultFrequency: CatalogItemDefaultFrequency;
+  type: CatalogItemType;
+  /**
+   * UUID v4
+   */
+  taxCategoryId: string | null;
+  status: CatalogItemStatus;
+  /**
+   * UUID v4
+   */
+  clientId: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const CatalogItemUnit$inboundSchema: z.ZodMiniType<
+  CatalogItemUnit,
+  unknown
+> = openEnums.inboundSchema(CatalogItemUnit);
+
+/** @internal */
+export const CatalogItemDefaultFrequency$inboundSchema: z.ZodMiniType<
+  CatalogItemDefaultFrequency,
+  unknown
+> = openEnums.inboundSchema(CatalogItemDefaultFrequency);
+
+/** @internal */
+export const CatalogItemType$inboundSchema: z.ZodMiniType<
+  CatalogItemType,
+  unknown
+> = openEnums.inboundSchema(CatalogItemType);
+
+/** @internal */
+export const CatalogItemStatus$inboundSchema: z.ZodMiniType<
+  CatalogItemStatus,
+  unknown
+> = openEnums.inboundSchema(CatalogItemStatus);
+
+/** @internal */
+export const CatalogItem$inboundSchema: z.ZodMiniType<CatalogItem, unknown> = z
+  .object({
+    id: types.string(),
+    name: types.string(),
+    invoiceLabel: types.nullable(types.string()),
+    description: types.nullable(types.string()),
+    invoiceDescription: types.nullable(types.string()),
+    defaultRate: types.nullable(types.number()),
+    unit: CatalogItemUnit$inboundSchema,
+    defaultFrequency: CatalogItemDefaultFrequency$inboundSchema,
+    type: CatalogItemType$inboundSchema,
+    taxCategoryId: types.nullable(types.string()),
+    status: CatalogItemStatus$inboundSchema,
+    clientId: types.nullable(types.string()),
+    createdAt: types.date(),
+    updatedAt: types.date(),
+  });
+
+export function catalogItemFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogItem' from JSON`,
+  );
+}

package/src/models/client-create.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ClientCreateStatus = {
+  Prospect: "prospect",
+  Active: "active",
+  Inactive: "inactive",
+} as const;
+export type ClientCreateStatus = ClosedEnum<typeof ClientCreateStatus>;
+
+export type ClientCreate = {
+  name: string;
+  status?: ClientCreateStatus | undefined;
+  notes?: string | undefined;
+};
+
+/** @internal */
+export const ClientCreateStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ClientCreateStatus
+> = z.enum(ClientCreateStatus);
+
+/** @internal */
+export type ClientCreate$Outbound = {
+  name: string;
+  status: string;
+  notes?: string | undefined;
+};
+
+/** @internal */
+export const ClientCreate$outboundSchema: z.ZodMiniType<
+  ClientCreate$Outbound,
+  ClientCreate
+> = z.object({
+  name: z.string(),
+  status: z._default(ClientCreateStatus$outboundSchema, "active"),
+  notes: z.optional(z.string()),
+});
+
+export function clientCreateToJSON(clientCreate: ClientCreate): string {
+  return JSON.stringify(ClientCreate$outboundSchema.parse(clientCreate));
+}

package/src/models/client-update.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ClientUpdateStatus = {
+  Prospect: "prospect",
+  Active: "active",
+  Inactive: "inactive",
+} as const;
+export type ClientUpdateStatus = ClosedEnum<typeof ClientUpdateStatus>;
+
+export type ClientUpdate = {
+  name?: string | undefined;
+  status?: ClientUpdateStatus | undefined;
+  notes?: string | undefined;
+};
+
+/** @internal */
+export const ClientUpdateStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ClientUpdateStatus
+> = z.enum(ClientUpdateStatus);
+
+/** @internal */
+export type ClientUpdate$Outbound = {
+  name?: string | undefined;
+  status: string;
+  notes?: string | undefined;
+};
+
+/** @internal */
+export const ClientUpdate$outboundSchema: z.ZodMiniType<
+  ClientUpdate$Outbound,
+  ClientUpdate
+> = z.object({
+  name: z.optional(z.string()),
+  status: z._default(ClientUpdateStatus$outboundSchema, "active"),
+  notes: z.optional(z.string()),
+});
+
+export function clientUpdateToJSON(clientUpdate: ClientUpdate): string {
+  return JSON.stringify(ClientUpdate$outboundSchema.parse(clientUpdate));
+}

package/src/models/client.ts

@@ -0,0 +1,60 @@
+/*
+ * 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 ClientStatus = {
+  Prospect: "prospect",
+  Active: "active",
+  Inactive: "inactive",
+} as const;
+export type ClientStatus = OpenEnum<typeof ClientStatus>;
+
+export type Client = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  name: string;
+  status: ClientStatus;
+  notes: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ClientStatus$inboundSchema: z.ZodMiniType<ClientStatus, unknown> =
+  openEnums.inboundSchema(ClientStatus);
+
+/** @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()),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+export function clientFromJSON(
+  jsonString: string,
+): SafeParseResult<Client, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Client$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Client' from JSON`,
+  );
+}

package/src/models/contact-create.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ContactCreateRole = {
+  Primary: "primary",
+  Billing: "billing",
+  Other: "other",
+} as const;
+export type ContactCreateRole = ClosedEnum<typeof ContactCreateRole>;
+
+export type ContactCreate = {
+  name: string;
+  email?: string | undefined;
+  phone?: string | undefined;
+  title?: string | undefined;
+  role?: ContactCreateRole | undefined;
+  isPrimary?: boolean | undefined;
+  /**
+   * UUID v4
+   */
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const ContactCreateRole$outboundSchema: z.ZodMiniEnum<
+  typeof ContactCreateRole
+> = z.enum(ContactCreateRole);
+
+/** @internal */
+export type ContactCreate$Outbound = {
+  name: string;
+  email?: string | undefined;
+  phone?: string | undefined;
+  title?: string | undefined;
+  role: string;
+  isPrimary: boolean;
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const ContactCreate$outboundSchema: z.ZodMiniType<
+  ContactCreate$Outbound,
+  ContactCreate
+> = z.object({
+  name: z.string(),
+  email: z.optional(z.string()),
+  phone: z.optional(z.string()),
+  title: z.optional(z.string()),
+  role: z._default(ContactCreateRole$outboundSchema, "other"),
+  isPrimary: z._default(z.boolean(), false),
+  clientId: z.optional(z.string()),
+});
+
+export function contactCreateToJSON(contactCreate: ContactCreate): string {
+  return JSON.stringify(ContactCreate$outboundSchema.parse(contactCreate));
+}

package/src/models/contact-update.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ContactUpdateRole = {
+  Primary: "primary",
+  Billing: "billing",
+  Other: "other",
+} as const;
+export type ContactUpdateRole = ClosedEnum<typeof ContactUpdateRole>;
+
+export type ContactUpdate = {
+  name?: string | undefined;
+  email?: string | undefined;
+  phone?: string | undefined;
+  title?: string | undefined;
+  role?: ContactUpdateRole | undefined;
+  isPrimary?: boolean | undefined;
+  /**
+   * UUID v4
+   */
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const ContactUpdateRole$outboundSchema: z.ZodMiniEnum<
+  typeof ContactUpdateRole
+> = z.enum(ContactUpdateRole);
+
+/** @internal */
+export type ContactUpdate$Outbound = {
+  name?: string | undefined;
+  email?: string | undefined;
+  phone?: string | undefined;
+  title?: string | undefined;
+  role: string;
+  isPrimary: boolean;
+  clientId?: string | undefined;
+};
+
+/** @internal */
+export const ContactUpdate$outboundSchema: z.ZodMiniType<
+  ContactUpdate$Outbound,
+  ContactUpdate
+> = z.object({
+  name: z.optional(z.string()),
+  email: z.optional(z.string()),
+  phone: z.optional(z.string()),
+  title: z.optional(z.string()),
+  role: z._default(ContactUpdateRole$outboundSchema, "other"),
+  isPrimary: z._default(z.boolean(), false),
+  clientId: z.optional(z.string()),
+});
+
+export function contactUpdateToJSON(contactUpdate: ContactUpdate): string {
+  return JSON.stringify(ContactUpdate$outboundSchema.parse(contactUpdate));
+}

package/src/models/contact.ts

@@ -0,0 +1,76 @@
+/*
+ * 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 ContactRole = {
+  Primary: "primary",
+  Billing: "billing",
+  Other: "other",
+} as const;
+export type ContactRole = OpenEnum<typeof ContactRole>;
+
+export type Contact = {
+  /**
+   * UUID v4
+   */
+  id: string;
+  name: string;
+  email: string | null;
+  phone: string | null;
+  title: string | null;
+  role: ContactRole;
+  isPrimary: boolean;
+  /**
+   * UUID v4
+   */
+  clientId: string | null;
+  /**
+   * UUID v4
+   */
+  inquiryId: string | null;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  createdAt: Date;
+  /**
+   * ISO 8601 timestamp (UTC)
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ContactRole$inboundSchema: z.ZodMiniType<ContactRole, unknown> =
+  openEnums.inboundSchema(ContactRole);
+
+/** @internal */
+export const Contact$inboundSchema: z.ZodMiniType<Contact, unknown> = z.object({
+  id: types.string(),
+  name: types.string(),
+  email: types.nullable(types.string()),
+  phone: types.nullable(types.string()),
+  title: types.nullable(types.string()),
+  role: ContactRole$inboundSchema,
+  isPrimary: types.boolean(),
+  clientId: types.nullable(types.string()),
+  inquiryId: types.nullable(types.string()),
+  createdAt: types.date(),
+  updatedAt: types.date(),
+});
+
+export function contactFromJSON(
+  jsonString: string,
+): SafeParseResult<Contact, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Contact$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Contact' from JSON`,
+  );
+}

package/src/models/contract-create.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type ContractCreate = {
+  title: string;
+  /**
+   * UUID v4
+   */
+  clientId: string;
+  /**
+   * UUID v4
+   */
+  billingContactId?: string | undefined;
+  /**
+   * UUID v4
+   */
+  proposalId?: string | undefined;
+  /**
+   * UUID v4
+   */
+  projectId?: string | undefined;
+  /**
+   * UUID v4
+   */
+  sourceTemplateId?: string | undefined;
+  issueDate?: Date | undefined;
+  effectiveDate?: Date | undefined;
+  expirationDate?: Date | undefined;
+  contractValue?: number | undefined;
+};
+
+/** @internal */
+export type ContractCreate$Outbound = {
+  title: string;
+  clientId: string;
+  billingContactId?: string | undefined;
+  proposalId?: string | undefined;
+  projectId?: string | undefined;
+  sourceTemplateId?: string | undefined;
+  issueDate?: string | undefined;
+  effectiveDate?: string | undefined;
+  expirationDate?: string | undefined;
+  contractValue?: number | undefined;
+};
+
+/** @internal */
+export const ContractCreate$outboundSchema: z.ZodMiniType<
+  ContractCreate$Outbound,
+  ContractCreate
+> = z.object({
+  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(
+    z.pipe(
+      z.date(),
+      z.transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+    ),
+  ),
+  effectiveDate: z.optional(
+    z.pipe(
+      z.date(),
+      z.transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+    ),
+  ),
+  expirationDate: z.optional(
+    z.pipe(
+      z.date(),
+      z.transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+    ),
+  ),
+  contractValue: z.optional(z.number()),
+});
+
+export function contractCreateToJSON(contractCreate: ContractCreate): string {
+  return JSON.stringify(ContractCreate$outboundSchema.parse(contractCreate));
+}