@convex-dev/better-auth 0.6.0

package/dist/esm/component/util.d.ts

@@ -0,0 +1,394 @@
+export declare const vv: {
+    id: <TableName extends import("convex/server").TableNamesInDataModel<{
+        user: {
+            document: {
+                _id: import("convex/values").GenericId<"user">;
+                _creationTime: number;
+                image?: string | undefined;
+                twoFactorEnabled?: boolean | undefined;
+                name: string;
+                email: string;
+                emailVerified: boolean;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            fieldPaths: ("name" | "email" | "emailVerified" | "image" | "twoFactorEnabled" | "userId" | "createdAt" | "updatedAt" | "_creationTime") | "_id";
+            indexes: {
+                email: ["email", "_creationTime"];
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        session: {
+            document: {
+                _id: import("convex/values").GenericId<"session">;
+                _creationTime: number;
+                ipAddress?: string | undefined;
+                userAgent?: string | undefined;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+                expiresAt: number;
+                token: string;
+            };
+            fieldPaths: ("userId" | "createdAt" | "updatedAt" | "_creationTime" | "expiresAt" | "token" | "ipAddress" | "userAgent") | "_id";
+            indexes: {
+                token: ["token", "_creationTime"];
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        account: {
+            document: {
+                _id: import("convex/values").GenericId<"account">;
+                _creationTime: number;
+                accessToken?: string | undefined;
+                refreshToken?: string | undefined;
+                idToken?: string | undefined;
+                accessTokenExpiresAt?: number | undefined;
+                refreshTokenExpiresAt?: number | undefined;
+                scope?: string | undefined;
+                password?: string | undefined;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+                accountId: string;
+                providerId: string;
+            };
+            fieldPaths: ("userId" | "createdAt" | "updatedAt" | "_creationTime" | "accountId" | "providerId" | "accessToken" | "refreshToken" | "idToken" | "accessTokenExpiresAt" | "refreshTokenExpiresAt" | "scope" | "password") | "_id";
+            indexes: {
+                userId: ["userId", "_creationTime"];
+                accountId: ["accountId", "_creationTime"];
+                providerId_accountId: ["providerId", "accountId", "_creationTime"];
+                userId_providerId: ["userId", "providerId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        twoFactor: {
+            document: {
+                _id: import("convex/values").GenericId<"twoFactor">;
+                _creationTime: number;
+                userId: string;
+                secret: string;
+                backupCodes: string;
+            };
+            fieldPaths: ("userId" | "_creationTime" | "secret" | "backupCodes") | "_id";
+            indexes: {
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        verification: {
+            document: {
+                _id: import("convex/values").GenericId<"verification">;
+                _creationTime: number;
+                createdAt?: number | undefined;
+                updatedAt?: number | undefined;
+                expiresAt: number;
+                identifier: string;
+                value: string;
+            };
+            fieldPaths: ("createdAt" | "updatedAt" | "_creationTime" | "expiresAt" | "identifier" | "value") | "_id";
+            indexes: {
+                identifier: ["identifier", "_creationTime"];
+                expiresAt: ["expiresAt", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        jwks: {
+            document: {
+                _id: import("convex/values").GenericId<"jwks">;
+                _creationTime: number;
+                id?: string | undefined;
+                createdAt: number;
+                publicKey: string;
+                privateKey: string;
+            };
+            fieldPaths: "_id" | ("id" | "createdAt" | "_creationTime" | "publicKey" | "privateKey");
+            indexes: {
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+    }>>(tableName: TableName) => import("convex/values").VId<import("convex/values").GenericId<TableName>, "required">;
+    doc: <TableName extends import("convex/server").TableNamesInDataModel<{
+        user: {
+            document: {
+                _id: import("convex/values").GenericId<"user">;
+                _creationTime: number;
+                image?: string | undefined;
+                twoFactorEnabled?: boolean | undefined;
+                name: string;
+                email: string;
+                emailVerified: boolean;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            fieldPaths: ("name" | "email" | "emailVerified" | "image" | "twoFactorEnabled" | "userId" | "createdAt" | "updatedAt" | "_creationTime") | "_id";
+            indexes: {
+                email: ["email", "_creationTime"];
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        session: {
+            document: {
+                _id: import("convex/values").GenericId<"session">;
+                _creationTime: number;
+                ipAddress?: string | undefined;
+                userAgent?: string | undefined;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+                expiresAt: number;
+                token: string;
+            };
+            fieldPaths: ("userId" | "createdAt" | "updatedAt" | "_creationTime" | "expiresAt" | "token" | "ipAddress" | "userAgent") | "_id";
+            indexes: {
+                token: ["token", "_creationTime"];
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        account: {
+            document: {
+                _id: import("convex/values").GenericId<"account">;
+                _creationTime: number;
+                accessToken?: string | undefined;
+                refreshToken?: string | undefined;
+                idToken?: string | undefined;
+                accessTokenExpiresAt?: number | undefined;
+                refreshTokenExpiresAt?: number | undefined;
+                scope?: string | undefined;
+                password?: string | undefined;
+                userId: string;
+                createdAt: number;
+                updatedAt: number;
+                accountId: string;
+                providerId: string;
+            };
+            fieldPaths: ("userId" | "createdAt" | "updatedAt" | "_creationTime" | "accountId" | "providerId" | "accessToken" | "refreshToken" | "idToken" | "accessTokenExpiresAt" | "refreshTokenExpiresAt" | "scope" | "password") | "_id";
+            indexes: {
+                userId: ["userId", "_creationTime"];
+                accountId: ["accountId", "_creationTime"];
+                providerId_accountId: ["providerId", "accountId", "_creationTime"];
+                userId_providerId: ["userId", "providerId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        twoFactor: {
+            document: {
+                _id: import("convex/values").GenericId<"twoFactor">;
+                _creationTime: number;
+                userId: string;
+                secret: string;
+                backupCodes: string;
+            };
+            fieldPaths: ("userId" | "_creationTime" | "secret" | "backupCodes") | "_id";
+            indexes: {
+                userId: ["userId", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        verification: {
+            document: {
+                _id: import("convex/values").GenericId<"verification">;
+                _creationTime: number;
+                createdAt?: number | undefined;
+                updatedAt?: number | undefined;
+                expiresAt: number;
+                identifier: string;
+                value: string;
+            };
+            fieldPaths: ("createdAt" | "updatedAt" | "_creationTime" | "expiresAt" | "identifier" | "value") | "_id";
+            indexes: {
+                identifier: ["identifier", "_creationTime"];
+                expiresAt: ["expiresAt", "_creationTime"];
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+        jwks: {
+            document: {
+                _id: import("convex/values").GenericId<"jwks">;
+                _creationTime: number;
+                id?: string | undefined;
+                createdAt: number;
+                publicKey: string;
+                privateKey: string;
+            };
+            fieldPaths: "_id" | ("id" | "createdAt" | "_creationTime" | "publicKey" | "privateKey");
+            indexes: {
+                by_id: ["_id"];
+                by_creation_time: ["_creationTime"];
+            };
+            searchIndexes: {};
+            vectorIndexes: {};
+        };
+    }>>(tableName: TableName) => import("convex-helpers/validators").AddFieldsToValidator<{
+        user: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            image?: string | undefined;
+            twoFactorEnabled?: boolean | undefined;
+            name: string;
+            email: string;
+            emailVerified: boolean;
+            userId: string;
+            createdAt: number;
+            updatedAt: number;
+        }, {
+            name: import("convex/values").VString<string, "required">;
+            email: import("convex/values").VString<string, "required">;
+            emailVerified: import("convex/values").VBoolean<boolean, "required">;
+            image: import("convex/values").VString<string | undefined, "optional">;
+            twoFactorEnabled: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            userId: import("convex/values").VString<string, "required">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "name" | "email" | "emailVerified" | "image" | "twoFactorEnabled" | "userId" | "createdAt" | "updatedAt">, {
+            email: ["email", "_creationTime"];
+            userId: ["userId", "_creationTime"];
+        }, {}, {}>;
+        session: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            userId: string;
+            createdAt: number;
+            updatedAt: number;
+            expiresAt: number;
+            token: string;
+        }, {
+            expiresAt: import("convex/values").VFloat64<number, "required">;
+            token: import("convex/values").VString<string, "required">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+            ipAddress: import("convex/values").VString<string | undefined, "optional">;
+            userAgent: import("convex/values").VString<string | undefined, "optional">;
+            userId: import("convex/values").VString<string, "required">;
+        }, "required", "userId" | "createdAt" | "updatedAt" | "expiresAt" | "token" | "ipAddress" | "userAgent">, {
+            token: ["token", "_creationTime"];
+            userId: ["userId", "_creationTime"];
+        }, {}, {}>;
+        account: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            accessToken?: string | undefined;
+            refreshToken?: string | undefined;
+            idToken?: string | undefined;
+            accessTokenExpiresAt?: number | undefined;
+            refreshTokenExpiresAt?: number | undefined;
+            scope?: string | undefined;
+            password?: string | undefined;
+            userId: string;
+            createdAt: number;
+            updatedAt: number;
+            accountId: string;
+            providerId: string;
+        }, {
+            accountId: import("convex/values").VString<string, "required">;
+            providerId: import("convex/values").VString<string, "required">;
+            userId: import("convex/values").VString<string, "required">;
+            accessToken: import("convex/values").VString<string | undefined, "optional">;
+            refreshToken: import("convex/values").VString<string | undefined, "optional">;
+            idToken: import("convex/values").VString<string | undefined, "optional">;
+            accessTokenExpiresAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            refreshTokenExpiresAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            scope: import("convex/values").VString<string | undefined, "optional">;
+            password: import("convex/values").VString<string | undefined, "optional">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "userId" | "createdAt" | "updatedAt" | "accountId" | "providerId" | "accessToken" | "refreshToken" | "idToken" | "accessTokenExpiresAt" | "refreshTokenExpiresAt" | "scope" | "password">, {
+            userId: ["userId", "_creationTime"];
+            accountId: ["accountId", "_creationTime"];
+            providerId_accountId: ["providerId", "accountId", "_creationTime"];
+            userId_providerId: ["userId", "providerId", "_creationTime"];
+        }, {}, {}>;
+        twoFactor: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            userId: string;
+            secret: string;
+            backupCodes: string;
+        }, {
+            secret: import("convex/values").VString<string, "required">;
+            backupCodes: import("convex/values").VString<string, "required">;
+            userId: import("convex/values").VString<string, "required">;
+        }, "required", "userId" | "secret" | "backupCodes">, {
+            userId: ["userId", "_creationTime"];
+        }, {}, {}>;
+        verification: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            createdAt?: number | undefined;
+            updatedAt?: number | undefined;
+            expiresAt: number;
+            identifier: string;
+            value: string;
+        }, {
+            identifier: import("convex/values").VString<string, "required">;
+            value: import("convex/values").VString<string, "required">;
+            expiresAt: import("convex/values").VFloat64<number, "required">;
+            createdAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            updatedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "createdAt" | "updatedAt" | "expiresAt" | "identifier" | "value">, {
+            identifier: ["identifier", "_creationTime"];
+            expiresAt: ["expiresAt", "_creationTime"];
+        }, {}, {}>;
+        jwks: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            id?: string | undefined;
+            createdAt: number;
+            publicKey: string;
+            privateKey: string;
+        }, {
+            publicKey: import("convex/values").VString<string, "required">;
+            privateKey: import("convex/values").VString<string, "required">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+            id: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "id" | "createdAt" | "publicKey" | "privateKey">, {}, {}, {}>;
+    }[TableName]["validator"], {
+        _id: import("convex/values").VId<import("convex/values").GenericId<TableName>, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+    }>;
+    null: () => import("convex/values").VNull<null, "required">;
+    number: () => import("convex/values").VFloat64<number, "required">;
+    float64: () => import("convex/values").VFloat64<number, "required">;
+    bigint: () => import("convex/values").VInt64<bigint, "required">;
+    int64: () => import("convex/values").VInt64<bigint, "required">;
+    boolean: () => import("convex/values").VBoolean<boolean, "required">;
+    string: () => import("convex/values").VString<string, "required">;
+    bytes: () => import("convex/values").VBytes<ArrayBuffer, "required">;
+    literal: <T extends string | number | bigint | boolean>(literal: T) => import("convex/values").VLiteral<T, "required">;
+    array: <T_1 extends import("convex/values").Validator<any, "required", any>>(element: T_1) => import("convex/values").VArray<T_1["type"][], T_1, "required">;
+    object: <T_2 extends import("convex/values").PropertyValidators>(fields: T_2) => import("convex/values").VObject<import("convex/server").Expand<{ [Property in { [Property_1 in keyof T_2]: T_2[Property_1]["isOptional"] extends "optional" ? Property_1 : never; }[keyof T_2]]?: Exclude<import("convex/values").Infer<T_2[Property]>, undefined> | undefined; } & { [Property_1 in Exclude<keyof T_2, { [Property in keyof T_2]: T_2[Property]["isOptional"] extends "optional" ? Property : never; }[keyof T_2]>]: import("convex/values").Infer<T_2[Property_1]>; }>, T_2, "required", { [Property_2 in keyof T_2]: Property_2 | `${Property_2 & string}.${T_2[Property_2]["fieldPaths"]}`; }[keyof T_2] & string>;
+    record: <Key extends import("convex/values").Validator<string, "required", any>, Value extends import("convex/values").Validator<any, "required", any>>(keys: Key, values: Value) => import("convex/values").VRecord<Record<import("convex/values").Infer<Key>, Value["type"]>, Key, Value, "required", string>;
+    union: <T_3 extends import("convex/values").Validator<any, "required", any>[]>(...members: T_3) => import("convex/values").VUnion<T_3[number]["type"], T_3, "required", T_3[number]["fieldPaths"]>;
+    any: () => import("convex/values").VAny<any, "required", string>;
+    optional: <T_4 extends import("convex/values").GenericValidator>(value: T_4) => import("convex/values").VOptional<T_4>;
+};
+//# sourceMappingURL=util.d.ts.map

package/dist/esm/component/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/component/util.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gMACstS,eAAgB,qEAAqE,CAAC,mJAA0H,aAAc,+MAAuL,eAAe;;mFAAkV,GAAG,gDAAwB,WAAW,2BAA0B,WAAY;;;CADvgU,CAAC"}

package/dist/esm/component/util.js

@@ -0,0 +1,4 @@
+import { typedV } from "convex-helpers/validators";
+import schema from "./schema.js";
+export const vv = typedV(schema);
+//# sourceMappingURL=util.js.map

package/dist/esm/component/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../src/component/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACnD,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,MAAM,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC"}

package/dist/esm/nextjs/index.d.ts

@@ -0,0 +1,10 @@
+import { betterAuth } from "better-auth";
+import { GenericActionCtx } from "convex/server";
+export declare const getToken: (createAuth: (ctx: GenericActionCtx<any>) => ReturnType<typeof betterAuth>) => Promise<string | undefined>;
+export declare const nextJsHandler: (opts?: {
+    convexSiteUrl?: string;
+}) => {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/nextjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nextjs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,QAAQ,GACnB,YAAY,CAAC,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,OAAO,UAAU,CAAC,gCAS1E,CAAC;AAYF,eAAO,MAAM,aAAa,GAAI,OAAO;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE;mBAC9C,OAAO;oBACN,OAAO;CACvB,CAAC"}

package/dist/esm/nextjs/index.js

@@ -0,0 +1,23 @@
+import { createCookieGetter } from "better-auth/cookies";
+export const getToken = async (createAuth) => {
+    const { cookies } = await import("next/headers");
+    const cookieStore = await cookies();
+    const auth = createAuth({});
+    const createCookie = createCookieGetter(auth.options);
+    const cookie = createCookie("convex_jwt");
+    const token = cookieStore.get(cookie.name);
+    return typeof token === "string" ? token : token?.value;
+};
+const handler = (request, opts) => {
+    const requestUrl = new URL(request.url);
+    const convexSiteUrl = opts?.convexSiteUrl ?? process.env.NEXT_PUBLIC_CONVEX_SITE_URL;
+    const nextUrl = `${convexSiteUrl}${requestUrl.pathname}${requestUrl.search}`;
+    const newRequest = new Request(nextUrl, request);
+    newRequest.headers.set("accept-encoding", "application/json");
+    return fetch(newRequest, { method: request.method, redirect: "manual" });
+};
+export const nextJsHandler = (opts) => ({
+    GET: (request) => handler(request, opts),
+    POST: (request) => handler(request, opts),
+});
+//# sourceMappingURL=index.js.map

package/dist/esm/nextjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/nextjs/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,CAAC,MAAM,QAAQ,GAAG,KAAK,EAC3B,UAAyE,EACzE,EAAE;IACF,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;IACjD,MAAM,WAAW,GAAG,MAAM,OAAO,EAAE,CAAC;IACpC,MAAM,IAAI,GAAG,UAAU,CAAC,EAAS,CAAC,CAAC;IACnC,MAAM,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtD,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC;AAC1D,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,OAAgB,EAAE,IAAiC,EAAE,EAAE;IACtE,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACxC,MAAM,aAAa,GACjB,IAAI,EAAE,aAAa,IAAI,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;IACjE,MAAM,OAAO,GAAG,GAAG,aAAa,GAAG,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC;IAC7E,MAAM,UAAU,GAAG,IAAI,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjD,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;IAC9D,OAAO,KAAK,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;AAC3E,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAiC,EAAE,EAAE,CAAC,CAAC;IACnE,GAAG,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;IACjD,IAAI,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;CACnD,CAAC,CAAC"}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/plugins/convex/client.d.ts

@@ -0,0 +1,6 @@
+import { convex } from "./index.js";
+export declare const convexClient: () => {
+    id: "convex";
+    $InferServerPlugin: ReturnType<typeof convex>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/esm/plugins/convex/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/plugins/convex/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC;AAE3B,eAAO,MAAM,YAAY;;wBAGK,UAAU,CAAC,OAAO,MAAM,CAAC;CAEtD,CAAC"}

package/dist/esm/plugins/convex/client.js

@@ -0,0 +1,7 @@
+export const convexClient = () => {
+    return {
+        id: "convex",
+        $InferServerPlugin: {},
+    };
+};
+//# sourceMappingURL=client.js.map

package/dist/esm/plugins/convex/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/plugins/convex/client.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,EAAE;IAC/B,OAAO;QACL,EAAE,EAAE,QAAQ;QACZ,kBAAkB,EAAE,EAA+B;KACnB,CAAC;AACrC,CAAC,CAAC"}