contiguity 0.0.9 → 0.1.0

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const WhatsAppTypingRequest: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    action: z.ZodEnum<{
+        start: "start";
+        stop: "stop";
+    }>;
+}, z.core.$strip>;
+export declare const WhatsAppTypingResponse: z.ZodObject<{
+    status: z.ZodString;
+}, z.core.$strip>;
+export type WhatsAppTypingParams = z.infer<typeof WhatsAppTypingRequest>;
+export type WhatsAppTypingResponseType = z.infer<typeof WhatsAppTypingResponse>;
+/**
+ * Start or stop sending typing indicators over WhatsApp
+ *
+ * @example
+ * ```typescript
+ * // Start typing indicator
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   action: "start"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Stop typing indicator with specific sender number
+ * const response = await contiguity.whatsapp.typing({
+ *   to: "+1234567890",
+ *   from: "+15555555555",
+ *   action: "stop"
+ * });
+ * console.log(`Typing status: ${response.status}`);
+ * ```
+ */
+export declare function _whatsAppTyping(this: any, params: WhatsAppTypingParams): Promise<any>;
+//# sourceMappingURL=typing.d.ts.map

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

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

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

package/dist/types/base.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+/**
+ * Base response builder that automatically creates typed responses with metadata
+ * This creates flattened responses where the data is combined with metadata
+ */
+export declare class BaseResponseBuilder<T extends z.ZodObject<any>> {
+    readonly schema: T;
+    constructor(schema: T);
+    get response(): T;
+    get flattened(): z.ZodObject<{
+        [x: string]: any;
+    }, z.core.$strip>;
+}
+export declare function createResponse<T extends z.ZodObject<any>>(schema: T): BaseResponseBuilder<T>;
+export type BaseResponse<T extends BaseResponseBuilder<any>> = z.infer<T['response']>;
+export type FlattenedResponse<T extends BaseResponseBuilder<any>> = z.infer<T['flattened']>;
+//# sourceMappingURL=base.d.ts.map

package/dist/types/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC;aAC3B,MAAM,EAAE,CAAC;gBAAT,MAAM,EAAE,CAAC;IAErC,IAAI,QAAQ,MAEX;IAED,IAAI,SAAS;;sBAEZ;CACJ;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,0BAEnE;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;AACtF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC"}

package/dist/types/base.js

@@ -0,0 +1,20 @@
+import { ContiguityResponse } from "@/types/response";
+/**
+ * Base response builder that automatically creates typed responses with metadata
+ * This creates flattened responses where the data is combined with metadata
+ */
+export class BaseResponseBuilder {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    get response() {
+        return this.schema;
+    }
+    get flattened() {
+        return ContiguityResponse.extend(this.schema.shape);
+    }
+}
+export function createResponse(schema) {
+    return new BaseResponseBuilder(schema);
+}

package/dist/types/common.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+/**
+ * Common validation schemas used across multiple services
+ */
+export declare const E164PhoneNumber: z.ZodString;
+export declare const MessageContent: z.ZodString;
+export declare const OptionalSenderNumber: z.ZodOptional<z.ZodString>;
+export declare const AttachmentList: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const SingleOrMultipleEmails: (maxCount?: number, fieldName?: string) => z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+export declare const TypingAction: z.ZodEnum<{
+    start: "start";
+    stop: "stop";
+}>;
+export declare const NumberStatus: z.ZodEnum<{
+    available: "available";
+    "g-available": "g-available";
+    leased: "leased";
+    unavailable: "unavailable";
+}>;
+export declare const LeaseStatus: z.ZodEnum<{
+    active: "active";
+    expired: "expired";
+    terminated: "terminated";
+}>;
+export declare const BillingMethod: z.ZodEnum<{
+    monthly: "monthly";
+    service_contract: "service_contract";
+    goodwill: "goodwill";
+}>;
+export declare const Currency: z.ZodEnum<{
+    USD: "USD";
+    EUR: "EUR";
+    GBP: "GBP";
+    CAD: "CAD";
+    AUD: "AUD";
+}>;
+export declare const Carrier: z.ZodEnum<{
+    "T-Mobile": "T-Mobile";
+    "AT&T": "AT&T";
+    Verizon: "Verizon";
+    Contiguity: "Contiguity";
+    "International Partner": "International Partner";
+}>;
+export declare const MessageChannel: z.ZodEnum<{
+    sms: "sms";
+    mms: "mms";
+    rcs: "rcs";
+    imessage: "imessage";
+    whatsapp: "whatsapp";
+}>;
+export declare const createFallbackSchema: <T extends string>(serviceType: T, fallbackConditions: readonly [T, ...T[]]) => z.ZodOptional<z.ZodObject<{
+    when: z.ZodArray<z.ZodEnum<{ [k_1 in T]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
+    from: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type RequestFunction<TParams, TResponse> = (this: any, params: TParams) => Promise<TResponse>;
+//# sourceMappingURL=common.d.ts.map

package/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAGH,eAAO,MAAM,eAAe,aAAgF,CAAC;AAG7G,eAAO,MAAM,cAAc,aAA+C,CAAC;AAG3E,eAAO,MAAM,oBAAoB,4BAAwB,CAAC;AAG1D,eAAO,MAAM,cAAc,wCAGZ,CAAC;AAGhB,eAAO,MAAM,sBAAsB,GAAI,WAAU,MAAW,EAAE,YAAW,MAAgB,8DAKnF,CAAC;AAGP,eAAO,MAAM,YAAY;;;EAAgF,CAAC;AAG1G,eAAO,MAAM,YAAY;;;;;EAAgE,CAAC;AAE1F,eAAO,MAAM,WAAW;;;;EAA8C,CAAC;AAEvE,eAAO,MAAM,aAAa;;;;EAAsD,CAAC;AAEjF,eAAO,MAAM,QAAQ;;;;;;EAA8C,CAAC;AAEpE,eAAO,MAAM,OAAO;;;;;;EAMlB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,MAAM,EACjD,aAAa,CAAC,EACd,oBAAoB,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;;;kBAM/B,CAAC;AAGd,MAAM,MAAM,eAAe,CAAC,OAAO,EAAE,SAAS,IAAI,CAC9C,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,OAAO,KACd,OAAO,CAAC,SAAS,CAAC,CAAC"}

package/dist/types/common.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+/**
+ * Common validation schemas used across multiple services
+ */
+// Phone number validation - used in text, iMessage, WhatsApp, and lease services
+export const E164PhoneNumber = z.string().regex(/^\+[1-9]\d{1,14}$/, "Phone number must be in E.164 format");
+// Message validation - used across messaging services
+export const MessageContent = z.string().min(1, "Message cannot be empty");
+// Optional sender number - used across messaging services
+export const OptionalSenderNumber = z.string().optional();
+// Attachment validation - used in iMessage and WhatsApp
+export const AttachmentList = z
+    .array(z.string().min(1, "Attachment cannot be empty"))
+    .max(10, "Maximum 10 attachments allowed")
+    .optional();
+// Email validation patterns - used in email service
+export const SingleOrMultipleEmails = (maxCount = 10, fieldName = "email") => z.union([
+    z.email(`Must be a valid ${fieldName} address`),
+    z.array(z.email(`Must be a valid ${fieldName} address`))
+        .max(maxCount, `Maximum ${maxCount} ${fieldName} addresses allowed`)
+]);
+// Typing action validation - used in iMessage and WhatsApp typing
+export const TypingAction = z.enum(["start", "stop"]).describe("Action must be either 'start' or 'stop'");
+// Common status enums
+export const NumberStatus = z.enum(["available", "g-available", "leased", "unavailable"]);
+export const LeaseStatus = z.enum(["active", "expired", "terminated"]);
+export const BillingMethod = z.enum(["monthly", "service_contract", "goodwill"]);
+export const Currency = z.enum(["USD", "EUR", "GBP", "CAD", "AUD"]);
+export const Carrier = z.enum([
+    "T-Mobile",
+    "AT&T",
+    "Verizon",
+    "Contiguity",
+    "International Partner"
+]);
+export const MessageChannel = z.enum([
+    "sms",
+    "mms",
+    "rcs",
+    "imessage",
+    "whatsapp"
+]);
+export const createFallbackSchema = (serviceType, fallbackConditions) => z.object({
+    /** When to fallback to SMS/RCS */
+    when: z.array(z.enum(fallbackConditions)).min(1, "At least one fallback condition must be specified"),
+    /** Fallback sender number */
+    from: OptionalSenderNumber
+}).optional();

package/dist/types/error.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const ContiguityAPIError: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    api_version: z.ZodString;
+    object: z.ZodString;
+    data: z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface ContiguityErrorData {
+    data: {
+        status: number;
+        error: string;
+    };
+}
+export declare class ContiguityError extends Error {
+    readonly status: number;
+    constructor(response: ContiguityErrorData);
+    static fromError(error: any): ContiguityError;
+    toString(): string;
+    toJSON(): {
+        message: string;
+        status: number;
+    };
+}
+export declare class ContiguitySDKError extends Error {
+    readonly status: string;
+    constructor(message: string, status?: string);
+    toString(): string;
+    toJSON(): {
+        message: string;
+        status: string;
+    };
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/types/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/types/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;iBAS7B,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE;QACF,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACtC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,QAAQ,EAAE,mBAAmB;IAMzC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG;IASlB,QAAQ;IAIjB,MAAM;;;;CAMT;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IACzC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAoB;IAOhD,QAAQ;IAIjB,MAAM;;;;CAMT"}

package/dist/types/error.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const ContiguityAPIError = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    api_version: z.string(),
+    object: z.string(),
+    data: z.object({
+        status: z.number(),
+        error: z.string(),
+    }),
+});
+export class ContiguityError extends Error {
+    status;
+    constructor(response) {
+        super(response.data.error);
+        this.message = response.data.error;
+        this.status = response.data.status;
+    }
+    static fromError(error) {
+        return new ContiguityError({
+            data: {
+                error: error.message || "Unknown error",
+                status: error.status || 500,
+            }
+        });
+    }
+    toString() {
+        return `[Contiguity Error]: ${this.message} (status: ${this.status})`;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            status: this.status,
+        };
+    }
+}
+export class ContiguitySDKError extends Error {
+    status;
+    constructor(message, status = 'sdk_error') {
+        super(message);
+        this.message = message;
+        this.status = status;
+        this.name = '[Contiguity SDK Error]';
+    }
+    toString() {
+        return `[Contiguity SDK Error]: ${this.message} (status: ${this.status})`;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            status: this.status,
+        };
+    }
+}

package/dist/types/metadata.d.ts

@@ -0,0 +1,10 @@
+export interface ContiguityMetadata {
+    id: string;
+    timestamp: number;
+    api_version: string;
+    object: string;
+}
+export type WithMetadata<T> = T & {
+    metadata: ContiguityMetadata;
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/types/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/types/metadata.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;CAChC,CAAC"}

package/dist/types/response.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const ContiguityResponse: z.ZodObject<{
+    metadata: z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        api_version: z.ZodString;
+        object: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=response.d.ts.map

package/dist/types/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/types/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;iBAQ7B,CAAC"}

package/dist/types/response.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export const ContiguityResponse = z.object({
+    metadata: z.object({
+        id: z.string(),
+        timestamp: z.number(),
+        api_version: z.string(),
+        object: z.string(),
+    }),
+    // we run zod.extend with data here.
+});

package/dist/utils/parse.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/**
+ * Normalizes API responses to either raw or flattened format
+ * This utility handles the complex logic of parsing different response formats
+ * from the Contiguity API and normalizing them consistently.
+ */
+export declare function parseContiguityResponse<T extends z.ZodType, R extends z.ZodType>(response: any, dataSchema: T, rawResponseSchema: R, returnRaw?: boolean): any;
+//# sourceMappingURL=parse.d.ts.map

package/dist/utils/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/utils/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,OAAO,EAC5E,QAAQ,EAAE,GAAG,EACb,UAAU,EAAE,CAAC,EACb,iBAAiB,EAAE,CAAC,EACpB,SAAS,GAAE,OAAe,GAC3B,GAAG,CAiCL"}

package/dist/utils/parse.js

@@ -0,0 +1,36 @@
+/**
+ * Normalizes API responses to either raw or flattened format
+ * This utility handles the complex logic of parsing different response formats
+ * from the Contiguity API and normalizing them consistently.
+ */
+export function parseContiguityResponse(response, dataSchema, rawResponseSchema, returnRaw = false) {
+    // Handle different response formats:
+    // 1. Already wrapped in response format (response.object === "response")
+    // 2. Direct data that needs wrapping
+    // 3. Fallback to raw parsing
+    const validatedResponse = response.object === "response"
+        ? rawResponseSchema.parse(response)
+        : dataSchema.safeParse(response).success
+            ? {
+                id: response.id || "unknown",
+                timestamp: response.timestamp || Date.now(),
+                api_version: response.api_version || "unknown",
+                object: response.object || "unknown",
+                data: dataSchema.parse(response),
+            }
+            : rawResponseSchema.parse(response);
+    if (returnRaw) {
+        return validatedResponse;
+    }
+    // For flattened responses, we need to handle both formats
+    const rawData = rawResponseSchema.parse(validatedResponse);
+    return {
+        ...rawData.data,
+        metadata: {
+            id: rawData.id,
+            timestamp: rawData.timestamp,
+            api_version: rawData.api_version,
+            object: rawData.object,
+        },
+    };
+}

package/dist/utils/request.d.ts

@@ -1,28 +1,6 @@
-declare const BASE_URLS: {
-    readonly send: "https://api.contiguity.com/send";
-    readonly otp: "https://api.contiguity.com/otp";
-    readonly domains: "https://api.contiguity.com/domains";
-    readonly numbers: "https://api.contiguity.com/numbers";
-    readonly conversations: "https://api.contiguity.com/conversations";
-    readonly voice: "https://api.contiguity.com/voice";
-    readonly entitlements: "https://api.contiguity.com/entitlements";
-};
-export type ApiBase = keyof typeof BASE_URLS;
-export interface RequestConfig {
-    token: string;
-    base: ApiBase;
-    debug?: boolean;
-}
-export declare function request<T = Record<string, unknown>>(config: RequestConfig, path: string, options?: {
-    method?: "GET" | "POST" | "DELETE";
-    body?: Record<string, unknown>;
-}): Promise<T & {
-    metadata: {
-        id: string;
-        timestamp: string;
-        api_version: string;
-        object: string;
-    };
-}>;
-export {};
+import { z } from "zod";
+/**
+ * Standard request function factory - reduces duplication across services
+ */
+export declare function createRequestFunction<TRequest extends z.ZodType, TResponse extends z.ZodType, TRawResponse extends z.ZodType>(requestSchema: TRequest, responseSchema: TResponse, rawResponseSchema: TRawResponse, endpoint: string, method?: 'GET' | 'POST' | 'PUT' | 'DELETE'): (this: any, params?: z.infer<TRequest>) => Promise<any>;
 //# sourceMappingURL=request.d.ts.map

package/dist/utils/request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/utils/request.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS;;;;;;;;CAQL,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,SAAS,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrD,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IACL,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7B,GACP,OAAO,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,CAqCnG"}
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/utils/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,SAAS,CAAC,CAAC,OAAO,EAAE,SAAS,SAAS,CAAC,CAAC,OAAO,EAAE,YAAY,SAAS,CAAC,CAAC,OAAO,EACzH,aAAa,EAAE,QAAQ,EACvB,cAAc,EAAE,SAAS,EACzB,iBAAiB,EAAE,YAAY,EAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAiB,IAE5B,MAAM,GAAG,EAAE,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAG,OAAO,CAAC,GAAG,CAAC,CA8C7E"}

package/dist/utils/request.js

@@ -1,41 +1,47 @@
-import { transformResponse } from "./response.js";
-import { ContiguityError } from "./errors.js";
-const BASE_URLS = {
-    send: "https://api.contiguity.com/send",
-    otp: "https://api.contiguity.com/otp",
-    domains: "https://api.contiguity.com/domains",
-    numbers: "https://api.contiguity.com/numbers",
-    conversations: "https://api.contiguity.com/conversations",
-    voice: "https://api.contiguity.com/voice",
-    entitlements: "https://api.contiguity.com/entitlements",
-};
-export async function request(config, path, options = {}) {
-    const { token, base, debug } = config;
-    const url = `${BASE_URLS[base]}${path}`;
-    const headers = {
-        "Content-Type": "application/json",
-        Authorization: `Token ${token}`,
+/**
+ * Standard request function factory - reduces duplication across services
+ */
+export function createRequestFunction(requestSchema, responseSchema, rawResponseSchema, endpoint, method = 'POST') {
+    return async function (params) {
+        let validatedParams;
+        let url = endpoint;
+        let body;
+        if (params !== undefined) {
+            validatedParams = requestSchema.parse(params);
+            // Handle path parameters (for endpoints with {param})
+            if (endpoint.includes('{') && endpoint.includes('}')) {
+                // Extract path parameter name (e.g., "{number}" -> "number")
+                const pathParamMatch = endpoint.match(/\{(\w+)\}/);
+                if (pathParamMatch && pathParamMatch[1] && validatedParams && typeof validatedParams === 'object') {
+                    const pathParam = pathParamMatch[1];
+                    const pathValue = validatedParams[pathParam];
+                    if (pathValue) {
+                        url = endpoint.replace(`{${pathParam}}`, encodeURIComponent(pathValue));
+                        // Remove path param from body
+                        const bodyParams = { ...validatedParams };
+                        delete bodyParams[pathParam];
+                        // Only set body if there are remaining params and not GET/DELETE
+                        if (Object.keys(bodyParams).length > 0 && method !== 'GET' && method !== 'DELETE') {
+                            body = JSON.stringify(bodyParams);
+                        }
+                    }
+                }
+            }
+            else if (method !== 'GET' && method !== 'DELETE') {
+                // For non-path-param endpoints, use all params as body
+                body = JSON.stringify(validatedParams);
+            }
+        }
+        const response = await this.request(url, {
+            method,
+            ...(body && { body })
+        });
+        return this.parse({
+            response,
+            schemas: {
+                sdk: responseSchema,
+                raw: rawResponseSchema
+            }
+        });
     };
-    if (debug) {
-        console.debug("[Contiguity]", options.method ?? "GET", url, options.body ?? "");
-    }
-    const res = await fetch(url, {
-        method: options.method ?? "GET",
-        headers,
-        body: options.body ? JSON.stringify(options.body) : undefined,
-    });
-    const json = (await res.json());
-    if (!res.ok) {
-        // Default API shape: data: { error, status }. Occasional: { message, status } at top level.
-        const errMsg = json.data?.error ??
-            json.message ??
-            json.object ??
-            "Unknown error";
-        const status = json.data?.status ?? json.status ?? res.status;
-        const data = json.data?.agreement_url != null
-            ? { agreement_url: String(json.data.agreement_url) }
-            : undefined;
-        throw new ContiguityError(errMsg, status, undefined, data);
-    }
-    return transformResponse(json);
 }

package/package.json

@@ -1,46 +1,49 @@
 {
     "name": "contiguity",
-    "version": "0.0.9",
-    "description": "Contiguity JavaScript/TypeScript SDK",
+    "version": "0.1.0",
     "type": "module",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js",
-            "default": "./dist/index.js"
-        }
-    },
+    "description": "Contiguity's official TypeScript SDK",
+    "author": "Contiguity",
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "files": [
-        "dist"
+        "dist/**/*",
+        "README.md",
+        "LICENSE.md"
     ],
-    "scripts": {
-        "build": "tsc",
-        "test": "bun run build && vitest run",
-        "prepublishOnly": "tsc",
-        "pack": "bun pm pack",
-        "publish:dry": "bun run build && bun publish --dry-run",
-        "publish": "bun run build && npm publish"
-    },
     "keywords": [
         "contiguity",
         "sms",
         "email",
-        "otp",
+        "whatsapp",
         "imessage",
-        "whatsapp"
+        "otp",
+        "send texts",
+        "api",
+        "sdk"
     ],
-    "license": "MIT",
+    "homepage": "https://contiguity.com",
+    "bugs": {
+        "url": "https://github.com/contiguity/javascript/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/contiguity/javascript.git"
+    },
+    "documentation": "https://docs.contiguity.com/sdk/js/overview",
+    "scripts": {
+        "publish": "bun publish --access public",
+        "dev": "bun run src/index.ts",
+        "build": "bunx tsc && bun build src/index.ts --outdir=dist --format=esm --target=node",
+        "typecheck": "bunx tsc --noEmit",
+        "update-deps": "npx npm-check-updates"
+    },
     "dependencies": {
-        "zod": "^4.3.6"
+        "zod": "^4.0.17"
     },
     "devDependencies": {
-        "@types/node": "^22.19.11",
-        "typescript": "^5.9.3",
-        "vitest": "^3.2.4"
-    },
-    "engines": {
-        "node": ">=18"
+        "typescript": "^5.9.2"
     }
 }