@clientcasa/sdk 0.1.3 → 0.4.0

package/src/models/operations/create-calendar-event.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateCalendarEventSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateCalendarEventRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.CalendarEventCreate;
+};
+
 /** @internal */
 export type CreateCalendarEventSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -33,3 +43,33 @@ export function createCalendarEventSecurityToJSON(
     ),
   );
 }
+
+/** @internal */
+export type CreateCalendarEventRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.CalendarEventCreate$Outbound;
+};
+
+/** @internal */
+export const CreateCalendarEventRequest$outboundSchema: z.ZodMiniType<
+  CreateCalendarEventRequest$Outbound,
+  CreateCalendarEventRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.CalendarEventCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createCalendarEventRequestToJSON(
+  createCalendarEventRequest: CreateCalendarEventRequest,
+): string {
+  return JSON.stringify(
+    CreateCalendarEventRequest$outboundSchema.parse(createCalendarEventRequest),
+  );
+}

package/src/models/operations/create-catalog-item.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateCatalogItemSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateCatalogItemRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.CatalogItemCreate;
+};
+
 /** @internal */
 export type CreateCatalogItemSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createCatalogItemSecurityToJSON(
     CreateCatalogItemSecurity$outboundSchema.parse(createCatalogItemSecurity),
   );
 }
+
+/** @internal */
+export type CreateCatalogItemRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.CatalogItemCreate$Outbound;
+};
+
+/** @internal */
+export const CreateCatalogItemRequest$outboundSchema: z.ZodMiniType<
+  CreateCatalogItemRequest$Outbound,
+  CreateCatalogItemRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.CatalogItemCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createCatalogItemRequestToJSON(
+  createCatalogItemRequest: CreateCatalogItemRequest,
+): string {
+  return JSON.stringify(
+    CreateCatalogItemRequest$outboundSchema.parse(createCatalogItemRequest),
+  );
+}

package/src/models/operations/create-client.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateClientSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateClientRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.ClientCreate;
+};
+
 /** @internal */
 export type CreateClientSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createClientSecurityToJSON(
     CreateClientSecurity$outboundSchema.parse(createClientSecurity),
   );
 }
+
+/** @internal */
+export type CreateClientRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.ClientCreate$Outbound;
+};
+
+/** @internal */
+export const CreateClientRequest$outboundSchema: z.ZodMiniType<
+  CreateClientRequest$Outbound,
+  CreateClientRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.ClientCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createClientRequestToJSON(
+  createClientRequest: CreateClientRequest,
+): string {
+  return JSON.stringify(
+    CreateClientRequest$outboundSchema.parse(createClientRequest),
+  );
+}

package/src/models/operations/create-contact.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateContactSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateContactRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.ContactCreate;
+};
+
 /** @internal */
 export type CreateContactSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createContactSecurityToJSON(
     CreateContactSecurity$outboundSchema.parse(createContactSecurity),
   );
 }
+
+/** @internal */
+export type CreateContactRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.ContactCreate$Outbound;
+};
+
+/** @internal */
+export const CreateContactRequest$outboundSchema: z.ZodMiniType<
+  CreateContactRequest$Outbound,
+  CreateContactRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.ContactCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createContactRequestToJSON(
+  createContactRequest: CreateContactRequest,
+): string {
+  return JSON.stringify(
+    CreateContactRequest$outboundSchema.parse(createContactRequest),
+  );
+}

package/src/models/operations/create-contract.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateContractSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateContractRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.ContractCreate;
+};
+
 /** @internal */
 export type CreateContractSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createContractSecurityToJSON(
     CreateContractSecurity$outboundSchema.parse(createContractSecurity),
   );
 }
+
+/** @internal */
+export type CreateContractRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.ContractCreate$Outbound;
+};
+
+/** @internal */
+export const CreateContractRequest$outboundSchema: z.ZodMiniType<
+  CreateContractRequest$Outbound,
+  CreateContractRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.ContractCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createContractRequestToJSON(
+  createContractRequest: CreateContractRequest,
+): string {
+  return JSON.stringify(
+    CreateContractRequest$outboundSchema.parse(createContractRequest),
+  );
+}

package/src/models/operations/create-invoice.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateInvoiceSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateInvoiceRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.InvoiceCreate;
+};
+
 /** @internal */
 export type CreateInvoiceSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createInvoiceSecurityToJSON(
     CreateInvoiceSecurity$outboundSchema.parse(createInvoiceSecurity),
   );
 }
+
+/** @internal */
+export type CreateInvoiceRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.InvoiceCreate$Outbound;
+};
+
+/** @internal */
+export const CreateInvoiceRequest$outboundSchema: z.ZodMiniType<
+  CreateInvoiceRequest$Outbound,
+  CreateInvoiceRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.InvoiceCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createInvoiceRequestToJSON(
+  createInvoiceRequest: CreateInvoiceRequest,
+): string {
+  return JSON.stringify(
+    CreateInvoiceRequest$outboundSchema.parse(createInvoiceRequest),
+  );
+}

package/src/models/operations/create-milestone.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateMilestoneSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateMilestoneRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.MilestoneCreate;
+};
+
 /** @internal */
 export type CreateMilestoneSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createMilestoneSecurityToJSON(
     CreateMilestoneSecurity$outboundSchema.parse(createMilestoneSecurity),
   );
 }
+
+/** @internal */
+export type CreateMilestoneRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.MilestoneCreate$Outbound;
+};
+
+/** @internal */
+export const CreateMilestoneRequest$outboundSchema: z.ZodMiniType<
+  CreateMilestoneRequest$Outbound,
+  CreateMilestoneRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.MilestoneCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createMilestoneRequestToJSON(
+  createMilestoneRequest: CreateMilestoneRequest,
+): string {
+  return JSON.stringify(
+    CreateMilestoneRequest$outboundSchema.parse(createMilestoneRequest),
+  );
+}

package/src/models/operations/create-payment.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreatePaymentSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreatePaymentRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.PaymentCreate;
+};
+
 /** @internal */
 export type CreatePaymentSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createPaymentSecurityToJSON(
     CreatePaymentSecurity$outboundSchema.parse(createPaymentSecurity),
   );
 }
+
+/** @internal */
+export type CreatePaymentRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.PaymentCreate$Outbound;
+};
+
+/** @internal */
+export const CreatePaymentRequest$outboundSchema: z.ZodMiniType<
+  CreatePaymentRequest$Outbound,
+  CreatePaymentRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.PaymentCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createPaymentRequestToJSON(
+  createPaymentRequest: CreatePaymentRequest,
+): string {
+  return JSON.stringify(
+    CreatePaymentRequest$outboundSchema.parse(createPaymentRequest),
+  );
+}

package/src/models/operations/create-project.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateProjectSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateProjectRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.ProjectCreate;
+};
+
 /** @internal */
 export type CreateProjectSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createProjectSecurityToJSON(
     CreateProjectSecurity$outboundSchema.parse(createProjectSecurity),
   );
 }
+
+/** @internal */
+export type CreateProjectRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.ProjectCreate$Outbound;
+};
+
+/** @internal */
+export const CreateProjectRequest$outboundSchema: z.ZodMiniType<
+  CreateProjectRequest$Outbound,
+  CreateProjectRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.ProjectCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createProjectRequestToJSON(
+  createProjectRequest: CreateProjectRequest,
+): string {
+  return JSON.stringify(
+    CreateProjectRequest$outboundSchema.parse(createProjectRequest),
+  );
+}

package/src/models/operations/create-time-entry.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateTimeEntrySecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateTimeEntryRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.TimeEntryCreate;
+};
+
 /** @internal */
 export type CreateTimeEntrySecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createTimeEntrySecurityToJSON(
     CreateTimeEntrySecurity$outboundSchema.parse(createTimeEntrySecurity),
   );
 }
+
+/** @internal */
+export type CreateTimeEntryRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.TimeEntryCreate$Outbound;
+};
+
+/** @internal */
+export const CreateTimeEntryRequest$outboundSchema: z.ZodMiniType<
+  CreateTimeEntryRequest$Outbound,
+  CreateTimeEntryRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.TimeEntryCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createTimeEntryRequestToJSON(
+  createTimeEntryRequest: CreateTimeEntryRequest,
+): string {
+  return JSON.stringify(
+    CreateTimeEntryRequest$outboundSchema.parse(createTimeEntryRequest),
+  );
+}

package/src/models/operations/create-transaction.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateTransactionSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateTransactionRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.TransactionCreate;
+};
+
 /** @internal */
 export type CreateTransactionSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createTransactionSecurityToJSON(
     CreateTransactionSecurity$outboundSchema.parse(createTransactionSecurity),
   );
 }
+
+/** @internal */
+export type CreateTransactionRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.TransactionCreate$Outbound;
+};
+
+/** @internal */
+export const CreateTransactionRequest$outboundSchema: z.ZodMiniType<
+  CreateTransactionRequest$Outbound,
+  CreateTransactionRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.TransactionCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createTransactionRequestToJSON(
+  createTransactionRequest: CreateTransactionRequest,
+): string {
+  return JSON.stringify(
+    CreateTransactionRequest$outboundSchema.parse(createTransactionRequest),
+  );
+}

package/src/models/operations/create-webhook.ts

@@ -3,12 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type CreateWebhookSecurity = {
   apiKey?: string | undefined;
   bearer?: string | undefined;
 };
 
+export type CreateWebhookRequest = {
+  /**
+   * Optional unique key that makes this create safely retryable. Replaying the same key returns the original response instead of creating a duplicate; reusing a key with a different request body returns 409.
+   */
+  idempotencyKey?: string | undefined;
+  body: models.WebhookCreate;
+};
+
 /** @internal */
 export type CreateWebhookSecurity$Outbound = {
   apiKey?: string | undefined;
@@ -31,3 +41,33 @@ export function createWebhookSecurityToJSON(
     CreateWebhookSecurity$outboundSchema.parse(createWebhookSecurity),
   );
 }
+
+/** @internal */
+export type CreateWebhookRequest$Outbound = {
+  "Idempotency-Key"?: string | undefined;
+  body: models.WebhookCreate$Outbound;
+};
+
+/** @internal */
+export const CreateWebhookRequest$outboundSchema: z.ZodMiniType<
+  CreateWebhookRequest$Outbound,
+  CreateWebhookRequest
+> = z.pipe(
+  z.object({
+    idempotencyKey: z.optional(z.string()),
+    body: models.WebhookCreate$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "Idempotency-Key",
+    });
+  }),
+);
+
+export function createWebhookRequestToJSON(
+  createWebhookRequest: CreateWebhookRequest,
+): string {
+  return JSON.stringify(
+    CreateWebhookRequest$outboundSchema.parse(createWebhookRequest),
+  );
+}