contiguity 0.0.4 → 0.0.6

package/dist/client/fetch.js

@@ -1,85 +0,0 @@
-import { ContiguityAPIError, ContiguityError } from "@/types/error";
-// year | month | version (monthly) 
-const LATEST_API_VERSION = "v2025.8.20";
-const BASE_URL = "https://api.contiguity.com"; // "http://localhost:8080";
-/**
- * Contiguity API client with request functionality
- */
-export class ContiguityClient {
-    token;
-    constructor(token, options = {}) {
-        if (!token || typeof token !== 'string') {
-            throw new Error('API token is required and must be a string');
-        }
-        if (token.trim().length === 0) {
-            throw new Error('API token cannot be empty');
-        }
-        this.token = token.trim();
-    }
-    /**
-     * Make an authenticated request to the Contiguity API
-     */
-    async request(endpoint, options = {}) {
-        const url = `${BASE_URL}${endpoint}`;
-        const defaultHeaders = {
-            "Authorization": `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-            "User-Agent": "@contiguity/javascript",
-            "X-Contiguity-API-Version": LATEST_API_VERSION,
-        };
-        const config = {
-            ...options,
-            headers: {
-                ...defaultHeaders,
-                ...options.headers,
-            },
-        };
-        try {
-            const response = await fetch(url, config);
-            const data = await response.json();
-            if (!response.ok) {
-                // Validate error response with Zod
-                const errorResult = ContiguityAPIError.safeParse(data);
-                if (errorResult.success) {
-                    throw new ContiguityError(errorResult.data);
-                }
-                else {
-                    // Fallback error handling
-                    throw new ContiguityError({
-                        data: {
-                            status: response.status,
-                            error: data?.error || `HTTP ${response.status}: ${response.statusText}`,
-                        }
-                    });
-                }
-            }
-            return data;
-        }
-        catch (error) {
-            if (error instanceof ContiguityError) {
-                throw error;
-            }
-            // Network or other errors
-            throw ContiguityError.fromError(error);
-        }
-    }
-    /**
-     * Parse and normalize API responses to flattened format with metadata
-     * This method handles different response formats from the Contiguity API
-     * and normalizes them to a consistent flattened format.
-     */
-    parse({ response, schema }) {
-        // Parse the response data
-        const responseData = schema.parse(response);
-        // Return flattened response with metadata
-        return {
-            ...(typeof responseData === 'object' && responseData !== null ? responseData : {}),
-            metadata: {
-                id: response.id || "unknown",
-                timestamp: response.timestamp || Date.now(),
-                api_version: response.api_version || "unknown",
-                object: response.object || "unknown",
-            },
-        };
-    }
-}

package/dist/contiguity.d.ts

@@ -1,81 +0,0 @@
-import { TextService } from "@/services/text/index";
-import { EmailService } from "@/services/email/index";
-import { iMessageService } from "@/services/imessage/index";
-import { WhatsAppService } from "@/services/whatsapp/index";
-import { LeaseService } from "@/services/lease/index";
-import { OTPService } from "@/services/otp/index";
-import { DomainsService } from "@/services/domains/index";
-/**
- * Main Contiguity API client class
- *
- * @example
- * ```typescript
- * import { Contiguity } from '@contiguity/javascript';
- *
- * const contiguity = new Contiguity('your-api-token');
- *
- * // Send a text message
- * const response = await contiguity.text.send({
- *   to: "+1234567890",
- *   message: "Hello from Contiguity!"
- * });
- *
- * // Send an iMessage
- * const imessageResponse = await contiguity.imessage.send({
- *   to: "+1234567890",
- *   message: "Hello via iMessage!"
- * });
- *
- * // Send a WhatsApp message
- * const whatsappResponse = await contiguity.whatsapp.send({
- *   to: "+1234567890",
- *   message: "Hello via WhatsApp!"
- * });
- *
- * // Lease a phone number
- * const availableNumbers = await contiguity.lease.available();
- * const leaseResponse = await contiguity.lease.create({
- *   number: availableNumbers.numbers[0].id
- * });
- *
- * // Send and verify OTP
- * const otpResponse = await contiguity.otp.send({
- *   to: "+1234567890",
- *   language: "en",
- *   name: "MyApp"
- * });
- * const verification = await contiguity.otp.verify({
- *   otp_id: otpResponse.otp_id,
- *   otp: "123456"
- * });
- *
- * // Manage email domains
- * const domainsList = await contiguity.domains.list();
- * const registerResponse = await contiguity.domains.register({
- *   domain: "example.com",
- *   region: "us-east-1"
- * });
- * ```
- */
-export declare class Contiguity {
-    private readonly token;
-    readonly text: TextService;
-    readonly email: EmailService;
-    readonly imessage: iMessageService;
-    readonly whatsapp: WhatsAppService;
-    readonly lease: LeaseService;
-    readonly otp: OTPService;
-    readonly domains: DomainsService;
-    /**
-     * Create a new Contiguity client instance
-     *
-     * @throws {ContiguitySDKError} When token is not provided or invalid
-     */
-    constructor(token: string);
-    /**
-     * Validate that the client is properly configured
-     * @returns True if the client is ready to use
-     */
-    ready(): boolean;
-}
-//# sourceMappingURL=contiguity.d.ts.map

package/dist/contiguity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contiguity.d.ts","sourceRoot":"","sources":["../src/contiguity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,SAAgB,IAAI,EAAE,WAAW,CAAC;IAClC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,QAAQ,EAAE,eAAe,CAAC;IAC1C,SAAgB,QAAQ,EAAE,eAAe,CAAC;IAC1C,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,GAAG,EAAE,UAAU,CAAC;IAChC,SAAgB,OAAO,EAAE,cAAc,CAAC;IAExC;;;;OAIG;gBACS,KAAK,EAAE,MAAM;IAyCzB;;;OAGG;IACH,KAAK,IAAI,OAAO;CAInB"}

package/dist/contiguity.js

@@ -1,106 +0,0 @@
-import { TextService } from "@/services/text/index";
-import { EmailService } from "@/services/email/index";
-import { iMessageService } from "@/services/imessage/index";
-import { WhatsAppService } from "@/services/whatsapp/index";
-import { LeaseService } from "@/services/lease/index";
-import { OTPService } from "@/services/otp/index";
-import { DomainsService } from "@/services/domains/index";
-import { ContiguitySDKError } from "@/types/error";
-/**
- * Main Contiguity API client class
- *
- * @example
- * ```typescript
- * import { Contiguity } from '@contiguity/javascript';
- *
- * const contiguity = new Contiguity('your-api-token');
- *
- * // Send a text message
- * const response = await contiguity.text.send({
- *   to: "+1234567890",
- *   message: "Hello from Contiguity!"
- * });
- *
- * // Send an iMessage
- * const imessageResponse = await contiguity.imessage.send({
- *   to: "+1234567890",
- *   message: "Hello via iMessage!"
- * });
- *
- * // Send a WhatsApp message
- * const whatsappResponse = await contiguity.whatsapp.send({
- *   to: "+1234567890",
- *   message: "Hello via WhatsApp!"
- * });
- *
- * // Lease a phone number
- * const availableNumbers = await contiguity.lease.available();
- * const leaseResponse = await contiguity.lease.create({
- *   number: availableNumbers.numbers[0].id
- * });
- *
- * // Send and verify OTP
- * const otpResponse = await contiguity.otp.send({
- *   to: "+1234567890",
- *   language: "en",
- *   name: "MyApp"
- * });
- * const verification = await contiguity.otp.verify({
- *   otp_id: otpResponse.otp_id,
- *   otp: "123456"
- * });
- *
- * // Manage email domains
- * const domainsList = await contiguity.domains.list();
- * const registerResponse = await contiguity.domains.register({
- *   domain: "example.com",
- *   region: "us-east-1"
- * });
- * ```
- */
-export class Contiguity {
-    token;
-    text;
-    email;
-    imessage;
-    whatsapp;
-    lease;
-    otp;
-    domains;
-    /**
-     * Create a new Contiguity client instance
-     *
-     * @throws {ContiguitySDKError} When token is not provided or invalid
-     */
-    constructor(token) {
-        if (!token || typeof token !== 'string') {
-            throw new ContiguitySDKError('Contiguity API token is required and must be a string', 'invalid_token');
-        }
-        if (token.trim().length === 0) {
-            throw new ContiguitySDKError('Contiguity API token cannot be empty', 'empty_token');
-        }
-        if (!token.startsWith('contiguity_sk_')) {
-            throw new ContiguitySDKError('Contiguity tokens begin with "contiguity_sk_" – are you sure you entered the correct token?', 'invalid_token');
-        }
-        if (token.toUpperCase() === token && !token.startsWith('contiguity_sk_')) {
-            throw new ContiguitySDKError('Unfortunately, you cannot use API v1 keys with API v2. Please generate a new token at https://console.contiguity.com/dashboard/tokens', 'old_token');
-        }
-        this.token = token.trim();
-        // add new services here
-        this.text = new TextService(this.token);
-        this.email = new EmailService(this.token);
-        this.imessage = new iMessageService(this.token);
-        this.whatsapp = new WhatsAppService(this.token);
-        this.lease = new LeaseService(this.token);
-        this.otp = new OTPService(this.token);
-        this.domains = new DomainsService(this.token);
-    }
-    /**
-     * Validate that the client is properly configured
-     * @returns True if the client is ready to use
-     */
-    ready() {
-        const products = [this.text, this.email, this.imessage, this.whatsapp, this.lease, this.otp, this.domains];
-        return products.every(product => product !== undefined);
-    }
-}

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

@@ -1,28 +0,0 @@
-import { z } from "zod";
-export declare const DomainsDeleteRequest: z.ZodObject<{
-    domain: z.ZodString;
-}, z.core.$strip>;
-export declare const DomainsDeleteResponse: z.ZodObject<{
-    success: z.ZodBoolean;
-    message: z.ZodString;
-}, z.core.$strip>;
-export type DomainsDeleteParams = z.infer<typeof DomainsDeleteRequest>;
-export type DomainsDeleteResponse = z.infer<typeof DomainsDeleteResponse>;
-/**
- * Deletes a domain from your account
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.delete({
- *   domain: "example.com"
- * });
- *
- * if (response.success) {
- *   console.log(`Domain deleted successfully: ${response.message}`);
- * } else {
- *   console.log(`Failed to delete domain: ${response.message}`);
- * }
- * ```
- */
-export declare function _domainsDelete(this: any, params: DomainsDeleteParams): Promise<any>;
-//# sourceMappingURL=delete.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/services/domains/delete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;iBAG/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAC;AAKH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,CAUzF"}

package/dist/services/domains/delete.js

@@ -1,37 +0,0 @@
-import { z } from "zod";
-export const DomainsDeleteRequest = z.object({
-    /** Domain name to delete */
-    domain: z.string().min(1, "Domain cannot be empty"),
-});
-export const DomainsDeleteResponse = z.object({
-    /** Whether the deletion was successful */
-    success: z.boolean(),
-    /** Success message */
-    message: z.string(),
-});
-/**
- * Deletes a domain from your account
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.delete({
- *   domain: "example.com"
- * });
- *
- * if (response.success) {
- *   console.log(`Domain deleted successfully: ${response.message}`);
- * } else {
- *   console.log(`Failed to delete domain: ${response.message}`);
- * }
- * ```
- */
-export async function _domainsDelete(params) {
-    const validatedParams = DomainsDeleteRequest.parse(params);
-    const response = await this.request(`/domains/${encodeURIComponent(validatedParams.domain)}`, {
-        method: "DELETE",
-    });
-    return this.parse({
-        response,
-        schema: DomainsDeleteResponse
-    });
-}

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

@@ -1,98 +0,0 @@
-import { z } from "zod";
-export declare const DNSRecord: z.ZodObject<{
-    name: z.ZodString;
-    value: z.ZodString;
-    purpose: z.ZodString;
-}, z.core.$strip>;
-export declare const DNSRecords: 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>;
-export declare const DomainVerifications: z.ZodObject<{
-    dkim: z.ZodString;
-    mail_from: z.ZodString;
-    domain: z.ZodString;
-}, z.core.$strip>;
-export declare const DomainsGetRequest: z.ZodObject<{
-    domain: z.ZodString;
-}, z.core.$strip>;
-export declare const DomainsGetResponse: z.ZodObject<{
-    domain: z.ZodString;
-    status: z.ZodString;
-    id: z.ZodString;
-    created_at: z.ZodNumber;
-    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>>;
-    region: z.ZodString;
-    sending_allowed: z.ZodBoolean;
-    verifications: z.ZodObject<{
-        dkim: z.ZodString;
-        mail_from: z.ZodString;
-        domain: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type DomainsGetParams = z.infer<typeof DomainsGetRequest>;
-export type DomainsGetResponse = z.infer<typeof DomainsGetResponse>;
-export type DNSRecord = z.infer<typeof DNSRecord>;
-export type DomainVerifications = z.infer<typeof DomainVerifications>;
-/**
- * Gets domain verification status and DNS instructions
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.get({
- *   domain: "example.com"
- * });
- *
- * console.log(`Domain: ${response.domain}`);
- * console.log(`Status: ${response.status}`);
- * console.log(`Sending allowed: ${response.sending_allowed}`);
- * console.log(`DKIM status: ${response.verifications.dkim}`);
- * ```
- *
- * @example
- * ```typescript
- * // Check DNS records
- * const response = await contiguity.domains.get({
- *   domain: "example.com"
- * });
- *
- * response.records.forEach(recordGroup => {
- *   if (recordGroup.TXT) {
- *     recordGroup.TXT.forEach(record => {
- *       console.log(`TXT Record: ${record.name} -> ${record.value} (${record.purpose})`);
- *     });
- *   }
- * });
- * ```
- */
-export declare function _domainsGet(this: any, params: DomainsGetParams): Promise<any>;
-//# sourceMappingURL=get.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/services/domains/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS;;;;iBAOpB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;iBAO9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;iBAG5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB7B,CAAC;AAKH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAUnF"}

package/dist/services/domains/get.js

@@ -1,89 +0,0 @@
-import { z } from "zod";
-// DNS Record schemas based on OpenAPI spec
-export const DNSRecord = z.object({
-    /** Record name */
-    name: z.string(),
-    /** Record value */
-    value: z.string(),
-    /** Record purpose */
-    purpose: z.string(),
-});
-export const DNSRecords = z.object({
-    /** MX records */
-    MX: z.array(DNSRecord).optional(),
-    /** TXT records */
-    TXT: z.array(DNSRecord).optional(),
-    /** CNAME records */
-    CNAME: z.array(DNSRecord).optional(),
-});
-export const DomainVerifications = z.object({
-    /** DKIM configuration status */
-    dkim: z.string(),
-    /** Mail-from domain verification status */
-    mail_from: z.string(),
-    /** Domain verification status */
-    domain: z.string(),
-});
-export const DomainsGetRequest = z.object({
-    /** Domain name to get information about */
-    domain: z.string().min(1, "Domain cannot be empty"),
-});
-export const DomainsGetResponse = z.object({
-    /** The domain name */
-    domain: z.string(),
-    /** Domain verification status */
-    status: z.string(),
-    /** Domain ID */
-    id: z.string(),
-    /** Domain creation timestamp */
-    created_at: z.number(),
-    /** DNS records grouped by type */
-    records: z.array(DNSRecords),
-    /** AWS region */
-    region: z.string(),
-    /** Whether sending is allowed using this domain */
-    sending_allowed: z.boolean(),
-    /** Verification status details */
-    verifications: DomainVerifications,
-});
-/**
- * Gets domain verification status and DNS instructions
- *
- * @example
- * ```typescript
- * const response = await contiguity.domains.get({
- *   domain: "example.com"
- * });
- *
- * console.log(`Domain: ${response.domain}`);
- * console.log(`Status: ${response.status}`);
- * console.log(`Sending allowed: ${response.sending_allowed}`);
- * console.log(`DKIM status: ${response.verifications.dkim}`);
- * ```
- *
- * @example
- * ```typescript
- * // Check DNS records
- * const response = await contiguity.domains.get({
- *   domain: "example.com"
- * });
- *
- * response.records.forEach(recordGroup => {
- *   if (recordGroup.TXT) {
- *     recordGroup.TXT.forEach(record => {
- *       console.log(`TXT Record: ${record.name} -> ${record.value} (${record.purpose})`);
- *     });
- *   }
- * });
- * ```
- */
-export async function _domainsGet(params) {
-    const validatedParams = DomainsGetRequest.parse(params);
-    const response = await this.request(`/domains/${encodeURIComponent(validatedParams.domain)}`, {
-        method: "GET",
-    });
-    return this.parse({
-        response,
-        schema: DomainsGetResponse
-    });
-}

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

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import { ContiguityClient } from "@/client/fetch";
-import type { WithMetadata } from "@/types/metadata";
-import { DomainsListResponse } from "./list";
-import { type DomainsGetParams, DomainsGetResponse } from "./get";
-import { type DomainsRegisterParams, DomainsRegisterResponse } from "./register";
-import { type DomainsDeleteParams, DomainsDeleteResponse } from "./delete";
-export type DomainsListResponseType = z.infer<typeof DomainsListResponse>;
-export type DomainsGetResponseType = z.infer<typeof DomainsGetResponse>;
-export type DomainsRegisterResponseType = z.infer<typeof DomainsRegisterResponse>;
-export type DomainsDeleteResponseType = z.infer<typeof DomainsDeleteResponse>;
-/**
- * Domains service for managing email domains
- */
-export declare class DomainsService extends ContiguityClient {
-    constructor(token: string);
-    /**
-     * List all domains owned by the user
-     */
-    list(): Promise<WithMetadata<DomainsListResponseType>>;
-    /**
-     * Get domain verification status and DNS instructions
-     */
-    get(params: DomainsGetParams): Promise<WithMetadata<DomainsGetResponseType>>;
-    /**
-     * Register a domain for email sending
-     */
-    register(params: DomainsRegisterParams): Promise<WithMetadata<DomainsRegisterResponseType>>;
-    /**
-     * Delete a domain from your account
-     */
-    delete(params: DomainsDeleteParams): Promise<WithMetadata<DomainsDeleteResponseType>>;
-}
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/domains/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAgB,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAe,KAAK,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAoB,KAAK,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACnG,OAAO,EAAkB,KAAK,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAE3F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAClF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE9E;;GAEG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;gBACpC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC;IAI5D;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;IAIlF;;OAEG;IACG,QAAQ,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC;IAIjG;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;CAG9F"}

package/dist/services/domains/index.js

@@ -1,37 +0,0 @@
-import { ContiguityClient } from "@/client/fetch";
-import { _domainsList } from "./list";
-import { _domainsGet } from "./get";
-import { _domainsRegister } from "./register";
-import { _domainsDelete } from "./delete";
-/**
- * Domains service for managing email domains
- */
-export class DomainsService extends ContiguityClient {
-    constructor(token) {
-        super(token);
-    }
-    /**
-     * List all domains owned by the user
-     */
-    async list() {
-        return _domainsList.call(this);
-    }
-    /**
-     * Get domain verification status and DNS instructions
-     */
-    async get(params) {
-        return _domainsGet.call(this, params);
-    }
-    /**
-     * Register a domain for email sending
-     */
-    async register(params) {
-        return _domainsRegister.call(this, params);
-    }
-    /**
-     * Delete a domain from your account
-     */
-    async delete(params) {
-        return _domainsDelete.call(this, params);
-    }
-}

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

@@ -1,36 +0,0 @@
-import { z } from "zod";
-export declare const DomainInfo: z.ZodObject<{
-    domain: z.ZodString;
-    status: z.ZodString;
-    created_at: z.ZodNumber;
-    id: z.ZodString;
-    region: z.ZodString;
-    sending_allowed: z.ZodBoolean;
-}, z.core.$strip>;
-export declare const DomainsListResponse: z.ZodObject<{
-    domains: z.ZodArray<z.ZodObject<{
-        domain: z.ZodString;
-        status: z.ZodString;
-        created_at: z.ZodNumber;
-        id: z.ZodString;
-        region: z.ZodString;
-        sending_allowed: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type DomainsListResponse = z.infer<typeof DomainsListResponse>;
-export type DomainInfo = z.infer<typeof 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 declare function _domainsList(this: any): Promise<any>;
-//# sourceMappingURL=list.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/services/domains/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;iBAarB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAG9B,CAAC;AAIH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAS1D"}