contiguity 0.0.4 → 0.0.6

package/dist/services/whatsapp/send.js

@@ -1,60 +0,0 @@
-import { z } from "zod";
-import { E164PhoneNumber, OptionalSenderNumber, MessageContent, AttachmentList, createFallbackSchema } from "@/types/common";
-export const WhatsAppSendRequest = 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,
-    /** The WhatsApp message to send */
-    message: MessageContent,
-    /** Should Contiguity fallback to SMS/RCS if the recipient does not have WhatsApp, or if WhatsApp fails to send? */
-    fallback: createFallbackSchema("whatsapp", ["whatsapp_unsupported", "whatsapp_fails"]),
-    /** Attachments to send. Can be a URL to your attachment (e.g. example.com/image.png) or a base64 string. Max 10 attachments, with a cumulative size of 50MB */
-    attachments: AttachmentList
-});
-export const WhatsAppResponse = z.object({
-    /** The message's ID. Use it to refer to this message in the future, when checking the status of the message or finding it in the Console */
-    message_id: z.string(),
-});
-/**
- * Sends a WhatsApp message
- *
- * @example
- * ```typescript
- * const response = await contiguity.whatsapp.send({
- *   to: "+1234567890",
- *   message: "Hello from Contiguity!"
- * });
- * console.log(`Message ID: ${response.message_id}`);
- * ```
- *
- * @example
- * ```typescript
- * // Send with fallback to SMS and attachments
- * const response = await contiguity.whatsapp.send({
- *   to: "+1234567890",
- *   from: "+15555555555",
- *   message: "Check out this image!",
- *   fallback: {
- *     when: ["whatsapp_unsupported", "whatsapp_fails"],
- *     from: "+15555555555"
- *   },
- *   attachments: [
- *     "https://example.com/image.png",
- *     "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34..."
- *   ]
- * });
- * console.log(`Message ID: ${response.message_id}`);
- * ```
- */
-export async function _whatsAppSend(params) {
-    const validatedParams = WhatsAppSendRequest.parse(params);
-    const response = await this.request("/send/whatsapp", {
-        method: "POST",
-        body: JSON.stringify(validatedParams),
-    });
-    return this.parse({
-        response,
-        schema: WhatsAppResponse
-    });
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-/**
- * 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,
-        },
-    };
-}