@devwithbobby/loops 0.1.11 → 0.1.13

package/dist/component/lib.js

@@ -6,7 +6,7 @@ const LOOPS_API_BASE_URL = "https://app.loops.so/api/v1";
 /**
  * Sanitize error messages to avoid leaking sensitive information
  */
-const sanitizeError = (status, errorText) => {
+const sanitizeError = (status, _errorText) => {
     if (status === 401 || status === 403) {
         return new Error("Authentication failed. Please check your API key.");
     }
@@ -244,7 +244,12 @@ export const listContacts = zq({
         // Sort by createdAt (newest first)
         allContacts.sort((a, b) => b.createdAt - a.createdAt);
         const total = allContacts.length;
-        const paginatedContacts = allContacts.slice(args.offset, args.offset + args.limit);
+        const paginatedContacts = allContacts
+            .slice(args.offset, args.offset + args.limit)
+            .map((contact) => ({
+            ...contact,
+            subscribed: contact.subscribed ?? true, // Ensure subscribed is always boolean
+        }));
         const hasMore = args.offset + args.limit < total;
         return {
             contacts: paginatedContacts,
@@ -321,7 +326,7 @@ export const addContact = za({
                     contactId = findData.id;
                 }
                 // Store/update in our database
-                await ctx.runMutation((internal.lib).storeContact, {
+                await ctx.runMutation(internal.lib.storeContact, {
                     email: args.contact.email,
                     firstName: args.contact.firstName,
                     lastName: args.contact.lastName,
@@ -342,7 +347,7 @@ export const addContact = za({
         }
         // Contact was created successfully
         const data = (await response.json());
-        await ctx.runMutation((internal.lib).storeContact, {
+        await ctx.runMutation(internal.lib.storeContact, {
             email: args.contact.email,
             firstName: args.contact.firstName,
             lastName: args.contact.lastName,
@@ -399,7 +404,7 @@ export const updateContact = za({
             console.error(`Loops API error [${response.status}]:`, errorText);
             throw sanitizeError(response.status, errorText);
         }
-        await ctx.runMutation((internal.lib).storeContact, {
+        await ctx.runMutation(internal.lib.storeContact, {
             email: args.email,
             firstName: args.firstName,
             lastName: args.lastName,
@@ -441,7 +446,7 @@ export const sendTransactional = za({
         if (!response.ok) {
             const errorText = await response.text();
             console.error(`Loops API error [${response.status}]:`, errorText);
-            await ctx.runMutation((internal.lib).logEmailOperation, {
+            await ctx.runMutation(internal.lib.logEmailOperation, {
                 operationType: "transactional",
                 email: args.email,
                 success: false,
@@ -450,7 +455,7 @@ export const sendTransactional = za({
             throw sanitizeError(response.status, errorText);
         }
         const data = (await response.json());
-        await ctx.runMutation((internal.lib).logEmailOperation, {
+        await ctx.runMutation(internal.lib.logEmailOperation, {
             operationType: "transactional",
             email: args.email,
             success: true,
@@ -476,7 +481,7 @@ export const sendEvent = za({
     returns: z.object({
         success: z.boolean(),
     }),
-    handler: async (ctx, args) => {
+    handler: async (_ctx, args) => {
         const response = await fetch(`${LOOPS_API_BASE_URL}/events/send`, {
             method: "POST",
             headers: {
@@ -522,116 +527,12 @@ export const deleteContact = za({
             console.error(`Loops API error [${response.status}]:`, errorText);
             throw sanitizeError(response.status, errorText);
         }
-        await ctx.runMutation((internal.lib).removeContact, {
+        await ctx.runMutation(internal.lib.removeContact, {
             email: args.email,
         });
         return { success: true };
     },
 });
-/**
- * Send a campaign to contacts
- * Note: Campaigns in Loops.so are typically managed from the dashboard.
- * This function sends transactional emails to multiple contacts as a workaround.
- * If you need true campaign functionality, use the Loops.so dashboard or contact their support.
- */
-export const sendCampaign = za({
-    args: z.object({
-        apiKey: z.string(),
-        campaignId: z.string(),
-        emails: z.array(z.string().email()).optional(),
-        transactionalId: z.string().optional(),
-        dataVariables: z.record(z.string(), z.any()).optional(),
-        audienceFilters: z
-            .object({
-            userGroup: z.string().optional(),
-            source: z.string().optional(),
-        })
-            .optional(),
-    }),
-    returns: z.object({
-        success: z.boolean(),
-        messageId: z.string().optional(),
-        sent: z.number().optional(),
-        errors: z.array(z.object({
-            email: z.string(),
-            error: z.string(),
-        })).optional(),
-    }),
-    handler: async (ctx, args) => {
-        // Loops.so doesn't have a campaigns API endpoint
-        // As a workaround, we'll send transactional emails to the specified contacts
-        if (!args.transactionalId) {
-            throw new Error("Campaigns require a transactionalId. " +
-                "Loops.so campaigns are managed from the dashboard. " +
-                "This function sends transactional emails to multiple contacts as a workaround. " +
-                "Please provide a transactionalId to send emails.");
-        }
-        if (!args.emails || args.emails.length === 0) {
-            // If no emails provided but audienceFilters are, we need to query contacts
-            if (args.audienceFilters) {
-                // Query contacts from our database based on filters
-                const contacts = await ctx.runQuery((internal.lib).countContacts, {
-                    userGroup: args.audienceFilters.userGroup,
-                    source: args.audienceFilters.source,
-                });
-                if (contacts === 0) {
-                    return {
-                        success: false,
-                        sent: 0,
-                        errors: [{ email: "audience", error: "No contacts found matching filters" }],
-                    };
-                }
-                // Note: We can't get email list from countContacts, so this is a limitation
-                throw new Error("Campaigns with audienceFilters require emails to be specified. " +
-                    "Please provide the emails array with contacts to send to.");
-            }
-            throw new Error("Campaigns require either emails array or audienceFilters. " +
-                "Please provide at least one email address or use transactional emails for single contacts.");
-        }
-        // Send transactional emails to each contact as a workaround for campaigns
-        let sent = 0;
-        const errors = [];
-        for (const email of args.emails) {
-            try {
-                await ctx.runAction((internal.lib).sendTransactional, {
-                    apiKey: args.apiKey,
-                    transactionalId: args.transactionalId,
-                    email,
-                    dataVariables: args.dataVariables,
-                });
-                sent++;
-                // Log as campaign operation
-                await ctx.runMutation((internal.lib).logEmailOperation, {
-                    operationType: "campaign",
-                    email,
-                    success: true,
-                    campaignId: args.campaignId,
-                    transactionalId: args.transactionalId,
-                });
-            }
-            catch (error) {
-                errors.push({
-                    email,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                // Log failed campaign operation
-                await ctx.runMutation((internal.lib).logEmailOperation, {
-                    operationType: "campaign",
-                    email,
-                    success: false,
-                    campaignId: args.campaignId,
-                    transactionalId: args.transactionalId,
-                    metadata: { error: error instanceof Error ? error.message : String(error) },
-                });
-            }
-        }
-        return {
-            success: sent > 0,
-            sent,
-            errors: errors.length > 0 ? errors : undefined,
-        };
-    },
-});
 /**
  * Trigger a loop for a contact
  * Note: Loops in Loops.so are triggered through events, not a direct API endpoint.
@@ -667,7 +568,7 @@ export const triggerLoop = za({
         const eventName = args.eventName || `loop_${args.loopId}`;
         try {
             // Send event to trigger the loop
-            await ctx.runAction((internal.lib).sendEvent, {
+            await ctx.runAction(internal.lib.sendEvent, {
                 apiKey: args.apiKey,
                 email: args.email,
                 eventName,
@@ -677,7 +578,7 @@ export const triggerLoop = za({
                 },
             });
             // Log as loop operation
-            await ctx.runMutation((internal.lib).logEmailOperation, {
+            await ctx.runMutation(internal.lib.logEmailOperation, {
                 operationType: "loop",
                 email: args.email,
                 success: true,
@@ -691,13 +592,15 @@ export const triggerLoop = za({
         }
         catch (error) {
             // Log failed loop operation
-            await ctx.runMutation((internal.lib).logEmailOperation, {
+            await ctx.runMutation(internal.lib.logEmailOperation, {
                 operationType: "loop",
                 email: args.email,
                 success: false,
                 loopId: args.loopId,
                 eventName,
-                metadata: { error: error instanceof Error ? error.message : String(error) },
+                metadata: {
+                    error: error instanceof Error ? error.message : String(error),
+                },
             });
             throw error;
         }
@@ -729,7 +632,7 @@ export const findContact = za({
         })
             .optional(),
     }),
-    handler: async (ctx, args) => {
+    handler: async (_ctx, args) => {
         const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/find?email=${encodeURIComponent(args.email)}`, {
             method: "GET",
             headers: {
@@ -750,7 +653,10 @@ export const findContact = za({
         let contact = Array.isArray(data) ? data[0] : data;
         // Convert null values to undefined for optional fields (Zod handles undefined but not null in optional())
         if (contact) {
-            contact = Object.fromEntries(Object.entries(contact).map(([key, value]) => [key, value === null ? undefined : value]));
+            contact = Object.fromEntries(Object.entries(contact).map(([key, value]) => [
+                key,
+                value === null ? undefined : value,
+            ]));
         }
         return {
             success: true,
@@ -772,11 +678,13 @@ export const batchCreateContacts = za({
         success: z.boolean(),
         created: z.number().optional(),
         failed: z.number().optional(),
-        results: z.array(z.object({
+        results: z
+            .array(z.object({
             email: z.string(),
             success: z.boolean(),
             error: z.string().optional(),
-        })).optional(),
+        }))
+            .optional(),
     }),
     handler: async (ctx, args) => {
         let created = 0;
@@ -786,7 +694,7 @@ export const batchCreateContacts = za({
         for (const contact of args.contacts) {
             try {
                 // Use the addContact function which handles create/update logic
-                const result = await ctx.runAction((internal.lib).addContact, {
+                const result = await ctx.runAction(internal.lib.addContact, {
                     apiKey: args.apiKey,
                     contact,
                 });
@@ -799,7 +707,7 @@ export const batchCreateContacts = za({
                     results.push({
                         email: contact.email,
                         success: false,
-                        error: "Unknown error"
+                        error: "Unknown error",
                     });
                 }
             }
@@ -846,7 +754,7 @@ export const unsubscribeContact = za({
             console.error(`Loops API error [${response.status}]:`, errorText);
             throw sanitizeError(response.status, errorText);
         }
-        await ctx.runMutation((internal.lib).storeContact, {
+        await ctx.runMutation(internal.lib.storeContact, {
             email: args.email,
             subscribed: false,
         });
@@ -879,7 +787,7 @@ export const resubscribeContact = za({
             console.error(`Loops API error [${response.status}]:`, errorText);
             throw sanitizeError(response.status, errorText);
         }
-        await ctx.runMutation((internal.lib).storeContact, {
+        await ctx.runMutation(internal.lib.storeContact, {
             email: args.email,
             subscribed: true,
         });
@@ -895,11 +803,13 @@ export const detectRecipientSpam = zq({
         timeWindowMs: z.number().default(3600000),
         maxEmailsPerRecipient: z.number().default(10),
     }),
-    returns: z.array(z.object({
+    returns: z.array(z
+        .object({
         email: z.string(),
         count: z.number(),
         timeWindowMs: z.number(),
-    })),
+    })
+        .catchall(z.any())),
     handler: async (ctx, args) => {
         const cutoffTime = Date.now() - args.timeWindowMs;
         const operations = await ctx.db
@@ -971,14 +881,16 @@ export const getEmailStats = zq({
     args: z.object({
         timeWindowMs: z.number().default(86400000),
     }),
-    returns: z.object({
+    returns: z
+        .object({
         totalOperations: z.number(),
         successfulOperations: z.number(),
         failedOperations: z.number(),
         operationsByType: z.record(z.string(), z.number()),
         uniqueRecipients: z.number(),
         uniqueActors: z.number(),
-    }),
+    })
+        .catchall(z.any()),
     handler: async (ctx, args) => {
         const cutoffTime = Date.now() - args.timeWindowMs;
         const operations = await ctx.db
@@ -1041,7 +953,7 @@ export const detectRapidFirePatterns = zq({
                 if (!emailGroups.has(op.email)) {
                     emailGroups.set(op.email, []);
                 }
-                emailGroups.get(op.email).push(op);
+                emailGroups.get(op.email)?.push(op);
             }
         }
         for (const [email, ops] of emailGroups.entries()) {
@@ -1069,7 +981,7 @@ export const detectRapidFirePatterns = zq({
                 if (!actorGroups.has(op.actorId)) {
                     actorGroups.set(op.actorId, []);
                 }
-                actorGroups.get(op.actorId).push(op);
+                actorGroups.get(op.actorId)?.push(op);
             }
         }
         for (const [actorId, ops] of actorGroups.entries()) {
@@ -1104,13 +1016,15 @@ export const checkRecipientRateLimit = zq({
         timeWindowMs: z.number(),
         maxEmails: z.number(),
     }),
-    returns: z.object({
+    returns: z
+        .object({
         allowed: z.boolean(),
         count: z.number(),
         limit: z.number(),
         timeWindowMs: z.number(),
         retryAfter: z.number().optional(),
-    }),
+    })
+        .catchall(z.any()),
     handler: async (ctx, args) => {
         const cutoffTime = Date.now() - args.timeWindowMs;
         const operations = await ctx.db

package/dist/component/schema.d.ts

@@ -1,3 +1,68 @@
-declare const _default: any;
+declare const _default: import("convex/server").SchemaDefinition<{
+    contacts: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        loopsContactId?: string | undefined;
+        email: string;
+        createdAt: number;
+        updatedAt: number;
+    }, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        email: import("zod").ZodString;
+        firstName: import("zod").ZodOptional<import("zod").ZodString>;
+        lastName: import("zod").ZodOptional<import("zod").ZodString>;
+        userId: import("zod").ZodOptional<import("zod").ZodString>;
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+        subscribed: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        userGroup: import("zod").ZodOptional<import("zod").ZodString>;
+        loopsContactId: import("zod").ZodOptional<import("zod").ZodString>;
+        createdAt: import("zod").ZodNumber;
+        updatedAt: import("zod").ZodNumber;
+    }>, "required", "email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt">, {
+        email: ["email", "_creationTime"];
+        userId: ["userId", "_creationTime"];
+        userGroup: ["userGroup", "_creationTime"];
+        source: ["source", "_creationTime"];
+        subscribed: ["subscribed", "_creationTime"];
+    }, {}, {}>;
+    emailOperations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        actorId?: string | undefined;
+        transactionalId?: string | undefined;
+        campaignId?: string | undefined;
+        loopId?: string | undefined;
+        eventName?: string | undefined;
+        messageId?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        email: string;
+        success: boolean;
+        operationType: "transactional" | "event" | "campaign" | "loop";
+        timestamp: number;
+    }, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        operationType: import("zod").ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: import("zod").ZodString;
+        actorId: import("zod").ZodOptional<import("zod").ZodString>;
+        transactionalId: import("zod").ZodOptional<import("zod").ZodString>;
+        campaignId: import("zod").ZodOptional<import("zod").ZodString>;
+        loopId: import("zod").ZodOptional<import("zod").ZodString>;
+        eventName: import("zod").ZodOptional<import("zod").ZodString>;
+        timestamp: import("zod").ZodNumber;
+        success: import("zod").ZodBoolean;
+        messageId: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    }>, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | `metadata.${string}`>, {
+        email: ["email", "timestamp", "_creationTime"];
+        actorId: ["actorId", "timestamp", "_creationTime"];
+        operationType: ["operationType", "timestamp", "_creationTime"];
+        timestamp: ["timestamp", "_creationTime"];
+    }, {}, {}>;
+}, true>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/dist/component/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";AAIA,wBAYG"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wBAYG"}

package/dist/component/tables/contacts.d.ts

@@ -1,2 +1,124 @@
-export declare const Contacts: any;
+import { z } from "zod";
+export declare const Contacts: {
+    name: "contacts";
+    table: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        loopsContactId?: string | undefined;
+        email: string;
+        createdAt: number;
+        updatedAt: number;
+    }, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        email: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        subscribed: z.ZodDefault<z.ZodBoolean>;
+        userGroup: z.ZodOptional<z.ZodString>;
+        loopsContactId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }>, "required", "email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt">, {}, {}, {}>;
+    doc: import("convex/values").VObject<{
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        loopsContactId?: string | undefined;
+        email: string;
+        createdAt: number;
+        updatedAt: number;
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"contacts">;
+    }, {
+        email: import("convex/values").VString<string, "required">;
+        firstName: import("convex/values").VString<string | undefined, "optional">;
+        lastName: import("convex/values").VString<string | undefined, "optional">;
+        userId: import("convex/values").VString<string | undefined, "optional">;
+        source: import("convex/values").VString<string | undefined, "optional">;
+        subscribed: import("convex/values").VBoolean<boolean, "optional">;
+        userGroup: import("convex/values").VString<string | undefined, "optional">;
+        loopsContactId: import("convex/values").VString<string | undefined, "optional">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+        _id: import("convex/values").VId<import("convex/values").GenericId<"contacts">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    }, "required", "email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt" | "_creationTime" | "_id">;
+    withoutSystemFields: import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        email: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        subscribed: z.ZodDefault<z.ZodBoolean>;
+        userGroup: z.ZodOptional<z.ZodString>;
+        loopsContactId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }>;
+    withSystemFields: {
+        email: import("convex/values").VString<string, "required">;
+        firstName: import("convex/values").VString<string | undefined, "optional">;
+        lastName: import("convex/values").VString<string | undefined, "optional">;
+        userId: import("convex/values").VString<string | undefined, "optional">;
+        source: import("convex/values").VString<string | undefined, "optional">;
+        subscribed: import("convex/values").VBoolean<boolean, "optional">;
+        userGroup: import("convex/values").VString<string | undefined, "optional">;
+        loopsContactId: import("convex/values").VString<string | undefined, "optional">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+        _id: import("convex/values").VId<import("convex/values").GenericId<"contacts">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    };
+    systemFields: {
+        _id: import("convex/values").VId<import("convex/values").GenericId<"contacts">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    };
+    _id: import("convex/values").VId<import("convex/values").GenericId<"contacts">, "required">;
+} & {
+    shape: {
+        email: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        subscribed: z.ZodDefault<z.ZodBoolean>;
+        userGroup: z.ZodOptional<z.ZodString>;
+        loopsContactId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    };
+    zDoc: z.ZodObject<{
+        email: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        subscribed: z.ZodDefault<z.ZodBoolean>;
+        userGroup: z.ZodOptional<z.ZodString>;
+        loopsContactId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    } & {
+        _id: z.ZodType<import("convex/values").GenericId<"contacts">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"contacts">, unknown>> & {
+            _tableName: "contacts";
+        };
+        _creationTime: z.ZodNumber;
+    }, z.core.$strip>;
+    docArray: z.ZodArray<z.ZodObject<Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }> & {
+        _id: z.ZodType<import("convex/values").GenericId<"contacts">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"contacts">, unknown>> & {
+            _tableName: "contacts";
+        };
+        _creationTime: z.ZodNumber;
+    }, z.core.$strip>>;
+};
 //# sourceMappingURL=contacts.d.ts.map

package/dist/component/tables/contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../src/component/tables/contacts.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,KAWnB,CAAC"}
+{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../src/component/tables/contacts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWnB,CAAC"}