contiguity 0.0.1

package/dist/services/otp/new.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { E164PhoneNumber } from "@/types/common";
+export const OTPNewRequest = z.object({
+    /** Recipient's phone number. Must be in E.164 format */
+    to: E164PhoneNumber,
+    /** Language of the OTP message */
+    language: z.string().min(1, "Language cannot be empty"),
+    /** Your app's name (customizes message to 'Your [name] code is...') */
+    name: z.string().min(1, "App name cannot be empty"),
+});
+export const OTPNewResponse = z.object({
+    /** The OTP's ID. Use it to refer to this verification in the future, such as when verifying the OTP or resending it. */
+    otp_id: z.string(),
+});
+// Using the new base response builder - this replaces the manual Flattened/Raw definitions
+export const OTPNewResponseBuilder = createResponse(OTPNewResponse);
+/**
+ * Sends a new OTP to the specified phone number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.otp.new({
+ *   to: "+1234567890",
+ *   language: "en",
+ *   name: "My App"
+ * });
+ * console.log(`OTP ID: ${response.otp_id}`);
+ * ```
+ */
+export async function _otpNew(params) {
+    const validatedParams = OTPNewRequest.parse(params);
+    const response = await this.request("/otp/new", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: OTPNewResponse,
+            raw: OTPNewResponseBuilder.raw
+        }
+    });
+}

package/dist/services/otp/resend.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const OTPResendRequest: z.ZodObject<{
+    otp_id: z.ZodString;
+}, z.core.$strip>;
+export declare const OTPResendResponse: z.ZodObject<{
+    resent: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const OTPResendResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    resent: z.ZodBoolean;
+}, z.core.$strip>>;
+export type OTPResendParams = z.infer<typeof OTPResendRequest>;
+export type OTPResendResponse = z.infer<typeof OTPResendResponse>;
+/**
+ * Resends an OTP to the same phone number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.otp.resend({
+ *   otp_id: "otp_1234567890"
+ * });
+ * console.log(`Resent: ${response.resent}`);
+ * ```
+ */
+export declare function _otpResend(this: any, params: OTPResendParams): Promise<any>;
+//# sourceMappingURL=resend.d.ts.map

package/dist/services/otp/resend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resend.d.ts","sourceRoot":"","sources":["../../../src/services/otp/resend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;iBAG3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;iBAG5B,CAAA;AAGF,eAAO,MAAM,wBAAwB;;kBAAoC,CAAA;AAEzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAcjF"}

package/dist/services/otp/resend.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+export const OTPResendRequest = z.object({
+    /** The OTP ID you received when sending the OTP */
+    otp_id: z.string().min(1, "OTP ID cannot be empty"),
+});
+export const OTPResendResponse = z.object({
+    /** Whether the OTP was resent */
+    resent: z.boolean(),
+});
+// Using the new base response builder
+export const OTPResendResponseBuilder = createResponse(OTPResendResponse);
+/**
+ * Resends an OTP to the same phone number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.otp.resend({
+ *   otp_id: "otp_1234567890"
+ * });
+ * console.log(`Resent: ${response.resent}`);
+ * ```
+ */
+export async function _otpResend(params) {
+    const validatedParams = OTPResendRequest.parse(params);
+    const response = await this.request("/otp/resend", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: OTPResendResponse,
+            raw: OTPResendResponseBuilder.raw
+        }
+    });
+}

package/dist/services/otp/verify.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const OTPVerifyRequest: z.ZodObject<{
+    otp_id: z.ZodString;
+    otp: z.ZodString;
+}, z.core.$strip>;
+export declare const OTPVerifyResponse: z.ZodObject<{
+    verified: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const OTPVerifyResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    verified: z.ZodBoolean;
+}, z.core.$strip>>;
+export type OTPVerifyParams = z.infer<typeof OTPVerifyRequest>;
+export type OTPVerifyResponse = z.infer<typeof OTPVerifyResponse>;
+/**
+ * Verifies an OTP code
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.otp.verify({
+ *   otp_id: "otp_1234567890",
+ *   otp: "123456"
+ * });
+ * console.log(`Verified: ${response.verified}`);
+ * ```
+ */
+export declare function _otpVerify(this: any, params: OTPVerifyParams): Promise<any>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/services/otp/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/services/otp/verify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;iBAG5B,CAAA;AAGF,eAAO,MAAM,wBAAwB;;kBAAoC,CAAA;AAEzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAcjF"}

package/dist/services/otp/verify.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+export const OTPVerifyRequest = z.object({
+    /** The OTP ID you received when sending the OTP */
+    otp_id: z.string().min(1, "OTP ID cannot be empty"),
+    /** The OTP inputted by the user */
+    otp: z.string().min(1, "OTP cannot be empty"),
+});
+export const OTPVerifyResponse = z.object({
+    /** Whether the OTP was verified or not */
+    verified: z.boolean(),
+});
+// Using the new base response builder
+export const OTPVerifyResponseBuilder = createResponse(OTPVerifyResponse);
+/**
+ * Verifies an OTP code
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.otp.verify({
+ *   otp_id: "otp_1234567890",
+ *   otp: "123456"
+ * });
+ * console.log(`Verified: ${response.verified}`);
+ * ```
+ */
+export async function _otpVerify(params) {
+    const validatedParams = OTPVerifyRequest.parse(params);
+    const response = await this.request("/otp/verify", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: OTPVerifyResponse,
+            raw: OTPVerifyResponseBuilder.raw
+        }
+    });
+}

package/dist/services/text/index.d.ts

@@ -0,0 +1,17 @@
+import { ContiguityClient } from "@/client/fetch";
+import { z } from "zod";
+import { TextSendRequest, TextResponse } from "@/services/text/send";
+import type { WithMetadata } from "@/types/metadata";
+export type TextSendParams = z.infer<typeof TextSendRequest>;
+export type TextSendResponse = z.infer<typeof TextResponse>;
+/**
+ * Text service for sending messages
+ */
+export declare class TextService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send a text message
+     */
+    send(params: TextSendParams): Promise<WithMetadata<TextSendResponse>>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/services/text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAE5D;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAAgB;gBACjC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC;CAG9E"}

package/dist/services/text/index.js

@@ -0,0 +1,16 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _textSend } from "@/services/text/send";
+/**
+ * Text service for sending messages
+ */
+export class TextService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send a text message
+     */
+    async send(params) {
+        return _textSend.call(this, params);
+    }
+}

package/dist/services/text/send.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const TextSendRequest: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const TextResponse: z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>;
+export declare const TextSendResponse: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>>;
+export type TextSendParams = z.infer<typeof TextSendRequest>;
+export type TextSendResponse = z.infer<typeof TextResponse>;
+/**
+ * Sends a text message
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.text.send({
+ *   to: "+1234567890",
+ *   message: "Hello from Contiguity!"
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export declare function _textSend(this: any, params: TextSendParams): Promise<any>;
+//# sourceMappingURL=send.d.ts.map

package/dist/services/text/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/text/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;iBAO1B,CAAA;AAEF,eAAO,MAAM,YAAY;;iBAGvB,CAAA;AAGF,eAAO,MAAM,gBAAgB;;kBAA+B,CAAA;AAE5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAc/E"}

package/dist/services/text/send.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { E164PhoneNumber, OptionalSenderNumber, MessageContent } from "@/types/common";
+export const TextSendRequest = z.object({
+    /** Recipient's phone number. Must be in E.164 format */
+    to: E164PhoneNumber,
+    /** If you lease a phone number from Contiguity, you can use a specific one by providing it here */
+    from: OptionalSenderNumber,
+    /** The text message to send */
+    message: MessageContent,
+});
+export const TextResponse = z.object({
+    /** The message's ID. Use it to refer to this message in the future */
+    message_id: z.string(),
+});
+// Using the new base response builder - this replaces the manual Flattened/Raw definitions
+export const TextSendResponse = createResponse(TextResponse);
+/**
+ * Sends a text message
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.text.send({
+ *   to: "+1234567890",
+ *   message: "Hello from Contiguity!"
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export async function _textSend(params) {
+    const validatedParams = TextSendRequest.parse(params);
+    const response = await this.request("/send/text", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: TextResponse,
+            raw: TextSendResponse.raw
+        }
+    });
+}

package/dist/services/whatsapp/index.d.ts

@@ -0,0 +1,24 @@
+import { ContiguityClient } from "@/client/fetch";
+import { z } from "zod";
+import { WhatsAppSendRequest, WhatsAppResponse } from "@/services/whatsapp/send";
+import { WhatsAppTypingRequest, WhatsAppTypingResponse } from "@/services/whatsapp/typing";
+import type { WithMetadata } from "@/types/metadata";
+export type WhatsAppSendParams = z.infer<typeof WhatsAppSendRequest>;
+export type WhatsAppSendResponse = z.infer<typeof WhatsAppResponse>;
+export type WhatsAppTypingParams = z.infer<typeof WhatsAppTypingRequest>;
+export type WhatsAppTypingResponseType = z.infer<typeof WhatsAppTypingResponse>;
+/**
+ * WhatsApp service for sending WhatsApp messages and managing typing indicators
+ */
+export declare class WhatsAppService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send a WhatsApp message
+     */
+    send(params: WhatsAppSendParams): Promise<WithMetadata<WhatsAppSendResponse>>;
+    /**
+     * Start or stop sending typing indicators over WhatsApp
+     */
+    typing(params: WhatsAppTypingParams): Promise<WithMetadata<WhatsAppTypingResponseType>>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/services/whatsapp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/whatsapp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACH,mBAAmB,EACnB,gBAAgB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACzE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEhF;;GAEG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;gBACrC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;IAInF;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,CAAC;CAGhG"}

package/dist/services/whatsapp/index.js

@@ -0,0 +1,23 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _whatsAppSend } from "@/services/whatsapp/send";
+import { _whatsAppTyping } from "@/services/whatsapp/typing";
+/**
+ * WhatsApp service for sending WhatsApp messages and managing typing indicators
+ */
+export class WhatsAppService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send a WhatsApp message
+     */
+    async send(params) {
+        return _whatsAppSend.call(this, params);
+    }
+    /**
+     * Start or stop sending typing indicators over WhatsApp
+     */
+    async typing(params) {
+        return _whatsAppTyping.call(this, params);
+    }
+}

package/dist/services/whatsapp/send.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const WhatsAppSendRequest: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    fallback: z.ZodOptional<z.ZodObject<{
+        when: z.ZodArray<z.ZodEnum<{
+            whatsapp: "whatsapp";
+            whatsapp_unsupported: "whatsapp_unsupported";
+            whatsapp_fails: "whatsapp_fails";
+        }>>;
+        from: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const WhatsAppResponse: z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>;
+export declare const WhatsAppSendResponse: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>>;
+export type WhatsAppFallbackParams = {
+    when: ("whatsapp_unsupported" | "whatsapp_fails")[];
+    from?: string;
+};
+export type WhatsAppSendParams = z.infer<typeof WhatsAppSendRequest>;
+export type WhatsAppSendResponse = z.infer<typeof WhatsAppResponse>;
+/**
+ * Sends a WhatsApp message
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.whatsapp.send({
+ *   to: "+1234567890",
+ *   message: "Hello from Contiguity!"
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Send with fallback to SMS and attachments
+ * const response = await contiguity.whatsapp.send({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   message: "Check out this image!",
+ *   fallback: {
+ *     when: ["whatsapp_unsupported", "whatsapp_fails"],
+ *     from: "+15555555555"
+ *   },
+ *   attachments: [
+ *     "https://example.com/image.png",
+ *     "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34..."
+ *   ]
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export declare function _whatsAppSend(this: any, params: WhatsAppSendParams): Promise<any>;
+//# sourceMappingURL=send.d.ts.map

package/dist/services/whatsapp/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/whatsapp/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAW9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;iBAG3B,CAAA;AAGF,eAAO,MAAM,oBAAoB;;kBAAmC,CAAA;AAEpE,MAAM,MAAM,sBAAsB,GAAG;IACpC,IAAI,EAAE,CAAC,sBAAsB,GAAG,gBAAgB,CAAC,EAAE,CAAC;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,CAcvF"}

package/dist/services/whatsapp/send.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { E164PhoneNumber, OptionalSenderNumber, MessageContent, AttachmentList, createFallbackSchema } from "@/types/common";
+export const WhatsAppSendRequest = z.object({
+    /** Recipient's WhatsApp number. Must be in E.164 format */
+    to: E164PhoneNumber,
+    /** Your leased WhatsApp number. If none is provided, we will use a random WhatsApp number of yours */
+    from: OptionalSenderNumber,
+    /** The WhatsApp message to send */
+    message: MessageContent,
+    /** Should Contiguity fallback to SMS/RCS if the recipient does not have WhatsApp, or if WhatsApp fails to send? */
+    fallback: createFallbackSchema("whatsapp", ["whatsapp_unsupported", "whatsapp_fails"]),
+    /** Attachments to send. Can be a URL to your attachment (e.g. example.com/image.png) or a base64 string. Max 10 attachments, with a cumulative size of 50MB */
+    attachments: AttachmentList
+});
+export const WhatsAppResponse = z.object({
+    /** The message's ID. Use it to refer to this message in the future, when checking the status of the message or finding it in the Console */
+    message_id: z.string(),
+});
+// Using the new base response builder - this replaces the manual Flattened/Raw definitions
+export const WhatsAppSendResponse = createResponse(WhatsAppResponse);
+/**
+ * Sends a WhatsApp message
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.whatsapp.send({
+ *   to: "+1234567890",
+ *   message: "Hello from Contiguity!"
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Send with fallback to SMS and attachments
+ * const response = await contiguity.whatsapp.send({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   message: "Check out this image!",
+ *   fallback: {
+ *     when: ["whatsapp_unsupported", "whatsapp_fails"],
+ *     from: "+15555555555"
+ *   },
+ *   attachments: [
+ *     "https://example.com/image.png",
+ *     "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34..."
+ *   ]
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export async function _whatsAppSend(params) {
+    const validatedParams = WhatsAppSendRequest.parse(params);
+    const response = await this.request("/send/whatsapp", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: WhatsAppResponse,
+            raw: WhatsAppSendResponse.raw
+        }
+    });
+}

package/dist/services/whatsapp/typing.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const WhatsAppTypingRequest: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    action: z.ZodEnum<{
+        start: "start";
+        stop: "stop";
+    }>;
+}, z.core.$strip>;
+export declare const WhatsAppTypingResponse: z.ZodObject<{
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const WhatsAppTypingResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    status: z.ZodString;
+}, z.core.$strip>>;
+export type WhatsAppTypingParams = z.infer<typeof WhatsAppTypingRequest>;
+export type WhatsAppTypingResponseType = z.infer<typeof WhatsAppTypingResponse>;
+/**
+ * Start or stop sending typing indicators over WhatsApp
+ *
+ * @example
+ * ```typescript
+ * // Start typing indicator
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   action: "start"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Stop typing indicator with specific sender number
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   action: "stop"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ */
+export declare function _whatsAppTyping(this: any, params: WhatsAppTypingParams): Promise<any>;
+//# sourceMappingURL=typing.d.ts.map

package/dist/services/whatsapp/typing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.ts","sourceRoot":"","sources":["../../../src/services/whatsapp/typing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,qBAAqB;;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;iBAGjC,CAAA;AAGF,eAAO,MAAM,6BAA6B;;kBAAyC,CAAA;AAEnF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACzE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,CAc3F"}

package/dist/services/whatsapp/typing.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { E164PhoneNumber, OptionalSenderNumber, TypingAction } from "@/types/common";
+export const WhatsAppTypingRequest = z.object({
+    /** Recipient's WhatsApp number. Must be in E.164 format */
+    to: E164PhoneNumber,
+    /** Your leased WhatsApp number. If none is provided, we will use a random WhatsApp number of yours */
+    from: OptionalSenderNumber,
+    /** Whether to start or stop sending typing indicators */
+    action: TypingAction
+});
+export const WhatsAppTypingResponse = z.object({
+    /** Status of the typing indicator */
+    status: z.string(),
+});
+// Using the new base response builder
+export const WhatsAppTypingResponseBuilder = createResponse(WhatsAppTypingResponse);
+/**
+ * Start or stop sending typing indicators over WhatsApp
+ *
+ * @example
+ * ```typescript
+ * // Start typing indicator
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   action: "start"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Stop typing indicator with specific sender number
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   action: "stop"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ */
+export async function _whatsAppTyping(params) {
+    const validatedParams = WhatsAppTypingRequest.parse(params);
+    const response = await this.request("/send/whatsapp/typing", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: WhatsAppTypingResponse,
+            raw: WhatsAppTypingResponseBuilder.raw
+        }
+    });
+}

package/dist/types/base.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+/**
+ * Base response builder that automatically creates flattened and raw response types
+ * This eliminates the need to manually define *ResponseFlattened and *ResponseRaw for each service
+ */
+export declare class BaseResponseBuilder<T extends z.ZodObject<any>> {
+    readonly schema: T;
+    constructor(schema: T);
+    get response(): T;
+    get flattened(): z.ZodObject<{
+        [x: string]: any;
+    }, z.core.$strip>;
+    get raw(): z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        api_version: z.ZodString;
+        object: z.ZodString;
+        data: T;
+    }, z.core.$strip>;
+    get all(): {
+        response: T;
+        flattened: z.ZodObject<{
+            [x: string]: any;
+        }, z.core.$strip>;
+        raw: z.ZodObject<{
+            id: z.ZodString;
+            timestamp: z.ZodNumber;
+            api_version: z.ZodString;
+            object: z.ZodString;
+            data: T;
+        }, z.core.$strip>;
+    };
+}
+export declare function createResponse<T extends z.ZodObject<any>>(schema: T): BaseResponseBuilder<T>;
+export type BaseResponse<T extends BaseResponseBuilder<any>> = z.infer<T['response']>;
+export type FlattenedResponse<T extends BaseResponseBuilder<any>> = z.infer<T['flattened']>;
+export type RawResponse<T extends BaseResponseBuilder<any>> = z.infer<T['raw']>;
+//# sourceMappingURL=base.d.ts.map

package/dist/types/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC;aAC3B,MAAM,EAAE,CAAC;gBAAT,MAAM,EAAE,CAAC;IAErC,IAAI,QAAQ,MAEX;IAED,IAAI,SAAS;;sBAEZ;IAED,IAAI,GAAG;;;;;;sBAIN;IAED,IAAI,GAAG;;;;;;;;;;;;MAMN;CACJ;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,0BAEnE;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;AACtF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;AAC5F,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC"}