@niama/loops 0.2.0

package/dist/component/actions.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Add or update a contact in Loops
+ * This function tries to create a contact, and if the email already exists (409),
+ * it falls back to updating the contact instead.
+ */
+export declare const addContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    contact: {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        email: string;
+    };
+}, Promise<{
+    success: boolean;
+    id: string | undefined;
+}>>;
+/**
+ * Update an existing contact in Loops
+ */
+export declare const updateContact: import("convex/server").RegisteredAction<"public", {
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    userId?: string | undefined;
+    source?: string | undefined;
+    subscribed?: boolean | undefined;
+    userGroup?: string | undefined;
+    dataVariables?: Record<string, any> | undefined;
+    email: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Send a transactional email using a transactional ID
+ */
+export declare const sendTransactional: import("convex/server").RegisteredAction<"public", {
+    dataVariables?: Record<string, any> | undefined;
+    idempotencyKey?: string | undefined;
+    email: string;
+    transactionalId: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+    messageId?: undefined;
+} | {
+    success: boolean;
+    messageId: string;
+}>>;
+/**
+ * Send an event to Loops to trigger email workflows
+ */
+export declare const sendEvent: import("convex/server").RegisteredAction<"public", {
+    eventProperties?: Record<string, any> | undefined;
+    email: string;
+    eventName: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Delete a contact from Loops
+ */
+export declare const deleteContact: import("convex/server").RegisteredAction<"public", {
+    email: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Trigger a loop for a contact
+ * Note: Loops in Loops.so are triggered through events, not a direct API endpoint.
+ * This function uses the events endpoint to trigger the loop.
+ * The loop must be configured in the Loops dashboard to listen for events.
+ *
+ * IMPORTANT: Loops.so doesn't have a direct /loops/trigger endpoint.
+ * Loops are triggered by sending events. Make sure your loop in the dashboard
+ * is configured to trigger on an event name (e.g., "loop_trigger").
+ *
+ * If you need to trigger a specific loop, you should:
+ * 1. Configure the loop in the dashboard to listen for a specific event name
+ * 2. Use sendEvent() with that event name instead
+ *
+ * This function is kept for backwards compatibility but works by sending an event.
+ */
+export declare const triggerLoop: import("convex/server").RegisteredAction<"public", {
+    eventName?: string | undefined;
+    dataVariables?: Record<string, any> | undefined;
+    email: string;
+    loopId: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+    warning: string;
+}>>;
+/**
+ * Find a contact by email
+ * Retrieves contact information from Loops
+ * Note: Loops API may return either an object or an array
+ */
+export declare const findContact: import("convex/server").RegisteredAction<"public", {
+    email: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+    contact: Record<string, unknown> | undefined;
+}>>;
+/**
+ * Batch create contacts
+ * Creates multiple contacts sequentially using the single contact create endpoint.
+ * Note: Loops.so doesn't have a batch endpoint, so we create contacts one by one.
+ */
+export declare const batchCreateContacts: import("convex/server").RegisteredAction<"public", {
+    contacts: {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        email: string;
+    }[];
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+    created: number;
+    failed: number;
+    results: {
+        email: string;
+        success: boolean;
+        error?: string;
+    }[];
+}>>;
+/**
+ * Unsubscribe a contact
+ * Unsubscribes a contact from receiving emails (they remain in the system)
+ * Uses the update endpoint with subscribed: false as per Loops API
+ */
+export declare const unsubscribeContact: import("convex/server").RegisteredAction<"public", {
+    email: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Resubscribe a contact
+ * Resubscribes a previously unsubscribed contact
+ * Uses the update endpoint with subscribed: true as per Loops API
+ */
+export declare const resubscribeContact: import("convex/server").RegisteredAction<"public", {
+    email: string;
+    apiKey: string;
+}, Promise<{
+    success: boolean;
+}>>;
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/component/actions.ts"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;GA4GrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;GA8CxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;GAoD5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;GAuCpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;GAwBxB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;;;;;;;GAyDtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;aA0CD,0BAAqB,SAAS;GAGnD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;eASA,MAAM;iBAAW,OAAO;gBAAU,MAAM;;GAwCtE,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;GAyB7B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;GAyB7B,CAAC"}

package/dist/component/actions.js

@@ -0,0 +1,468 @@
+import { v } from "convex/values";
+import { api, internal } from "./_generated/api";
+import { action } from "./_generated/server";
+import { loopsFetch, sanitizeLoopsError } from "./helpers";
+import { batchCreateResponseValidator, contactValidator, findContactResponseValidator, successResponseValidator, successWithIdResponseValidator, successWithMessageIdResponseValidator, successWithWarningResponseValidator, } from "./validators";
+/**
+ * Add or update a contact in Loops
+ * This function tries to create a contact, and if the email already exists (409),
+ * it falls back to updating the contact instead.
+ */
+export const addContact = action({
+    args: {
+        apiKey: v.string(),
+        contact: contactValidator,
+    },
+    returns: successWithIdResponseValidator,
+    handler: async (ctx, args) => {
+        const createResponse = await loopsFetch(args.apiKey, "/contacts/create", {
+            method: "POST",
+            json: args.contact,
+        });
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            if (createResponse.status === 409) {
+                console.log(`Contact ${args.contact.email} already exists, updating instead`);
+                const findResponse = await loopsFetch(args.apiKey, `/contacts/find?email=${encodeURIComponent(args.contact.email)}`, { method: "GET" });
+                if (!findResponse.ok) {
+                    const findErrorText = await findResponse.text();
+                    console.error(`Failed to find existing contact [${findResponse.status}]:`, findErrorText);
+                }
+                const updateResponse = await loopsFetch(args.apiKey, "/contacts/update", {
+                    method: "PUT",
+                    json: {
+                        email: args.contact.email,
+                        firstName: args.contact.firstName,
+                        lastName: args.contact.lastName,
+                        userId: args.contact.userId,
+                        source: args.contact.source,
+                        subscribed: args.contact.subscribed,
+                        userGroup: args.contact.userGroup,
+                    },
+                });
+                if (!updateResponse.ok) {
+                    const updateErrorText = await updateResponse.text();
+                    console.error(`Loops API error [${updateResponse.status}]:`, updateErrorText);
+                    throw sanitizeLoopsError(updateResponse.status, updateErrorText);
+                }
+                // Get contact ID if available
+                let contactId;
+                if (findResponse.ok) {
+                    const findData = (await findResponse.json());
+                    contactId = findData.id;
+                }
+                // Store/update in our database
+                await ctx.runMutation(internal.mutations.storeContact, {
+                    email: args.contact.email,
+                    firstName: args.contact.firstName,
+                    lastName: args.contact.lastName,
+                    userId: args.contact.userId,
+                    source: args.contact.source,
+                    subscribed: args.contact.subscribed,
+                    userGroup: args.contact.userGroup,
+                    loopsContactId: contactId,
+                });
+                return {
+                    success: true,
+                    id: contactId,
+                };
+            }
+            console.error(`Loops API error [${createResponse.status}]:`, errorText);
+            throw sanitizeLoopsError(createResponse.status, errorText);
+        }
+        // Contact was created successfully
+        const data = (await createResponse.json());
+        await ctx.runMutation(internal.mutations.storeContact, {
+            email: args.contact.email,
+            firstName: args.contact.firstName,
+            lastName: args.contact.lastName,
+            userId: args.contact.userId,
+            source: args.contact.source,
+            subscribed: args.contact.subscribed,
+            userGroup: args.contact.userGroup,
+            loopsContactId: data.id,
+        });
+        return {
+            success: true,
+            id: data.id,
+        };
+    },
+});
+/**
+ * Update an existing contact in Loops
+ */
+export const updateContact = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+        dataVariables: v.optional(v.record(v.string(), v.any())),
+        firstName: v.optional(v.string()),
+        lastName: v.optional(v.string()),
+        userId: v.optional(v.string()),
+        source: v.optional(v.string()),
+        subscribed: v.optional(v.boolean()),
+        userGroup: v.optional(v.string()),
+    },
+    returns: successResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/contacts/update", {
+            method: "PUT",
+            json: {
+                email: args.email,
+                dataVariables: args.dataVariables,
+                firstName: args.firstName,
+                lastName: args.lastName,
+                userId: args.userId,
+                source: args.source,
+                subscribed: args.subscribed,
+                userGroup: args.userGroup,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        await ctx.runMutation(internal.mutations.storeContact, {
+            email: args.email,
+            firstName: args.firstName,
+            lastName: args.lastName,
+            userId: args.userId,
+            source: args.source,
+            subscribed: args.subscribed,
+            userGroup: args.userGroup,
+        });
+        return { success: true };
+    },
+});
+/**
+ * Send a transactional email using a transactional ID
+ */
+export const sendTransactional = action({
+    args: {
+        apiKey: v.string(),
+        transactionalId: v.string(),
+        email: v.string(),
+        dataVariables: v.optional(v.record(v.string(), v.any())),
+        idempotencyKey: v.optional(v.string()),
+    },
+    returns: successWithMessageIdResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/transactional", {
+            headers: args.idempotencyKey === undefined
+                ? undefined
+                : {
+                    "Idempotency-Key": args.idempotencyKey,
+                },
+            method: "POST",
+            json: {
+                transactionalId: args.transactionalId,
+                email: args.email,
+                dataVariables: args.dataVariables,
+            },
+        });
+        if (!(response.ok || response.status === 409)) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            await ctx.runMutation(internal.mutations.logEmailOperation, {
+                operationType: "transactional",
+                email: args.email,
+                success: false,
+                transactionalId: args.transactionalId,
+            });
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        const data = (await response.json());
+        await ctx.runMutation(internal.mutations.logEmailOperation, {
+            operationType: "transactional",
+            email: args.email,
+            success: true,
+            transactionalId: args.transactionalId,
+            messageId: data.messageId,
+        });
+        return data.messageId === undefined
+            ? { success: true }
+            : { success: true, messageId: data.messageId };
+    },
+});
+/**
+ * Send an event to Loops to trigger email workflows
+ */
+export const sendEvent = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+        eventName: v.string(),
+        eventProperties: v.optional(v.record(v.string(), v.any())),
+    },
+    returns: successResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/events/send", {
+            method: "POST",
+            json: {
+                email: args.email,
+                eventName: args.eventName,
+                eventProperties: args.eventProperties,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            await ctx.runMutation(internal.mutations.logEmailOperation, {
+                operationType: "event",
+                email: args.email,
+                success: false,
+                eventName: args.eventName,
+            });
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        await ctx.runMutation(internal.mutations.logEmailOperation, {
+            operationType: "event",
+            email: args.email,
+            success: true,
+            eventName: args.eventName,
+        });
+        return { success: true };
+    },
+});
+/**
+ * Delete a contact from Loops
+ */
+export const deleteContact = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+    },
+    returns: successResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/contacts/delete", {
+            method: "POST",
+            json: { email: args.email },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        await ctx.runMutation(internal.mutations.removeContact, {
+            email: args.email,
+        });
+        return { success: true };
+    },
+});
+/**
+ * Trigger a loop for a contact
+ * Note: Loops in Loops.so are triggered through events, not a direct API endpoint.
+ * This function uses the events endpoint to trigger the loop.
+ * The loop must be configured in the Loops dashboard to listen for events.
+ *
+ * IMPORTANT: Loops.so doesn't have a direct /loops/trigger endpoint.
+ * Loops are triggered by sending events. Make sure your loop in the dashboard
+ * is configured to trigger on an event name (e.g., "loop_trigger").
+ *
+ * If you need to trigger a specific loop, you should:
+ * 1. Configure the loop in the dashboard to listen for a specific event name
+ * 2. Use sendEvent() with that event name instead
+ *
+ * This function is kept for backwards compatibility but works by sending an event.
+ */
+export const triggerLoop = action({
+    args: {
+        apiKey: v.string(),
+        loopId: v.string(),
+        email: v.string(),
+        dataVariables: v.optional(v.record(v.string(), v.any())),
+        eventName: v.optional(v.string()),
+    },
+    returns: successWithWarningResponseValidator,
+    handler: async (ctx, args) => {
+        // Loops.so doesn't have a /loops/trigger endpoint
+        // Loops are triggered through events. We'll use the events endpoint.
+        // Default event name if not provided
+        const eventName = args.eventName || `loop_${args.loopId}`;
+        try {
+            // Send event to trigger the loop
+            await ctx.runAction(api.actions.sendEvent, {
+                apiKey: args.apiKey,
+                email: args.email,
+                eventName,
+                eventProperties: {
+                    ...args.dataVariables,
+                    loopId: args.loopId, // Include loopId in event properties
+                },
+            });
+            // Log as loop operation
+            await ctx.runMutation(internal.mutations.logEmailOperation, {
+                operationType: "loop",
+                email: args.email,
+                success: true,
+                loopId: args.loopId,
+                eventName,
+            });
+            return {
+                success: true,
+                warning: "Loops are triggered via events. Ensure your loop is configured to listen for this event.",
+            };
+        }
+        catch (error) {
+            // Log failed loop operation
+            await ctx.runMutation(internal.mutations.logEmailOperation, {
+                operationType: "loop",
+                email: args.email,
+                success: false,
+                loopId: args.loopId,
+                eventName,
+                metadata: {
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    },
+});
+/**
+ * Find a contact by email
+ * Retrieves contact information from Loops
+ * Note: Loops API may return either an object or an array
+ */
+export const findContact = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+    },
+    returns: findContactResponseValidator,
+    handler: async (_ctx, args) => {
+        const response = await loopsFetch(args.apiKey, `/contacts/find?email=${encodeURIComponent(args.email)}`, { method: "GET" });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, contact: undefined };
+            }
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        const data = (await response.json());
+        // Handle case where Loops returns an array instead of a single object
+        let contact = Array.isArray(data) ? data[0] : data;
+        // Convert null values to undefined for optional fields
+        if (contact) {
+            contact = Object.fromEntries(Object.entries(contact).map(([key, value]) => [
+                key,
+                value === null ? undefined : value,
+            ]));
+        }
+        return {
+            success: true,
+            contact: contact,
+        };
+    },
+});
+/**
+ * Batch create contacts
+ * Creates multiple contacts sequentially using the single contact create endpoint.
+ * Note: Loops.so doesn't have a batch endpoint, so we create contacts one by one.
+ */
+export const batchCreateContacts = action({
+    args: {
+        apiKey: v.string(),
+        contacts: v.array(contactValidator),
+    },
+    returns: batchCreateResponseValidator,
+    handler: async (ctx, args) => {
+        let created = 0;
+        let failed = 0;
+        const results = [];
+        // Create contacts one by one since Loops.so doesn't have a batch endpoint
+        for (const contact of args.contacts) {
+            try {
+                // Use the addContact function which handles create/update logic
+                const result = await ctx.runAction(api.actions.addContact, {
+                    apiKey: args.apiKey,
+                    contact,
+                });
+                if (result.success) {
+                    created++;
+                    results.push({ email: contact.email, success: true });
+                }
+                else {
+                    failed++;
+                    results.push({
+                        email: contact.email,
+                        success: false,
+                        error: "Unknown error",
+                    });
+                }
+            }
+            catch (error) {
+                failed++;
+                results.push({
+                    email: contact.email,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return {
+            success: created > 0,
+            created,
+            failed,
+            results,
+        };
+    },
+});
+/**
+ * Unsubscribe a contact
+ * Unsubscribes a contact from receiving emails (they remain in the system)
+ * Uses the update endpoint with subscribed: false as per Loops API
+ */
+export const unsubscribeContact = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+    },
+    returns: successResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/contacts/update", {
+            method: "PUT",
+            json: { email: args.email, subscribed: false },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        await ctx.runMutation(internal.mutations.storeContact, {
+            email: args.email,
+            subscribed: false,
+        });
+        return { success: true };
+    },
+});
+/**
+ * Resubscribe a contact
+ * Resubscribes a previously unsubscribed contact
+ * Uses the update endpoint with subscribed: true as per Loops API
+ */
+export const resubscribeContact = action({
+    args: {
+        apiKey: v.string(),
+        email: v.string(),
+    },
+    returns: successResponseValidator,
+    handler: async (ctx, args) => {
+        const response = await loopsFetch(args.apiKey, "/contacts/update", {
+            method: "PUT",
+            json: { email: args.email, subscribed: true },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Loops API error [${response.status}]:`, errorText);
+            throw sanitizeLoopsError(response.status, errorText);
+        }
+        await ctx.runMutation(internal.mutations.storeContact, {
+            email: args.email,
+            subscribed: true,
+        });
+        return { success: true };
+    },
+});

package/dist/component/aggregates.d.ts

@@ -0,0 +1,42 @@
+import { TableAggregate } from "@convex-dev/aggregate";
+import type { GenericMutationCtx, GenericQueryCtx } from "convex/server";
+import type { DataModel, Doc } from "./_generated/dataModel";
+/**
+ * Aggregate for counting contacts.
+ * Uses userGroup as namespace for efficient filtered counting.
+ * Key is null since we only need counts, not ordering.
+ */
+export declare const contactAggregate: TableAggregate<{
+    Namespace: string | undefined;
+    Key: null;
+    DataModel: DataModel;
+    TableName: "contacts";
+}>;
+type MutationCtx = GenericMutationCtx<DataModel>;
+type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * Insert a contact into the aggregate
+ */
+export declare function aggregateInsert(ctx: MutationCtx, doc: Doc<"contacts">): Promise<void>;
+/**
+ * Delete a contact from the aggregate
+ */
+export declare function aggregateDelete(ctx: MutationCtx, doc: Doc<"contacts">): Promise<void>;
+/**
+ * Replace a contact in the aggregate (when userGroup changes)
+ */
+export declare function aggregateReplace(ctx: MutationCtx, oldDoc: Doc<"contacts">, newDoc: Doc<"contacts">): Promise<void>;
+/**
+ * Count contacts by userGroup namespace
+ */
+export declare function aggregateCountByUserGroup(ctx: QueryCtx, userGroup: string | undefined): Promise<number>;
+/**
+ * Count all contacts across all userGroups
+ */
+export declare function aggregateCountTotal(ctx: QueryCtx): Promise<number>;
+/**
+ * Clear and reinitialize the aggregate (for backfill)
+ */
+export declare function aggregateClear(ctx: MutationCtx, namespace?: string): Promise<void>;
+export {};
+//# sourceMappingURL=aggregates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregates.d.ts","sourceRoot":"","sources":["../../src/component/aggregates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAO7D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;eACjB,MAAM,GAAG,SAAS;SACxB,IAAI;eACE,SAAS;eACT,UAAU;EAIpB,CAAC;AAEH,KAAK,WAAW,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACjD,KAAK,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;AAE3C;;GAEG;AACH,wBAAsB,eAAe,CACpC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,GAAG,CAAC,UAAU,CAAC,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,eAAe,CACpC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,GAAG,CAAC,UAAU,CAAC,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,EACvB,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,GACrB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAMxE;AAED;;GAEG;AACH,wBAAsB,cAAc,CACnC,GAAG,EAAE,WAAW,EAChB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAEf"}