contiguity 0.0.4 → 0.0.6

package/dist/services/domains/list.js

@@ -1,42 +0,0 @@
-import { z } from "zod";
-// Domain object schema based on OpenAPI spec
-export const DomainInfo = z.object({
-    /** The domain name */
-    domain: z.string(),
-    /** Domain verification status */
-    status: z.string(),
-    /** Domain creation timestamp */
-    created_at: z.number(),
-    /** Domain ID */
-    id: z.string(),
-    /** AWS region */
-    region: z.string(),
-    /** Whether sending is allowed */
-    sending_allowed: z.boolean(),
-});
-export const DomainsListResponse = z.object({
-    /** List of user's domains */
-    domains: z.array(DomainInfo),
-});
-/**
- * Lists all domains owned by the user
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.list();
- *
- * console.log(`You have ${response.domains.length} domains:`);
- * response.domains.forEach(domain => {
- *   console.log(`- ${domain.domain}: ${domain.status} (Region: ${domain.region})`);
- * });
- * ```
- */
-export async function _domainsList() {
-    const response = await this.request("/domains/", {
-        method: "GET",
-    });
-    return this.parse({
-        response,
-        schema: DomainsListResponse
-    });
-}

package/dist/services/domains/register.d.ts

@@ -1,67 +0,0 @@
-import { z } from "zod";
-export declare const DomainsRegisterRequest: z.ZodObject<{
-    domain: z.ZodString;
-    region: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    custom_return_path: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-}, z.core.$strip>;
-export declare const DomainsRegisterResponse: z.ZodObject<{
-    records: z.ZodArray<z.ZodObject<{
-        MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-            purpose: z.ZodString;
-        }, z.core.$strip>>>;
-        TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-            purpose: z.ZodString;
-        }, z.core.$strip>>>;
-        CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-            purpose: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    status: z.ZodString;
-    region: z.ZodString;
-    created_at: z.ZodNumber;
-}, z.core.$strip>;
-export type DomainsRegisterParams = z.infer<typeof DomainsRegisterRequest>;
-export type DomainsRegisterResponse = z.infer<typeof DomainsRegisterResponse>;
-/**
- * Registers a domain for email sending
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.register({
- *   domain: "example.com"
- * });
- *
- * console.log(`Domain registered with status: ${response.status}`);
- * console.log(`Region: ${response.region}`);
- *
- * // Display DNS records to configure
- * response.records.forEach(recordGroup => {
- *   if (recordGroup.TXT) {
- *     console.log("TXT Records to add:");
- *     recordGroup.TXT.forEach(record => {
- *       console.log(`  ${record.name}: ${record.value} (${record.purpose})`);
- *     });
- *   }
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Register domain with custom settings
- * const response = await contiguity.domains.register({
- *   domain: "example.com",
- *   region: "us-east-1",
- *   custom_return_path: "mail"
- * });
- *
- * console.log(`Created at: ${new Date(response.created_at).toISOString()}`);
- * ```
- */
-export declare function _domainsRegister(this: any, params: DomainsRegisterParams): Promise<any>;
-//# sourceMappingURL=register.d.ts.map

package/dist/services/domains/register.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/services/domains/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;iBAOjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AAKH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC3E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,CAa7F"}

package/dist/services/domains/register.js

@@ -1,67 +0,0 @@
-import { z } from "zod";
-import { DNSRecords } from "./get";
-export const DomainsRegisterRequest = z.object({
-    /** Domain name to register */
-    domain: z.string().min(1, "Domain cannot be empty"),
-    /** AWS region */
-    region: z.string().default("us-east-1").optional(),
-    /** Custom return path subdomain */
-    custom_return_path: z.string().default("contiguity").optional(),
-});
-export const DomainsRegisterResponse = z.object({
-    /** DNS records grouped by type */
-    records: z.array(DNSRecords),
-    /** Domain verification status */
-    status: z.string(),
-    /** AWS region (us-east-1 is the default and only currently supported region) */
-    region: z.string(),
-    /** Domain creation timestamp */
-    created_at: z.number(),
-});
-/**
- * Registers a domain for email sending
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.register({
- *   domain: "example.com"
- * });
- *
- * console.log(`Domain registered with status: ${response.status}`);
- * console.log(`Region: ${response.region}`);
- *
- * // Display DNS records to configure
- * response.records.forEach(recordGroup => {
- *   if (recordGroup.TXT) {
- *     console.log("TXT Records to add:");
- *     recordGroup.TXT.forEach(record => {
- *       console.log(`  ${record.name}: ${record.value} (${record.purpose})`);
- *     });
- *   }
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Register domain with custom settings
- * const response = await contiguity.domains.register({
- *   domain: "example.com",
- *   region: "us-east-1",
- *   custom_return_path: "mail"
- * });
- *
- * console.log(`Created at: ${new Date(response.created_at).toISOString()}`);
- * ```
- */
-export async function _domainsRegister(params) {
-    const validatedParams = DomainsRegisterRequest.parse(params);
-    const { domain, ...bodyParams } = validatedParams;
-    const response = await this.request(`/domains/${encodeURIComponent(domain)}`, {
-        method: "POST",
-        body: JSON.stringify(bodyParams),
-    });
-    return this.parse({
-        response,
-        schema: DomainsRegisterResponse
-    });
-}

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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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 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

@@ -1 +0,0 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/email/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBA8B3B,CAAA;AAEF,eAAO,MAAM,aAAa;;iBAExB,CAAA;AAIF,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,CAWjF"}

package/dist/services/email/send.js

@@ -1,78 +0,0 @@
-import { z } from "zod";
-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(),
-});
-/**
- * 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,
-        schema: EmailResponse
-    });
-}

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

@@ -1,24 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,23 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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 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

@@ -1 +0,0 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/imessage/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAW9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;iBAG3B,CAAA;AAKF,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,CAWvF"}

package/dist/services/imessage/send.js

@@ -1,60 +0,0 @@
-import { z } from "zod";
-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(),
-});
-/**
- * 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,
-        schema: iMessageResponse
-    });
-}

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

@@ -1,40 +0,0 @@
-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 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

@@ -1 +0,0 @@
-{"version":3,"file":"typing.d.ts","sourceRoot":"","sources":["../../../src/services/imessage/typing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;iBAGjC,CAAA;AAKF,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,CAW3F"}

package/dist/services/imessage/typing.js

@@ -1,49 +0,0 @@
-import { z } from "zod";
-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(),
-});
-/**
- * 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,
-        schema: iMessageTypingResponse
-    });
-}