contiguity 0.0.1

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

@@ -0,0 +1,17 @@
+import { ContiguityClient } from "@/client/fetch";
+import { z } from "zod";
+import { EmailSendRequest, EmailResponse } from "@/services/email/send";
+import type { WithMetadata } from "@/types/metadata";
+export type EmailSendParams = z.infer<typeof EmailSendRequest>;
+export type EmailSendResponse = z.infer<typeof EmailResponse>;
+/**
+ * Email service for sending emails
+ */
+export declare class EmailService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send an email
+     */
+    send(params: EmailSendParams): Promise<WithMetadata<EmailSendResponse>>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/email/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;gBAClC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;CAGhF"}

package/dist/services/email/index.js

@@ -0,0 +1,16 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _emailSend } from "@/services/email/send";
+/**
+ * Email service for sending emails
+ */
+export class EmailService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send an email
+     */
+    async send(params) {
+        return _emailSend.call(this, params);
+    }
+}

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const EmailSendRequest: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+    from: z.ZodString;
+    subject: z.ZodString;
+    body: z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    reply_to: z.ZodOptional<z.ZodString>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>>;
+    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const EmailResponse: z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$strip>;
+export declare const EmailSendResponse: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$strip>>;
+export type EmailBodyParams = {
+    text?: string;
+    html?: string;
+};
+export type EmailHeaderParams = {
+    name: string;
+    value: string;
+};
+export type EmailSendParams = z.infer<typeof EmailSendRequest>;
+export type EmailSendResponseType = z.infer<typeof EmailResponse>;
+/**
+ * Sends an email
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.email.send({
+ *   to: "recipient@example.com",
+ *   from: "Contiguity <no-reply@contiguity.com>",
+ *   subject: "Hello from Contiguity!",
+ *   body: {
+ *     text: "Hello, world!",
+ *     html: "<p>Hello, world!</p>"
+ *   }
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Send to multiple recipients with CC and BCC
+ * const response = await contiguity.email.send({
+ *   to: ["user1@example.com", "user2@example.com"],
+ *   from: "Your Company <no-reply@yourcompany.com>",
+ *   subject: "Newsletter Update",
+ *   body: {
+ *     html: "<h1>Newsletter</h1><p>Latest updates...</p>"
+ *   },
+ *   cc: "manager@example.com",
+ *   bcc: ["analytics@company.com"],
+ *   reply_to: "support@yourcompany.com"
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ */
+export declare function _emailSend(this: any, params: EmailSendParams): Promise<any>;
+//# sourceMappingURL=send.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/email/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBA8B3B,CAAA;AAEF,eAAO,MAAM,aAAa;;iBAExB,CAAA;AAGF,eAAO,MAAM,iBAAiB;;kBAAgC,CAAA;AAE9D,MAAM,MAAM,eAAe,GAAG;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAcjF"}

package/dist/services/email/send.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { SingleOrMultipleEmails } from "@/types/common";
+export const EmailSendRequest = z.object({
+    /** Recipient email address(es). Can be a string or array of up to 10 addresses */
+    to: SingleOrMultipleEmails(10, "email"),
+    /** Provide either just your sender name (and use Contiguity's email) or provide your sender name and email (has to be verified in the Console) */
+    from: z.string().min(1, "From field cannot be empty"),
+    /** Subject of the email */
+    subject: z.string().min(1, "Subject cannot be empty"),
+    /** Email body content */
+    body: z.object({
+        /** Text content of the email */
+        text: z.string().optional(),
+        /** HTML content of the email */
+        html: z.string().optional()
+    }).refine((data) => data.text || data.html, "Either text or html content must be provided"),
+    /** Reply-to email address */
+    reply_to: z.string().email("Must be a valid email address").optional(),
+    /** Carbon copy email address(es). Can be a string or array of up to 10 addresses */
+    cc: SingleOrMultipleEmails(10, "email").optional(),
+    /** Blind carbon copy email address(es). Can be a string or array of up to 10 addresses */
+    bcc: SingleOrMultipleEmails(10, "email").optional(),
+    /** Custom email headers */
+    headers: z.array(z.object({
+        /** Header name */
+        name: z.string().min(1, "Header name cannot be empty"),
+        /** Header value */
+        value: z.string().min(1, "Header value cannot be empty")
+    })).optional()
+});
+export const EmailResponse = z.object({
+    email_id: z.string(),
+});
+// Using the new base response builder
+export const EmailSendResponse = createResponse(EmailResponse);
+/**
+ * Sends an email
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.email.send({
+ *   to: "recipient@example.com",
+ *   from: "Contiguity <no-reply@contiguity.com>",
+ *   subject: "Hello from Contiguity!",
+ *   body: {
+ *     text: "Hello, world!",
+ *     html: "<p>Hello, world!</p>"
+ *   }
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Send to multiple recipients with CC and BCC
+ * const response = await contiguity.email.send({
+ *   to: ["user1@example.com", "user2@example.com"],
+ *   from: "Your Company <no-reply@yourcompany.com>",
+ *   subject: "Newsletter Update",
+ *   body: {
+ *     html: "<h1>Newsletter</h1><p>Latest updates...</p>"
+ *   },
+ *   cc: "manager@example.com",
+ *   bcc: ["analytics@company.com"],
+ *   reply_to: "support@yourcompany.com"
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ */
+export async function _emailSend(params) {
+    const validatedParams = EmailSendRequest.parse(params);
+    const response = await this.request("/email", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: EmailResponse,
+            raw: EmailSendResponse.raw
+        }
+    });
+}

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

@@ -0,0 +1,24 @@
+import { ContiguityClient } from "@/client/fetch";
+import { z } from "zod";
+import { iMessageSendRequest, iMessageResponse } from "@/services/imessage/send";
+import { iMessageTypingRequest, iMessageTypingResponse } from "@/services/imessage/typing";
+import type { WithMetadata } from "@/types/metadata";
+export type iMessageSendParams = z.infer<typeof iMessageSendRequest>;
+export type iMessageSendResponse = z.infer<typeof iMessageResponse>;
+export type iMessageTypingParams = z.infer<typeof iMessageTypingRequest>;
+export type iMessageTypingResponseType = z.infer<typeof iMessageTypingResponse>;
+/**
+ * iMessage service for sending iMessages and managing typing indicators
+ */
+export declare class iMessageService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send an iMessage
+     */
+    send(params: iMessageSendParams): Promise<WithMetadata<iMessageSendResponse>>;
+    /**
+     * Start or stop sending typing indicators over iMessage
+     */
+    typing(params: iMessageTypingParams): Promise<WithMetadata<iMessageTypingResponseType>>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/imessage/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/imessage/index.js

@@ -0,0 +1,23 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _iMessageSend } from "@/services/imessage/send";
+import { _iMessageTyping } from "@/services/imessage/typing";
+/**
+ * iMessage service for sending iMessages and managing typing indicators
+ */
+export class iMessageService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send an iMessage
+     */
+    async send(params) {
+        return _iMessageSend.call(this, params);
+    }
+    /**
+     * Start or stop sending typing indicators over iMessage
+     */
+    async typing(params) {
+        return _iMessageTyping.call(this, params);
+    }
+}

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const iMessageSendRequest: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    fallback: z.ZodOptional<z.ZodObject<{
+        when: z.ZodArray<z.ZodEnum<{
+            imessage: "imessage";
+            imessage_unsupported: "imessage_unsupported";
+            imessage_fails: "imessage_fails";
+        }>>;
+        from: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const iMessageResponse: z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>;
+export declare const iMessageSendResponse: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    message_id: z.ZodString;
+}, z.core.$strip>>;
+export type iMessageFallbackParams = {
+    when: ("imessage_unsupported" | "imessage_fails")[];
+    from?: string;
+};
+export type iMessageSendParams = z.infer<typeof iMessageSendRequest>;
+export type iMessageSendResponse = z.infer<typeof iMessageResponse>;
+/**
+ * Sends an iMessage
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.imessage.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.imessage.send({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   message: "Check out this image!",
+ *   fallback: {
+ *     when: ["imessage_unsupported", "imessage_fails"],
+ *     from: "+15555555555"
+ *   },
+ *   attachments: [
+ *     "https://example.com/image.png",
+ *     "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34..."
+ *   ]
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export declare function _iMessageSend(this: any, params: iMessageSendParams): Promise<any>;
+//# sourceMappingURL=send.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/imessage/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/imessage/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 iMessageSendRequest = z.object({
+    /** Recipient's iMessage address. Must be in E.164 format */
+    to: E164PhoneNumber,
+    /** Your leased iMessage number. If none is provided, we will use a random iMessage number of yours */
+    from: OptionalSenderNumber,
+    /** The iMessage to send */
+    message: MessageContent,
+    /** Should Contiguity fallback to SMS/RCS if the recipient does not have iMessage, or if iMessage fails to send? */
+    fallback: createFallbackSchema("imessage", ["imessage_unsupported", "imessage_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 iMessageResponse = 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 iMessageSendResponse = createResponse(iMessageResponse);
+/**
+ * Sends an iMessage
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.imessage.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.imessage.send({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   message: "Check out this image!",
+ *   fallback: {
+ *     when: ["imessage_unsupported", "imessage_fails"],
+ *     from: "+15555555555"
+ *   },
+ *   attachments: [
+ *     "https://example.com/image.png",
+ *     "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34..."
+ *   ]
+ * });
+ * console.log(`Message ID: ${response.message_id}`);
+ * ```
+ */
+export async function _iMessageSend(params) {
+    const validatedParams = iMessageSendRequest.parse(params);
+    const response = await this.request("/send/imessage", {
+        method: "POST",
+        body: JSON.stringify(validatedParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: iMessageResponse,
+            raw: iMessageSendResponse.raw
+        }
+    });
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.ts","sourceRoot":"","sources":["../../../src/services/imessage/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/imessage/typing.js

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