contiguity 0.0.9 → 0.1.0

package/dist/services/lease/available.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export const NumberCapabilities = z.object({
+    /** International SMS support (generally only T-Mobile numbers support this) */
+    intl_sms: z.boolean(),
+    /** Supported channels */
+    channels: z.array(z.enum(["sms", "mms", "rcs", "imessage", "whatsapp"]))
+});
+export const NumberHealth = z.object({
+    /** Reputation score 0.00-0.99. >0.80 is considered acceptable for all applications. <0.70 should be used for messages you care less about */
+    reputation: z.number().min(0).max(1),
+    /** Number of previous lessees */
+    previous_owners: z.number()
+});
+export const NumberLocation = z.object({
+    /** 2-letter country code */
+    country: z.string(),
+    /** Region/state */
+    region: z.string(),
+    /** City */
+    city: z.string()
+});
+export const NumberFormat = z.object({
+    /** E.164 format */
+    e164: z.string(),
+    /** Formatted phone number */
+    formatted: z.string()
+});
+export const NumberData = z.object({
+    /** Entitlements required to lease this number */
+    requirements: z.array(z.enum(["imessage_entitlement_required", "whatsapp_entitlement_required", "enterprise_plan_required"])),
+    /** E911 capability */
+    e911_capable: z.boolean()
+});
+export const NumberPricing = z.object({
+    /** Currency */
+    currency: z.enum(["USD", "EUR", "GBP", "CAD", "AUD"]),
+    /** One-time fee */
+    upfront_fee: z.number(),
+    /** Monthly rate */
+    monthly_rate: z.number()
+});
+export const AvailableNumber = z.object({
+    /** Phone number in E.164 format */
+    id: z.string(),
+    /** Number status */
+    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", "Contiguity", "International Partner"]),
+    /** Number capabilities */
+    capabilities: NumberCapabilities,
+    /** Number health metrics */
+    health: NumberHealth,
+    /** Additional data */
+    data: NumberData,
+    /** Date & time of when the number was provisioned */
+    created_at: z.number(),
+    /** Pricing information */
+    pricing: NumberPricing
+});
+export const LeaseAvailableResponse = z.object({
+    /** Count of available numbers */
+    available: z.number(),
+    /** Available numbers */
+    numbers: z.array(AvailableNumber)
+});
+/**
+ * Gets all phone numbers available for lease
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.available();
+ * console.log(`${response.available} numbers available`);
+ *
+ * // Find numbers with iMessage support
+ * const imessageNumbers = response.numbers.filter(
+ *   num => num.capabilities.channels.includes('imessage')
+ * );
+ * console.log(`Found ${imessageNumbers.length} iMessage-capable numbers`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Find high-reputation numbers in a specific city
+ * const response = await contiguity.lease.available();
+ * const miamiNumbers = response.numbers.filter(
+ *   num => num.location.city === 'Miami' && num.health.reputation > 0.8
+ * );
+ * console.log(`Found ${miamiNumbers.length} high-reputation Miami numbers`);
+ * ```
+ */
+export async function _leaseAvailable() {
+    const response = await this.request("/numbers/leases", {
+        method: "GET",
+    });
+    return this.parse({
+        response,
+        schema: LeaseAvailableResponse
+    });
+}

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const LeaseConfigureFailover: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        selective: "selective";
+    }>>;
+    numbers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const LeaseConfigureRequest: z.ZodObject<{
+    number: z.ZodString;
+    failover: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            selective: "selective";
+        }>>;
+        numbers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LeaseConfigureResponse: z.ZodObject<{
+    number: z.ZodString;
+    failover: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        mode: z.ZodEnum<{
+            all: "all";
+            selective: "selective";
+        }>;
+        numbers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type LeaseConfigureParams = z.infer<typeof LeaseConfigureRequest>;
+export type LeaseConfigureResponseType = z.infer<typeof LeaseConfigureResponse>;
+/**
+ * Configure a leased number (failover, etc.)
+ */
+export declare function _leaseConfigure(this: any, params: LeaseConfigureParams): Promise<any>;
+//# sourceMappingURL=configure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../src/services/lease/configure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;iBAOjC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAKhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBASjC,CAAC;AAEH,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,wBAAsB,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,CAW3F"}

package/dist/services/lease/configure.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { E164PhoneNumber } from "@/types/common";
+export const LeaseConfigureFailover = z.object({
+    /** Enable this number as a failover target */
+    enabled: z.boolean(),
+    /** 'all' = any number can fail over to this one. 'selective' = only specified numbers */
+    mode: z.enum(["all", "selective"]).optional(),
+    /** E.164 numbers this number will cover (selective mode only) */
+    numbers: z.array(z.string()).optional()
+});
+export const LeaseConfigureRequest = z.object({
+    /** Phone number in E.164 format to configure */
+    number: E164PhoneNumber,
+    /** Failover configuration */
+    failover: LeaseConfigureFailover
+});
+export const LeaseConfigureResponse = z.object({
+    /** Number that was configured */
+    number: z.string(),
+    /** Failover configuration */
+    failover: z.object({
+        enabled: z.boolean(),
+        mode: z.enum(["all", "selective"]),
+        numbers: z.array(z.string())
+    })
+});
+/**
+ * Configure a leased number (failover, etc.)
+ */
+export async function _leaseConfigure(params) {
+    const validatedParams = LeaseConfigureRequest.parse(params);
+    const response = await this.request(`/numbers/${encodeURIComponent(validatedParams.number)}/configure`, {
+        method: "POST",
+        body: JSON.stringify({ failover: validatedParams.failover })
+    });
+    return this.parse({
+        response,
+        schema: LeaseConfigureResponse
+    });
+}

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

@@ -0,0 +1,108 @@
+import { z } from "zod";
+export declare const LeaseCreateRequest: z.ZodObject<{
+    number: z.ZodString;
+    billing_method: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        monthly: "monthly";
+        service_contract: "service_contract";
+    }>>>;
+}, z.core.$strip>;
+export declare const LeaseBillingPrice: z.ZodObject<{
+    currency: z.ZodEnum<{
+        USD: "USD";
+        EUR: "EUR";
+        GBP: "GBP";
+        CAD: "CAD";
+        AUD: "AUD";
+    }>;
+    monthly_rate: z.ZodNumber;
+    upfront_fee: z.ZodNumber;
+}, z.core.$strip>;
+export declare const LeaseBillingPeriod: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNull;
+}, z.core.$strip>;
+export declare const LeaseBilling: z.ZodObject<{
+    method: z.ZodEnum<{
+        monthly: "monthly";
+        service_contract: "service_contract";
+        goodwill: "goodwill";
+    }>;
+    price: z.ZodObject<{
+        currency: z.ZodEnum<{
+            USD: "USD";
+            EUR: "EUR";
+            GBP: "GBP";
+            CAD: "CAD";
+            AUD: "AUD";
+        }>;
+        monthly_rate: z.ZodNumber;
+        upfront_fee: z.ZodNumber;
+    }, z.core.$strip>;
+    period: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNull;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LeaseCreateResponse: z.ZodObject<{
+    lease_id: z.ZodString;
+    number: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        terminated: "terminated";
+    }>;
+    billing: z.ZodObject<{
+        method: z.ZodEnum<{
+            monthly: "monthly";
+            service_contract: "service_contract";
+            goodwill: "goodwill";
+        }>;
+        price: z.ZodObject<{
+            currency: z.ZodEnum<{
+                USD: "USD";
+                EUR: "EUR";
+                GBP: "GBP";
+                CAD: "CAD";
+                AUD: "AUD";
+            }>;
+            monthly_rate: z.ZodNumber;
+            upfront_fee: z.ZodNumber;
+        }, z.core.$strip>;
+        period: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNull;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type LeaseCreateParams = z.infer<typeof LeaseCreateRequest>;
+export type LeaseCreateResponseType = z.infer<typeof LeaseCreateResponse>;
+export type LeaseBillingType = z.infer<typeof LeaseBilling>;
+/**
+ * Leases a specific phone number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.create({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Lease ID: ${response.lease_id}`);
+ * console.log(`Number: ${response.number}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Monthly rate: $${response.billing.price.monthly_rate}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Lease with specific billing method
+ * const response = await contiguity.lease.create({
+ *   number: "+1234567890",
+ *   billing_method: "service_contract"
+ * });
+ *
+ * console.log(`Lease created with ${response.billing.method} billing`);
+ * console.log(`Lease starts: ${new Date(response.billing.period.start * 1000)}`);
+ * ```
+ */
+export declare function _leaseCreate(this: any, params: LeaseCreateParams): Promise<any>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/services/lease/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;iBAK7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;iBAK7B,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;iBAOvB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAC;AAKH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,CAarF"}

package/dist/services/lease/create.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+export const LeaseCreateRequest = z.object({
+    /** Phone number in E.164 format to lease */
+    number: z.string().regex(/^\+[1-9]\d{1,14}$/, "Phone number must be in E.164 format"),
+    /** Billing method (service_contract only works if active) */
+    billing_method: z.enum(["monthly", "service_contract"]).default("monthly").optional(),
+});
+export const LeaseBillingPrice = z.object({
+    /** Currency */
+    currency: z.enum(["USD", "EUR", "GBP", "CAD", "AUD"]),
+    /** Monthly rate */
+    monthly_rate: z.number(),
+    /** One-time fee */
+    upfront_fee: z.number()
+});
+export const LeaseBillingPeriod = z.object({
+    /** Lease start timestamp */
+    start: z.number(),
+    /** Always null for month-to-month leases */
+    end: z.null()
+});
+export const LeaseBilling = z.object({
+    /** Billing method */
+    method: z.enum(["monthly", "service_contract", "goodwill"]),
+    /** Pricing information */
+    price: LeaseBillingPrice,
+    /** Billing period */
+    period: LeaseBillingPeriod
+});
+export const LeaseCreateResponse = z.object({
+    /** Lease ID */
+    lease_id: z.string(),
+    /** Phone number ID */
+    number: z.string(),
+    /** Lease status */
+    status: z.enum(["active", "expired", "terminated"]),
+    /** Lease billing information */
+    billing: LeaseBilling
+});
+/**
+ * Leases a specific phone number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.create({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Lease ID: ${response.lease_id}`);
+ * console.log(`Number: ${response.number}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Monthly rate: $${response.billing.price.monthly_rate}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Lease with specific billing method
+ * const response = await contiguity.lease.create({
+ *   number: "+1234567890",
+ *   billing_method: "service_contract"
+ * });
+ *
+ * console.log(`Lease created with ${response.billing.method} billing`);
+ * console.log(`Lease starts: ${new Date(response.billing.period.start * 1000)}`);
+ * ```
+ */
+export async function _leaseCreate(params) {
+    const validatedParams = LeaseCreateRequest.parse(params);
+    const { number, ...body } = validatedParams;
+    const response = await this.request(`/numbers/lease/${encodeURIComponent(number)}`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    return this.parse({
+        response,
+        schema: LeaseCreateResponse
+    });
+}

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

@@ -0,0 +1,133 @@
+import { z } from "zod";
+export declare const LeaseDetailsRequest: z.ZodObject<{
+    number: z.ZodString;
+}, z.core.$strip>;
+export declare const LeaseDetailsResponse: 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 type LeaseDetailsParams = z.infer<typeof LeaseDetailsRequest>;
+export type LeaseDetailsResponseType = z.infer<typeof LeaseDetailsResponse>;
+/**
+ * Gets information about a specific leased number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Number: ${response.number.formatted}`);
+ * console.log(`Lease ID: ${response.lease_id}`);
+ * console.log(`Status: ${response.lease_status}`);
+ * console.log(`Billing method: ${response.billing.method}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check lease billing details
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * const startDate = new Date(response.billing.period.start * 1000);
+ * console.log(`Lease started: ${startDate.toLocaleDateString()}`);
+ *
+ * if (response.billing.period.end) {
+ *   const endDate = new Date(response.billing.period.end * 1000);
+ *   console.log(`Lease ends: ${endDate.toLocaleDateString()}`);
+ * } else {
+ *   console.log(`Month-to-month billing`);
+ * }
+ *
+ * console.log(`Monthly rate: $${response.pricing.monthly_rate}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check number capabilities and health
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Supported channels: ${response.capabilities.channels.join(', ')}`);
+ * console.log(`Reputation score: ${response.health.reputation}`);
+ * console.log(`Previous owners: ${response.health.previous_owners}`);
+ * console.log(`International SMS: ${response.capabilities.intl_sms ? 'Yes' : 'No'}`);
+ * ```
+ */
+export declare function _leaseDetails(this: any, params: LeaseDetailsParams): Promise<any>;
+//# sourceMappingURL=details.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"details.d.ts","sourceRoot":"","sources":["../../../src/services/lease/details.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;iBAG9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAe,CAAC;AAKjD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,CAUvF"}

package/dist/services/lease/details.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { LeasedNumber } from "@/services/lease/leased";
+export const LeaseDetailsRequest = z.object({
+    /** Phone number in E.164 format to get lease details for */
+    number: z.string().regex(/^\+[1-9]\d{1,14}$/, "Phone number must be in E.164 format"),
+});
+export const LeaseDetailsResponse = LeasedNumber;
+/**
+ * Gets information about a specific leased number
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Number: ${response.number.formatted}`);
+ * console.log(`Lease ID: ${response.lease_id}`);
+ * console.log(`Status: ${response.lease_status}`);
+ * console.log(`Billing method: ${response.billing.method}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check lease billing details
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * const startDate = new Date(response.billing.period.start * 1000);
+ * console.log(`Lease started: ${startDate.toLocaleDateString()}`);
+ *
+ * if (response.billing.period.end) {
+ *   const endDate = new Date(response.billing.period.end * 1000);
+ *   console.log(`Lease ends: ${endDate.toLocaleDateString()}`);
+ * } else {
+ *   console.log(`Month-to-month billing`);
+ * }
+ *
+ * console.log(`Monthly rate: $${response.pricing.monthly_rate}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check number capabilities and health
+ * const response = await contiguity.lease.details({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Supported channels: ${response.capabilities.channels.join(', ')}`);
+ * console.log(`Reputation score: ${response.health.reputation}`);
+ * console.log(`Previous owners: ${response.health.previous_owners}`);
+ * console.log(`International SMS: ${response.capabilities.intl_sms ? 'Yes' : 'No'}`);
+ * ```
+ */
+export async function _leaseDetails(params) {
+    const validatedParams = LeaseDetailsRequest.parse(params);
+    const response = await this.request(`/numbers/leased/${encodeURIComponent(validatedParams.number)}`, {
+        method: "GET",
+    });
+    return this.parse({
+        response,
+        schema: LeaseDetailsResponse
+    });
+}

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

@@ -0,0 +1,96 @@
+import { z } from "zod";
+export declare const LeaseGetRequest: z.ZodObject<{
+    number: z.ZodString;
+}, z.core.$strip>;
+export declare const LeaseGetResponse: 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";
+    }>;
+    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>;
+}, z.core.$strip>;
+export type LeaseGetParams = z.infer<typeof LeaseGetRequest>;
+export type LeaseGetResponseType = z.infer<typeof LeaseGetResponse>;
+/**
+ * Gets information about a specific number available for lease
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.lease.get({
+ *   number: "+1234567890"
+ * });
+ *
+ * console.log(`Number: ${response.number.formatted}`);
+ * console.log(`Location: ${response.location.city}, ${response.location.region}`);
+ * console.log(`Reputation: ${response.health.reputation}`);
+ * console.log(`Monthly rate: $${response.pricing.monthly_rate}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check if a number supports specific channels
+ * const response = await contiguity.lease.get({
+ *   number: "+1234567890"
+ * });
+ *
+ * const supportsImessage = response.capabilities.channels.includes('imessage');
+ * const supportsWhatsApp = response.capabilities.channels.includes('whatsapp');
+ *
+ * console.log(`iMessage support: ${supportsImessage}`);
+ * console.log(`WhatsApp support: ${supportsWhatsApp}`);
+ * ```
+ */
+export declare function _leaseGet(this: any, params: LeaseGetParams): Promise<any>;
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/services/lease/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,eAAe;;iBAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAC;AAKH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAU/E"}