contiguity 0.0.1

package/dist/services/lease/leased.d.ts

@@ -0,0 +1,308 @@
+import { z } from "zod";
+export declare const LeasedBillingPeriod: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const LeasedBilling: z.ZodObject<{
+    method: z.ZodEnum<{
+        monthly: "monthly";
+        service_contract: "service_contract";
+        goodwill: "goodwill";
+    }>;
+    period: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LeasedNumber: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        available: "available";
+        "g-available": "g-available";
+        leased: "leased";
+        unavailable: "unavailable";
+    }>;
+    number: z.ZodObject<{
+        e164: z.ZodString;
+        formatted: z.ZodString;
+    }, z.core.$strip>;
+    location: z.ZodObject<{
+        country: z.ZodString;
+        region: z.ZodString;
+        city: z.ZodString;
+    }, z.core.$strip>;
+    carrier: z.ZodEnum<{
+        "T-Mobile": "T-Mobile";
+        "AT&T": "AT&T";
+        Verizon: "Verizon";
+        Contiguity: "Contiguity";
+        "International Partner": "International Partner";
+        Twilio: "Twilio";
+    }>;
+    capabilities: z.ZodObject<{
+        intl_sms: z.ZodBoolean;
+        channels: z.ZodArray<z.ZodEnum<{
+            sms: "sms";
+            mms: "mms";
+            rcs: "rcs";
+            imessage: "imessage";
+            whatsapp: "whatsapp";
+        }>>;
+    }, z.core.$strip>;
+    health: z.ZodObject<{
+        reputation: z.ZodNumber;
+        previous_owners: z.ZodNumber;
+    }, z.core.$strip>;
+    data: z.ZodObject<{
+        requirements: z.ZodArray<z.ZodEnum<{
+            imessage_entitlement_required: "imessage_entitlement_required";
+            whatsapp_entitlement_required: "whatsapp_entitlement_required";
+            enterprise_plan_required: "enterprise_plan_required";
+        }>>;
+        e911_capable: z.ZodBoolean;
+    }, z.core.$strip>;
+    created_at: z.ZodNumber;
+    pricing: z.ZodObject<{
+        currency: z.ZodEnum<{
+            USD: "USD";
+            EUR: "EUR";
+            GBP: "GBP";
+            CAD: "CAD";
+            AUD: "AUD";
+        }>;
+        upfront_fee: z.ZodNumber;
+        monthly_rate: z.ZodNumber;
+    }, z.core.$strip>;
+    lease_id: z.ZodString;
+    lease_status: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        terminated: "terminated";
+    }>;
+    billing: z.ZodObject<{
+        method: z.ZodEnum<{
+            monthly: "monthly";
+            service_contract: "service_contract";
+            goodwill: "goodwill";
+        }>;
+        period: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LeaseLeasedResponse: z.ZodObject<{
+    leased: z.ZodNumber;
+    numbers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            available: "available";
+            "g-available": "g-available";
+            leased: "leased";
+            unavailable: "unavailable";
+        }>;
+        number: z.ZodObject<{
+            e164: z.ZodString;
+            formatted: z.ZodString;
+        }, z.core.$strip>;
+        location: z.ZodObject<{
+            country: z.ZodString;
+            region: z.ZodString;
+            city: z.ZodString;
+        }, z.core.$strip>;
+        carrier: z.ZodEnum<{
+            "T-Mobile": "T-Mobile";
+            "AT&T": "AT&T";
+            Verizon: "Verizon";
+            Contiguity: "Contiguity";
+            "International Partner": "International Partner";
+            Twilio: "Twilio";
+        }>;
+        capabilities: z.ZodObject<{
+            intl_sms: z.ZodBoolean;
+            channels: z.ZodArray<z.ZodEnum<{
+                sms: "sms";
+                mms: "mms";
+                rcs: "rcs";
+                imessage: "imessage";
+                whatsapp: "whatsapp";
+            }>>;
+        }, z.core.$strip>;
+        health: z.ZodObject<{
+            reputation: z.ZodNumber;
+            previous_owners: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            requirements: z.ZodArray<z.ZodEnum<{
+                imessage_entitlement_required: "imessage_entitlement_required";
+                whatsapp_entitlement_required: "whatsapp_entitlement_required";
+                enterprise_plan_required: "enterprise_plan_required";
+            }>>;
+            e911_capable: z.ZodBoolean;
+        }, z.core.$strip>;
+        created_at: z.ZodNumber;
+        pricing: z.ZodObject<{
+            currency: z.ZodEnum<{
+                USD: "USD";
+                EUR: "EUR";
+                GBP: "GBP";
+                CAD: "CAD";
+                AUD: "AUD";
+            }>;
+            upfront_fee: z.ZodNumber;
+            monthly_rate: z.ZodNumber;
+        }, z.core.$strip>;
+        lease_id: z.ZodString;
+        lease_status: z.ZodEnum<{
+            active: "active";
+            expired: "expired";
+            terminated: "terminated";
+        }>;
+        billing: z.ZodObject<{
+            method: z.ZodEnum<{
+                monthly: "monthly";
+                service_contract: "service_contract";
+                goodwill: "goodwill";
+            }>;
+            period: z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const LeaseLeasedResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    leased: z.ZodNumber;
+    numbers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            available: "available";
+            "g-available": "g-available";
+            leased: "leased";
+            unavailable: "unavailable";
+        }>;
+        number: z.ZodObject<{
+            e164: z.ZodString;
+            formatted: z.ZodString;
+        }, z.core.$strip>;
+        location: z.ZodObject<{
+            country: z.ZodString;
+            region: z.ZodString;
+            city: z.ZodString;
+        }, z.core.$strip>;
+        carrier: z.ZodEnum<{
+            "T-Mobile": "T-Mobile";
+            "AT&T": "AT&T";
+            Verizon: "Verizon";
+            Contiguity: "Contiguity";
+            "International Partner": "International Partner";
+            Twilio: "Twilio";
+        }>;
+        capabilities: z.ZodObject<{
+            intl_sms: z.ZodBoolean;
+            channels: z.ZodArray<z.ZodEnum<{
+                sms: "sms";
+                mms: "mms";
+                rcs: "rcs";
+                imessage: "imessage";
+                whatsapp: "whatsapp";
+            }>>;
+        }, z.core.$strip>;
+        health: z.ZodObject<{
+            reputation: z.ZodNumber;
+            previous_owners: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            requirements: z.ZodArray<z.ZodEnum<{
+                imessage_entitlement_required: "imessage_entitlement_required";
+                whatsapp_entitlement_required: "whatsapp_entitlement_required";
+                enterprise_plan_required: "enterprise_plan_required";
+            }>>;
+            e911_capable: z.ZodBoolean;
+        }, z.core.$strip>;
+        created_at: z.ZodNumber;
+        pricing: z.ZodObject<{
+            currency: z.ZodEnum<{
+                USD: "USD";
+                EUR: "EUR";
+                GBP: "GBP";
+                CAD: "CAD";
+                AUD: "AUD";
+            }>;
+            upfront_fee: z.ZodNumber;
+            monthly_rate: z.ZodNumber;
+        }, z.core.$strip>;
+        lease_id: z.ZodString;
+        lease_status: z.ZodEnum<{
+            active: "active";
+            expired: "expired";
+            terminated: "terminated";
+        }>;
+        billing: z.ZodObject<{
+            method: z.ZodEnum<{
+                monthly: "monthly";
+                service_contract: "service_contract";
+                goodwill: "goodwill";
+            }>;
+            period: z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type LeaseLeasedResponseType = z.infer<typeof LeaseLeasedResponse>;
+export type LeasedNumberType = z.infer<typeof LeasedNumber>;
+/**
+ * Gets all phone numbers currently leased by the user
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.leased();
+ * console.log(`You have ${response.leased} leased numbers`);
+ *
+ * // List all active leases
+ * const activeLeases = response.numbers.filter(
+ *   num => num.lease_status === 'active'
+ * );
+ * console.log(`Active leases: ${activeLeases.length}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Find leases by capabilities
+ * const response = await contiguity.lease.leased();
+ *
+ * const imessageNumbers = response.numbers.filter(
+ *   num => num.capabilities.channels.includes('imessage')
+ * );
+ *
+ * const whatsappNumbers = response.numbers.filter(
+ *   num => num.capabilities.channels.includes('whatsapp')
+ * );
+ *
+ * console.log(`iMessage numbers: ${imessageNumbers.length}`);
+ * console.log(`WhatsApp numbers: ${whatsappNumbers.length}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check lease expiration dates
+ * const response = await contiguity.lease.leased();
+ *
+ * response.numbers.forEach(num => {
+ *   console.log(`${num.number.formatted}:`);
+ *   console.log(`  Lease ID: ${num.lease_id}`);
+ *   console.log(`  Status: ${num.lease_status}`);
+ *
+ *   if (num.billing.period.end) {
+ *     const endDate = new Date(num.billing.period.end * 1000);
+ *     console.log(`  Expires: ${endDate.toLocaleDateString()}`);
+ *   } else {
+ *     console.log(`  Billing: Month-to-month`);
+ *   }
+ * });
+ * ```
+ */
+export declare function _leasedNumbers(this: any): Promise<any>;
+//# sourceMappingURL=leased.d.ts.map

package/dist/services/lease/leased.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leased.d.ts","sourceRoot":"","sources":["../../../src/services/lease/leased.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,mBAAmB;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;iBAKxB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BvB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC;AAGH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsC,CAAC;AAE9E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAY5D"}

package/dist/services/lease/leased.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { NumberCapabilities, NumberHealth, NumberLocation, NumberFormat, NumberData, NumberPricing } from "@/services/lease/available";
+export const LeasedBillingPeriod = z.object({
+    /** Lease start timestamp */
+    start: z.number(),
+    /** Lease end timestamp. Null if month-to-month with no set cancellation date */
+    end: z.number().nullable()
+});
+export const LeasedBilling = z.object({
+    /** Billing method */
+    method: z.enum(["monthly", "service_contract", "goodwill"]),
+    /** Lease billing period */
+    period: LeasedBillingPeriod
+});
+export const LeasedNumber = z.object({
+    /** Phone number in E.164 format */
+    id: z.string(),
+    /** Number status (leased) */
+    status: z.enum(["available", "g-available", "leased", "unavailable"]),
+    /** Number formats */
+    number: NumberFormat,
+    /** Geographic location */
+    location: NumberLocation,
+    /** Carrier name */
+    carrier: z.enum(["T-Mobile", "AT&T", "Verizon", "Twilio", "Contiguity", "International Partner"]),
+    /** Number capabilities */
+    capabilities: NumberCapabilities,
+    /** Number health metrics */
+    health: NumberHealth,
+    /** Additional data */
+    data: NumberData,
+    /** Creation timestamp */
+    created_at: z.number(),
+    /** Pricing information */
+    pricing: NumberPricing,
+    /** Lease ID */
+    lease_id: z.string(),
+    /** Lease status */
+    lease_status: z.enum(["active", "expired", "terminated"]),
+    /** Lease billing information */
+    billing: LeasedBilling
+});
+export const LeaseLeasedResponse = z.object({
+    /** Number of leased numbers */
+    leased: z.number(),
+    /** User's leased numbers */
+    numbers: z.array(LeasedNumber)
+});
+// Using the new base response builder
+export const LeaseLeasedResponseBuilder = createResponse(LeaseLeasedResponse);
+/**
+ * Gets all phone numbers currently leased by the user
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.leased();
+ * console.log(`You have ${response.leased} leased numbers`);
+ *
+ * // List all active leases
+ * const activeLeases = response.numbers.filter(
+ *   num => num.lease_status === 'active'
+ * );
+ * console.log(`Active leases: ${activeLeases.length}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Find leases by capabilities
+ * const response = await contiguity.lease.leased();
+ *
+ * const imessageNumbers = response.numbers.filter(
+ *   num => num.capabilities.channels.includes('imessage')
+ * );
+ *
+ * const whatsappNumbers = response.numbers.filter(
+ *   num => num.capabilities.channels.includes('whatsapp')
+ * );
+ *
+ * console.log(`iMessage numbers: ${imessageNumbers.length}`);
+ * console.log(`WhatsApp numbers: ${whatsappNumbers.length}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check lease expiration dates
+ * const response = await contiguity.lease.leased();
+ *
+ * response.numbers.forEach(num => {
+ *   console.log(`${num.number.formatted}:`);
+ *   console.log(`  Lease ID: ${num.lease_id}`);
+ *   console.log(`  Status: ${num.lease_status}`);
+ *
+ *   if (num.billing.period.end) {
+ *     const endDate = new Date(num.billing.period.end * 1000);
+ *     console.log(`  Expires: ${endDate.toLocaleDateString()}`);
+ *   } else {
+ *     console.log(`  Billing: Month-to-month`);
+ *   }
+ * });
+ * ```
+ */
+export async function _leasedNumbers() {
+    const response = await this.request("/numbers/leased", {
+        method: "GET",
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: LeaseLeasedResponse,
+            raw: LeaseLeasedResponseBuilder.raw
+        }
+    });
+}

package/dist/services/lease/terminate.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export declare const LeaseTerminateRequest: z.ZodObject<{
+    number: z.ZodString;
+}, z.core.$strip>;
+export declare const LeaseTerminateResponse: z.ZodObject<{
+    lease_id: z.ZodString;
+    number_id: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        terminated: "terminated";
+    }>;
+    terminated_at: z.ZodNumber;
+}, z.core.$strip>;
+export declare const LeaseTerminateResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    lease_id: z.ZodString;
+    number_id: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        terminated: "terminated";
+    }>;
+    terminated_at: z.ZodNumber;
+}, z.core.$strip>>;
+export type LeaseTerminateParams = z.infer<typeof LeaseTerminateRequest>;
+export type LeaseTerminateResponseType = z.infer<typeof LeaseTerminateResponse>;
+/**
+ * Terminates your lease for a number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.terminate({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Lease ${response.lease_id} terminated`);
+ * console.log(`Number: ${response.number_id}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Terminated at: ${new Date(response.terminated_at * 1000)}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Terminate lease with confirmation
+ * try {
+ *   const response = await contiguity.lease.terminate({
+ *     number: "+1234567890"
+ *   });
+ *
+ *   if (response.status === 'terminated') {
+ *     console.log('✓ Lease successfully terminated');
+ *     console.log(`Termination date: ${new Date(response.terminated_at * 1000).toLocaleDateString()}`);
+ *   }
+ * } catch (error) {
+ *   console.error('Failed to terminate lease:', error.message);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Bulk terminate multiple leases
+ * const numbersToTerminate = ["+1234567890", "+0987654321"];
+ *
+ * const results = await Promise.allSettled(
+ *   numbersToTerminate.map(number =>
+ *     contiguity.lease.terminate({ number })
+ *   )
+ * );
+ *
+ * results.forEach((result, index) => {
+ *   const number = numbersToTerminate[index];
+ *   if (result.status === 'fulfilled') {
+ *     console.log(`✓ ${number}: Lease terminated`);
+ *   } else {
+ *     console.log(`✗ ${number}: Failed to terminate - ${result.reason.message}`);
+ *   }
+ * });
+ * ```
+ */
+export declare function _leaseTerminate(this: any, params: LeaseTerminateParams): Promise<any>;
+//# sourceMappingURL=terminate.d.ts.map

package/dist/services/lease/terminate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminate.d.ts","sourceRoot":"","sources":["../../../src/services/lease/terminate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;iBAGhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;iBASjC,CAAC;AAGH,eAAO,MAAM,6BAA6B;;;;;;;;;kBAAyC,CAAC;AAEpF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,CAa3F"}

package/dist/services/lease/terminate.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+export const LeaseTerminateRequest = z.object({
+    /** Phone number in E.164 format to terminate lease for */
+    number: z.string().regex(/^\+[1-9]\d{1,14}$/, "Phone number must be in E.164 format"),
+});
+export const LeaseTerminateResponse = z.object({
+    /** Terminated lease ID */
+    lease_id: z.string(),
+    /** Number ID */
+    number_id: z.string(),
+    /** The lease's new status */
+    status: z.enum(["active", "expired", "terminated"]),
+    /** Termination timestamp */
+    terminated_at: z.number()
+});
+// Using the new base response builder
+export const LeaseTerminateResponseBuilder = createResponse(LeaseTerminateResponse);
+/**
+ * Terminates your lease for a number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.terminate({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Lease ${response.lease_id} terminated`);
+ * console.log(`Number: ${response.number_id}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Terminated at: ${new Date(response.terminated_at * 1000)}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Terminate lease with confirmation
+ * try {
+ *   const response = await contiguity.lease.terminate({
+ *     number: "+1234567890"
+ *   });
+ *
+ *   if (response.status === 'terminated') {
+ *     console.log('✓ Lease successfully terminated');
+ *     console.log(`Termination date: ${new Date(response.terminated_at * 1000).toLocaleDateString()}`);
+ *   }
+ * } catch (error) {
+ *   console.error('Failed to terminate lease:', error.message);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Bulk terminate multiple leases
+ * const numbersToTerminate = ["+1234567890", "+0987654321"];
+ *
+ * const results = await Promise.allSettled(
+ *   numbersToTerminate.map(number =>
+ *     contiguity.lease.terminate({ number })
+ *   )
+ * );
+ *
+ * results.forEach((result, index) => {
+ *   const number = numbersToTerminate[index];
+ *   if (result.status === 'fulfilled') {
+ *     console.log(`✓ ${number}: Lease terminated`);
+ *   } else {
+ *     console.log(`✗ ${number}: Failed to terminate - ${result.reason.message}`);
+ *   }
+ * });
+ * ```
+ */
+export async function _leaseTerminate(params) {
+    const validatedParams = LeaseTerminateRequest.parse(params);
+    const response = await this.request(`/numbers/leased/${encodeURIComponent(validatedParams.number)}`, {
+        method: "DELETE",
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: LeaseTerminateResponse,
+            raw: LeaseTerminateResponseBuilder.raw
+        }
+    });
+}

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { ContiguityClient } from "@/client/fetch";
+import type { WithMetadata } from "@/types/metadata";
+import { type OTPNewParams, OTPNewResponse } from "./new";
+import { type OTPVerifyParams, OTPVerifyResponse } from "./verify";
+import { type OTPResendParams, OTPResendResponse } from "./resend";
+export type OTPNewResponseType = z.infer<typeof OTPNewResponse>;
+export type OTPVerifyResponseType = z.infer<typeof OTPVerifyResponse>;
+export type OTPResendResponseType = z.infer<typeof OTPResendResponse>;
+/**
+ * OTP service for sending, verifying, and resending one-time passwords
+ */
+export declare class OTPService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send a new OTP to the specified phone number
+     */
+    new(params: OTPNewParams): Promise<WithMetadata<OTPNewResponseType>>;
+    /**
+     * Verify an OTP code
+     */
+    verify(params: OTPVerifyParams): Promise<WithMetadata<OTPVerifyResponseType>>;
+    /**
+     * Resend an OTP to the same phone number
+     */
+    resend(params: OTPResendParams): Promise<WithMetadata<OTPResendResponseType>>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/otp/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,EAAW,KAAK,YAAY,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AACnE,OAAO,EAAc,KAAK,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,EAAc,KAAK,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE/E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACtE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEtE;;GAEG;AACH,qBAAa,UAAW,SAAQ,gBAAgB;gBAChC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;IAI1E;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;IAInF;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;CAGtF"}

package/dist/services/otp/index.js

@@ -0,0 +1,30 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _otpNew } from "./new";
+import { _otpVerify } from "./verify";
+import { _otpResend } from "./resend";
+/**
+ * OTP service for sending, verifying, and resending one-time passwords
+ */
+export class OTPService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send a new OTP to the specified phone number
+     */
+    async new(params) {
+        return _otpNew.call(this, params);
+    }
+    /**
+     * Verify an OTP code
+     */
+    async verify(params) {
+        return _otpVerify.call(this, params);
+    }
+    /**
+     * Resend an OTP to the same phone number
+     */
+    async resend(params) {
+        return _otpResend.call(this, params);
+    }
+}

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const OTPNewRequest: z.ZodObject<{
+    to: z.ZodString;
+    language: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const OTPNewResponse: z.ZodObject<{
+    otp_id: z.ZodString;
+}, z.core.$strip>;
+export declare const OTPNewResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    otp_id: z.ZodString;
+}, z.core.$strip>>;
+export type OTPNewParams = z.infer<typeof OTPNewRequest>;
+export type OTPNewResponse = z.infer<typeof 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 declare function _otpNew(this: any, params: OTPNewParams): Promise<any>;
+//# sourceMappingURL=new.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../../src/services/otp/new.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;iBAOxB,CAAA;AAEF,eAAO,MAAM,cAAc;;iBAGzB,CAAA;AAGF,eAAO,MAAM,qBAAqB;;kBAAiC,CAAA;AAEnE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,CAc3E"}