@devwithbobby/loops 0.1.12 → 0.1.14

package/dist/component/convex.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex.config.d.ts","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS,KAA2B,CAAC;AAuB3C,eAAe,SAAS,CAAC"}
+{"version":3,"file":"convex.config.d.ts","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS,kDAA2B,CAAC;AA4B3C,eAAe,SAAS,CAAC"}

package/dist/component/convex.config.js

@@ -1,5 +1,5 @@
 import { defineComponent } from "convex/server";
-import { api } from "./_generated/api.js";
+import { api } from "./_generated/api";
 const component = defineComponent("loops");
 component.export(api, {
     addContact: api.lib.addContact,

package/dist/component/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare const LOOPS_API_BASE_URL = "https://app.loops.so/api/v1";
+export declare const sanitizeLoopsError: (status: number, _errorText: string) => Error;
+export type LoopsRequestInit = Omit<RequestInit, "body"> & {
+    json?: unknown;
+};
+export declare const loopsFetch: (apiKey: string, path: string, init?: LoopsRequestInit) => Promise<Response>;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/component/helpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,gCAAgC,CAAC;AAEhE,eAAO,MAAM,kBAAkB,GAC9B,QAAQ,MAAM,EACd,YAAY,MAAM,KAChB,KAcF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAC1D,IAAI,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,UAAU,GACtB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,OAAM,gBAAqB,sBAe3B,CAAC"}

package/dist/component/helpers.js

@@ -0,0 +1,30 @@
+export const LOOPS_API_BASE_URL = "https://app.loops.so/api/v1";
+export const sanitizeLoopsError = (status, _errorText) => {
+    if (status === 401 || status === 403) {
+        return new Error("Authentication failed. Please check your API key.");
+    }
+    if (status === 404) {
+        return new Error("Resource not found.");
+    }
+    if (status === 429) {
+        return new Error("Rate limit exceeded. Please try again later.");
+    }
+    if (status >= 500) {
+        return new Error("Loops service error. Please try again later.");
+    }
+    return new Error(`Loops API error (${status}). Please try again.`);
+};
+export const loopsFetch = async (apiKey, path, init = {}) => {
+    const { json, ...rest } = init;
+    const headers = new Headers(rest.headers ?? {});
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    if (json !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    return fetch(`${LOOPS_API_BASE_URL}${path}`, {
+        ...rest,
+        headers,
+        // @ts-expect-error RequestInit in this build doesn't declare body
+        body: json !== undefined ? JSON.stringify(json) : rest.body,
+    });
+};

package/dist/component/http.d.ts

@@ -0,0 +1,3 @@
+declare const http: import("convex/server").HttpRouter;
+export default http;
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/component/http.ts"],"names":[],"mappings":"AAaA,QAAA,MAAM,IAAI,oCAAe,CAAC;AAkS1B,eAAe,IAAI,CAAC"}

package/dist/component/http.js

@@ -0,0 +1,268 @@
+import { httpRouter } from "convex/server";
+import { internalLib, } from "../types";
+import { httpAction } from "./_generated/server";
+const http = httpRouter();
+const allowedOrigin = process.env.LOOPS_HTTP_ALLOWED_ORIGIN ?? process.env.CLIENT_ORIGIN ?? "*";
+const buildCorsHeaders = (extra) => {
+    const headers = new Headers(extra ?? {});
+    headers.set("Access-Control-Allow-Origin", allowedOrigin);
+    headers.set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
+    headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    headers.set("Access-Control-Max-Age", "86400");
+    headers.set("Vary", "Origin");
+    return headers;
+};
+const jsonResponse = (data, init) => {
+    const headers = buildCorsHeaders(init?.headers ?? undefined);
+    headers.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), { ...init, headers });
+};
+const emptyResponse = (init) => {
+    const headers = buildCorsHeaders(init?.headers ?? undefined);
+    return new Response(null, { ...init, headers });
+};
+const readJsonBody = async (request) => {
+    try {
+        return (await request.json());
+    }
+    catch (_error) {
+        throw new Error("Invalid JSON body");
+    }
+};
+const booleanFromQuery = (value) => {
+    if (value === null) {
+        return undefined;
+    }
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    return undefined;
+};
+const numberFromQuery = (value, fallback) => {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? fallback : parsed;
+};
+const requireLoopsApiKey = () => {
+    const apiKey = process.env.LOOPS_API_KEY;
+    if (!apiKey) {
+        throw new Error("LOOPS_API_KEY environment variable must be set to use the HTTP API.");
+    }
+    return apiKey;
+};
+const respondError = (error) => {
+    console.error("[loops:http]", error);
+    const message = error instanceof Error ? error.message : "Unexpected error";
+    const status = error instanceof Error &&
+        error.message.includes("LOOPS_API_KEY environment variable")
+        ? 500
+        : 400;
+    return jsonResponse({ error: message }, { status });
+};
+http.route({
+    pathPrefix: "/loops",
+    method: "OPTIONS",
+    handler: httpAction(async (_ctx, request) => {
+        const headers = buildCorsHeaders();
+        const requestedHeaders = request.headers.get("Access-Control-Request-Headers");
+        if (requestedHeaders) {
+            headers.set("Access-Control-Allow-Headers", requestedHeaders);
+        }
+        const requestedMethod = request.headers.get("Access-Control-Request-Method");
+        if (requestedMethod) {
+            headers.set("Access-Control-Allow-Methods", `${requestedMethod},OPTIONS`);
+        }
+        return new Response(null, { status: 204, headers });
+    }),
+});
+http.route({
+    path: "/loops/contacts",
+    method: "POST",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const contact = await readJsonBody(request);
+            const data = await ctx.runAction(internalLib.addContact, {
+                apiKey: requireLoopsApiKey(),
+                contact,
+            });
+            return jsonResponse(data, { status: 201 });
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/contacts",
+    method: "PUT",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const payload = await readJsonBody(request);
+            if (!payload.email) {
+                throw new Error("email is required");
+            }
+            const data = await ctx.runAction(internalLib.updateContact, {
+                apiKey: requireLoopsApiKey(),
+                email: payload.email,
+                dataVariables: payload.dataVariables,
+                firstName: payload.firstName,
+                lastName: payload.lastName,
+                userId: payload.userId,
+                source: payload.source,
+                subscribed: payload.subscribed,
+                userGroup: payload.userGroup,
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/contacts",
+    method: "GET",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const url = new URL(request.url);
+            const email = url.searchParams.get("email");
+            if (email) {
+                const data = await ctx.runAction(internalLib.findContact, {
+                    apiKey: requireLoopsApiKey(),
+                    email,
+                });
+                return jsonResponse(data);
+            }
+            const data = await ctx.runQuery(internalLib.listContacts, {
+                userGroup: url.searchParams.get("userGroup") ?? undefined,
+                source: url.searchParams.get("source") ?? undefined,
+                subscribed: booleanFromQuery(url.searchParams.get("subscribed")),
+                limit: numberFromQuery(url.searchParams.get("limit"), 100),
+                offset: numberFromQuery(url.searchParams.get("offset"), 0),
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/contacts",
+    method: "DELETE",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const payload = await readJsonBody(request);
+            if (!payload.email) {
+                throw new Error("email is required");
+            }
+            await ctx.runAction(internalLib.deleteContact, {
+                apiKey: requireLoopsApiKey(),
+                email: payload.email,
+            });
+            return emptyResponse({ status: 204 });
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/transactional",
+    method: "POST",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const payload = await readJsonBody(request);
+            if (!payload.transactionalId) {
+                throw new Error("transactionalId is required");
+            }
+            if (!payload.email) {
+                throw new Error("email is required");
+            }
+            const data = await ctx.runAction(internalLib.sendTransactional, {
+                apiKey: requireLoopsApiKey(),
+                transactionalId: payload.transactionalId,
+                email: payload.email,
+                dataVariables: payload.dataVariables,
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/events",
+    method: "POST",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const payload = await readJsonBody(request);
+            if (!payload.email) {
+                throw new Error("email is required");
+            }
+            if (!payload.eventName) {
+                throw new Error("eventName is required");
+            }
+            const data = await ctx.runAction(internalLib.sendEvent, {
+                apiKey: requireLoopsApiKey(),
+                email: payload.email,
+                eventName: payload.eventName,
+                eventProperties: payload.eventProperties,
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/trigger",
+    method: "POST",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const payload = await readJsonBody(request);
+            if (!payload.loopId) {
+                throw new Error("loopId is required");
+            }
+            if (!payload.email) {
+                throw new Error("email is required");
+            }
+            const data = await ctx.runAction(internalLib.triggerLoop, {
+                apiKey: requireLoopsApiKey(),
+                loopId: payload.loopId,
+                email: payload.email,
+                dataVariables: payload.dataVariables,
+                eventName: payload.eventName,
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+http.route({
+    path: "/loops/stats",
+    method: "GET",
+    handler: httpAction(async (ctx, request) => {
+        try {
+            const url = new URL(request.url);
+            const timeWindowMs = numberFromQuery(url.searchParams.get("timeWindowMs"), 86400000);
+            const data = await ctx.runQuery(internalLib.getEmailStats, {
+                timeWindowMs,
+            });
+            return jsonResponse(data);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    }),
+});
+export default http;

package/dist/component/lib.d.ts

@@ -1,48 +1,144 @@
 /**
  * Internal mutation to store/update a contact in the database
  */
-export declare const storeContact: any;
+export declare const storeContact: import("convex/server").RegisteredMutation<"public", {
+    email: string;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    userId?: string | undefined;
+    source?: string | undefined;
+    subscribed?: boolean | undefined;
+    userGroup?: string | undefined;
+    loopsContactId?: string | undefined;
+}, Promise<void>>;
 /**
  * Internal mutation to delete a contact from the database
  */
-export declare const removeContact: any;
+export declare const removeContact: import("convex/server").RegisteredMutation<"public", {
+    email: string;
+}, Promise<void>>;
 /**
  * Internal mutation to log an email operation for monitoring
  */
-export declare const logEmailOperation: any;
+export declare const logEmailOperation: import("convex/server").RegisteredMutation<"public", {
+    operationType: "transactional" | "event" | "campaign" | "loop";
+    email: string;
+    success: boolean;
+    actorId?: string | undefined;
+    transactionalId?: string | undefined;
+    campaignId?: string | undefined;
+    loopId?: string | undefined;
+    eventName?: string | undefined;
+    messageId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, Promise<void>>;
 /**
  * Count contacts in the database
  * Can filter by audience criteria (userGroup, source, subscribed status)
  */
-export declare const countContacts: any;
+export declare const countContacts: import("convex/server").RegisteredQuery<"public", {
+    userGroup?: string | undefined;
+    source?: string | undefined;
+    subscribed?: boolean | undefined;
+}, Promise<number>>;
 /**
  * List contacts from the database with pagination
  * Can filter by audience criteria (userGroup, source, subscribed status)
  * Returns actual contact data, not just a count
  */
-export declare const listContacts: any;
+export declare const listContacts: import("convex/server").RegisteredQuery<"public", {
+    limit: number;
+    offset: number;
+    userGroup?: string | undefined;
+    source?: string | undefined;
+    subscribed?: boolean | undefined;
+}, Promise<{
+    contacts: {
+        _id: string;
+        email: string;
+        subscribed: boolean;
+        createdAt: number;
+        updatedAt: number;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        userGroup?: string | undefined;
+        loopsContactId?: string | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}>>;
 /**
  * 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: any;
+export declare const addContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    contact: {
+        email: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+    };
+}, Promise<{
+    success: boolean;
+    id?: string | undefined;
+}>>;
 /**
  * Update an existing contact in Loops
  */
-export declare const updateContact: any;
+export declare const updateContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+    dataVariables?: Record<string, any> | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    userId?: string | undefined;
+    source?: string | undefined;
+    subscribed?: boolean | undefined;
+    userGroup?: string | undefined;
+}, Promise<{
+    success: boolean;
+}>>;
 /**
  * Send a transactional email using a transactional ID
  */
-export declare const sendTransactional: any;
+export declare const sendTransactional: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    transactionalId: string;
+    email: string;
+    dataVariables?: Record<string, any> | undefined;
+}, Promise<{
+    success: boolean;
+    messageId?: string | undefined;
+}>>;
 /**
  * Send an event to Loops to trigger email workflows
  */
-export declare const sendEvent: any;
+export declare const sendEvent: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+    eventName: string;
+    eventProperties?: Record<string, any> | undefined;
+}, Promise<{
+    success: boolean;
+}>>;
 /**
  * Delete a contact from Loops
  */
-export declare const deleteContact: any;
+export declare const deleteContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+}, Promise<{
+    success: boolean;
+}>>;
 /**
  * Trigger a loop for a contact
  * Note: Loops in Loops.so are triggered through events, not a direct API endpoint.
@@ -59,61 +155,180 @@ export declare const deleteContact: any;
  *
  * This function is kept for backwards compatibility but works by sending an event.
  */
-export declare const triggerLoop: any;
+export declare const triggerLoop: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    loopId: string;
+    email: string;
+    dataVariables?: Record<string, any> | undefined;
+    eventName?: string | undefined;
+}, Promise<{
+    success: boolean;
+    warning?: string | undefined;
+}>>;
 /**
  * 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: any;
+export declare const findContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+}, Promise<{
+    success: boolean;
+    contact?: {
+        id?: string | null | undefined;
+        email?: string | null | undefined;
+        firstName?: string | null | undefined;
+        lastName?: string | null | undefined;
+        source?: string | null | undefined;
+        subscribed?: boolean | null | undefined;
+        userGroup?: string | null | undefined;
+        userId?: string | null | undefined;
+        createdAt?: string | null | undefined;
+    } | 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: any;
+export declare const batchCreateContacts: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    contacts: {
+        email: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+    }[];
+}, Promise<{
+    success: boolean;
+    created?: number | undefined;
+    failed?: number | undefined;
+    results?: {
+        email: string;
+        success: boolean;
+        error?: string | undefined;
+    }[] | undefined;
+}>>;
 /**
  * Unsubscribe a contact
  * Unsubscribes a contact from receiving emails (they remain in the system)
  */
-export declare const unsubscribeContact: any;
+export declare const unsubscribeContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+}, Promise<{
+    success: boolean;
+}>>;
 /**
  * Resubscribe a contact
  * Resubscribes a previously unsubscribed contact
  */
-export declare const resubscribeContact: any;
+export declare const resubscribeContact: import("convex/server").RegisteredAction<"public", {
+    apiKey: string;
+    email: string;
+}, Promise<{
+    success: boolean;
+}>>;
 /**
  * Check for spam patterns: too many emails to the same recipient in a time window
  * Returns email addresses that received too many emails
  */
-export declare const detectRecipientSpam: any;
+export declare const detectRecipientSpam: import("convex/server").RegisteredQuery<"public", {
+    timeWindowMs: number;
+    maxEmailsPerRecipient: number;
+}, Promise<{
+    [x: string]: any;
+    email: string;
+    count: number;
+    timeWindowMs: number;
+}[]>>;
 /**
  * Check for spam patterns: too many emails from the same actor/user
  * Returns actor IDs that sent too many emails
  */
-export declare const detectActorSpam: any;
+export declare const detectActorSpam: import("convex/server").RegisteredQuery<"public", {
+    timeWindowMs: number;
+    maxEmailsPerActor: number;
+}, Promise<{
+    actorId: string;
+    count: number;
+    timeWindowMs: number;
+}[]>>;
 /**
  * Get recent email operation statistics for monitoring
  */
-export declare const getEmailStats: any;
+export declare const getEmailStats: import("convex/server").RegisteredQuery<"public", {
+    timeWindowMs: number;
+}, Promise<{
+    [x: string]: any;
+    totalOperations: number;
+    successfulOperations: number;
+    failedOperations: number;
+    operationsByType: Record<string, number>;
+    uniqueRecipients: number;
+    uniqueActors: number;
+}>>;
 /**
  * Detect rapid-fire email sending patterns (multiple emails sent in quick succession)
  * Returns suspicious patterns indicating potential spam
  */
-export declare const detectRapidFirePatterns: any;
+export declare const detectRapidFirePatterns: import("convex/server").RegisteredQuery<"public", {
+    timeWindowMs: number;
+    minEmailsInWindow: number;
+}, Promise<{
+    count: number;
+    timeWindowMs: number;
+    firstTimestamp: number;
+    lastTimestamp: number;
+    email?: string | undefined;
+    actorId?: string | undefined;
+}[]>>;
 /**
  * Rate limiting: Check if an email can be sent to a recipient
  * Based on recent email operations in the database
  */
-export declare const checkRecipientRateLimit: any;
+export declare const checkRecipientRateLimit: import("convex/server").RegisteredQuery<"public", {
+    email: string;
+    timeWindowMs: number;
+    maxEmails: number;
+}, Promise<{
+    [x: string]: any;
+    allowed: boolean;
+    count: number;
+    limit: number;
+    timeWindowMs: number;
+    retryAfter?: number | undefined;
+}>>;
 /**
  * Rate limiting: Check if an actor/user can send more emails
  * Based on recent email operations in the database
  */
-export declare const checkActorRateLimit: any;
+export declare const checkActorRateLimit: import("convex/server").RegisteredQuery<"public", {
+    actorId: string;
+    timeWindowMs: number;
+    maxEmails: number;
+}, Promise<{
+    allowed: boolean;
+    count: number;
+    limit: number;
+    timeWindowMs: number;
+    retryAfter?: number | undefined;
+}>>;
 /**
  * Rate limiting: Check global email sending rate
  * Checks total email operations across all senders
  */
-export declare const checkGlobalRateLimit: any;
+export declare const checkGlobalRateLimit: import("convex/server").RegisteredQuery<"public", {
+    timeWindowMs: number;
+    maxEmails: number;
+}, Promise<{
+    allowed: boolean;
+    count: number;
+    limit: number;
+    timeWindowMs: number;
+}>>;
 //# sourceMappingURL=lib.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/component/lib.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,eAAO,MAAM,YAAY,KA6CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,KAexB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,KAgC5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa,KAwCxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,KA8EvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,KAiHrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,KAoDxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,KAqD5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,KAgCpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,KA8BxB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,KAyDtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,KA2DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,KAyD9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,KA+B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,KA+B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,KAwC9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,KAwC1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,KAgDxB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,KAsGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,KA6ClC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,KA6C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB,KA8B/B,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/component/lib.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;iBA6CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;iBAexB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAkC5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;mBAwCxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAmFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;GA+GrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;GAgDxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;GAiD5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;GA4BpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;GA0BxB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;GA8D9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;KA8C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;KA4C1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;GAkDxB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;KAsGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;GA+ClC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;GA6C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;GA8B/B,CAAC"}