@devwithbobby/loops 0.1.12 → 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,7 +527,7 @@ 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 };
@@ -563,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,
@@ -573,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,
@@ -587,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;
         }
@@ -625,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: {
@@ -646,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,
@@ -668,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;
@@ -682,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,
                 });
@@ -695,7 +707,7 @@ export const batchCreateContacts = za({
                     results.push({
                         email: contact.email,
                         success: false,
-                        error: "Unknown error"
+                        error: "Unknown error",
                     });
                 }
             }
@@ -742,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,
         });
@@ -775,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,
         });
@@ -791,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
@@ -867,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
@@ -937,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()) {
@@ -965,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()) {
@@ -1000,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"}

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

@@ -1,2 +1,152 @@
-export declare const EmailOperations: any;
+import { z } from "zod";
+export declare const EmailOperations: {
+    name: "emailOperations";
+    table: 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: z.ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: z.ZodString;
+        actorId: z.ZodOptional<z.ZodString>;
+        transactionalId: z.ZodOptional<z.ZodString>;
+        campaignId: z.ZodOptional<z.ZodString>;
+        loopId: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodNumber;
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }>, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | `metadata.${string}`>, {}, {}, {}>;
+    doc: 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;
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"emailOperations">;
+    }, {
+        operationType: import("convex/values").VUnion<"transactional" | "event" | "campaign" | "loop", import("convex/values").VLiteral<"transactional" | "event" | "campaign" | "loop", "required">[], "required", never>;
+        email: import("convex/values").VString<string, "required">;
+        actorId: import("convex/values").VString<string | undefined, "optional">;
+        transactionalId: import("convex/values").VString<string | undefined, "optional">;
+        campaignId: import("convex/values").VString<string | undefined, "optional">;
+        loopId: import("convex/values").VString<string | undefined, "optional">;
+        eventName: import("convex/values").VString<string | undefined, "optional">;
+        timestamp: import("convex/values").VFloat64<number, "required">;
+        success: import("convex/values").VBoolean<boolean, "required">;
+        messageId: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<"required", "required", string>, "optional", string>;
+        _id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    }, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}` | "_id">;
+    withoutSystemFields: import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        operationType: z.ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: z.ZodString;
+        actorId: z.ZodOptional<z.ZodString>;
+        transactionalId: z.ZodOptional<z.ZodString>;
+        campaignId: z.ZodOptional<z.ZodString>;
+        loopId: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodNumber;
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }>;
+    withSystemFields: {
+        operationType: import("convex/values").VUnion<"transactional" | "event" | "campaign" | "loop", import("convex/values").VLiteral<"transactional" | "event" | "campaign" | "loop", "required">[], "required", never>;
+        email: import("convex/values").VString<string, "required">;
+        actorId: import("convex/values").VString<string | undefined, "optional">;
+        transactionalId: import("convex/values").VString<string | undefined, "optional">;
+        campaignId: import("convex/values").VString<string | undefined, "optional">;
+        loopId: import("convex/values").VString<string | undefined, "optional">;
+        eventName: import("convex/values").VString<string | undefined, "optional">;
+        timestamp: import("convex/values").VFloat64<number, "required">;
+        success: import("convex/values").VBoolean<boolean, "required">;
+        messageId: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<"required", "required", string>, "optional", string>;
+        _id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    };
+    systemFields: {
+        _id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    };
+    _id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
+} & {
+    shape: {
+        operationType: z.ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: z.ZodString;
+        actorId: z.ZodOptional<z.ZodString>;
+        transactionalId: z.ZodOptional<z.ZodString>;
+        campaignId: z.ZodOptional<z.ZodString>;
+        loopId: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodNumber;
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    };
+    zDoc: z.ZodObject<{
+        operationType: z.ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: z.ZodString;
+        actorId: z.ZodOptional<z.ZodString>;
+        transactionalId: z.ZodOptional<z.ZodString>;
+        campaignId: z.ZodOptional<z.ZodString>;
+        loopId: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodNumber;
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    } & {
+        _id: z.ZodType<import("convex/values").GenericId<"emailOperations">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"emailOperations">, unknown>> & {
+            _tableName: "emailOperations";
+        };
+        _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<"emailOperations">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"emailOperations">, unknown>> & {
+            _tableName: "emailOperations";
+        };
+        _creationTime: z.ZodNumber;
+    }, z.core.$strip>>;
+};
 //# sourceMappingURL=emailOperations.d.ts.map

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

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

package/dist/component/tables/emailOperations.js

@@ -1,12 +1,7 @@
 import { z } from "zod";
 import { zodTable } from "zodvex";
 export const EmailOperations = zodTable("emailOperations", {
-    operationType: z.enum([
-        "transactional",
-        "event",
-        "campaign",
-        "loop",
-    ]),
+    operationType: z.enum(["transactional", "event", "campaign", "loop"]),
     email: z.string().email(),
     actorId: z.string().optional(),
     transactionalId: z.string().optional(),