@better-auth/electron 1.6.0-beta.0 → 1.6.0

package/dist/{client-CMv-uqSO.d.mts → client-D6xRwPM0.d.mts}

@@ -241,7 +241,14 @@ interface ElectronProxyClientOptions extends ElectronSharedClientOptions {
 //#region src/authenticate.d.ts
 declare const kElectron: unique symbol;
 declare const requestAuthOptionsSchema: z.ZodObject<{
-  [x: string]: any;
+  provider: z.ZodOptional<z.ZodString>;
+  callbackURL: z.ZodOptional<z.ZodString>;
+  newUserCallbackURL: z.ZodOptional<z.ZodString>;
+  errorCallbackURL: z.ZodOptional<z.ZodString>;
+  disableRedirect: z.ZodOptional<z.ZodBoolean>;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  requestSignUp: z.ZodOptional<z.ZodBoolean>;
+  additionalData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>;
 type ElectronRequestAuthOptions = z.infer<typeof requestAuthOptionsSchema>;
 /**

package/dist/client.d.mts

@@ -1,2 +1,2 @@
-import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-CMv-uqSO.mjs";
+import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-D6xRwPM0.mjs";
 export { ElectronAuthenticateOptions, ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, ElectronSharedClientOptions, ElectronSharedOptions, ExposedBridges, FetchUserImageResult, SetupRendererConfig, Storage, authenticate, electronClient, fetchUserImage, handleDeepLink, kElectron, normalizeUserOutput, requestAuth, setupRenderer };

package/dist/client.mjs

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-BqMHXjG-.mjs";
+import { t as PACKAGE_VERSION } from "./version-Cf5gNNxE.mjs";
 import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-DxDKRT6e.mjs";
 import { BetterAuthError } from "@better-auth/core/error";
 import { base64, base64Url } from "@better-auth/utils/base64";

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-CMv-uqSO.mjs";
+import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-D6xRwPM0.mjs";
 import * as better_auth0 from "better-auth";
+import * as z from "zod";
 import * as _better_auth_core0 from "@better-auth/core";
 import { HookEndpointContext } from "@better-auth/core";
 import * as better_call0 from "better-call";
@@ -21,10 +22,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
   hooks: {
     after: ({
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<void>>;
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
     } | {
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<better_call0.MiddlewareContext<{
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
         returned?: unknown | undefined;
         responseHeaders?: Headers | undefined;
       } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
@@ -154,156 +155,171 @@ declare const electron: (options?: ElectronOptions | undefined) => {
         runInBackgroundOrAwait: (promise: Promise<unknown> | void) => better_auth0.Awaitable<unknown>;
       }> | {
         electron_authorization_code: string;
-      } | undefined>>;
+      } | undefined>;
     })[];
   };
   endpoints: {
-    electronToken: better_call0.Endpoint<"/electron/token", "POST", {
-      token: string;
-      state: string;
-      code_verifier: string;
-    }, Record<string, any> | undefined, [], {
-      token: string;
-      user: better_auth0.User & Record<string, any>;
-    }, {
-      scope: "http";
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    token: {
-                      type: string;
-                    };
-                    user: {
-                      type: string;
-                      $ref: string;
+    electronToken: better_call0.StrictEndpoint<"/electron/token", {
+      method: "POST";
+      body: z.ZodObject<{
+        token: z.ZodString;
+        state: z.ZodString;
+        code_verifier: z.ZodString;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      token: {
+                        type: string;
+                      };
+                      user: {
+                        type: string;
+                        $ref: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
-    electronInitOAuthProxy: better_call0.Endpoint<"/electron/init-oauth-proxy", "GET", undefined, {
-      provider: string;
-      state: string;
-      code_challenge: string;
-      code_challenge_method?: string | undefined;
-    }, [], {
-      url: string | undefined;
-      redirect: boolean;
-      user?: better_auth0.User & Record<string, any>;
-      token?: string;
-    } | undefined, {
-      scope: "http";
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    url: {
-                      type: string;
-                      nullable: boolean;
-                    };
-                    redirect: {
-                      type: string;
-                    };
-                    user: {
-                      type: string;
-                      $ref: string;
-                    };
-                    token: {
-                      type: string;
+    }, {
+      token: string;
+      user: better_auth0.User & Record<string, any>;
+    }>;
+    electronInitOAuthProxy: better_call0.StrictEndpoint<"/electron/init-oauth-proxy", {
+      method: "GET";
+      query: z.ZodObject<{
+        provider: z.ZodString;
+        state: z.ZodString;
+        code_challenge: z.ZodString;
+        code_challenge_method: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      url: {
+                        type: string;
+                        nullable: boolean;
+                      };
+                      redirect: {
+                        type: string;
+                      };
+                      user: {
+                        type: string;
+                        $ref: string;
+                      };
+                      token: {
+                        type: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
-    electronTransferUser: better_call0.Endpoint<"/electron/transfer-user", "POST", {
-      callbackURL?: string | undefined;
     }, {
-      client_id: string;
-      state: string;
-      code_challenge: string;
-      code_challenge_method?: string | undefined;
-    }, [better_call0.Middleware<(inputContext: Record<string, any>) => Promise<{
-      session: {
-        session: Record<string, any> & {
-          id: string;
-          createdAt: Date;
-          updatedAt: Date;
-          userId: string;
-          expiresAt: Date;
-          token: string;
-          ipAddress?: string | null | undefined;
-          userAgent?: string | null | undefined;
-        };
-        user: Record<string, any> & {
-          id: string;
-          createdAt: Date;
-          updatedAt: Date;
-          email: string;
-          emailVerified: boolean;
-          name: string;
-          image?: string | null | undefined;
-        };
-      };
-    }>>], {
-      url: string | null;
+      url: string | undefined;
       redirect: boolean;
-      electron_authorization_code: string;
-    }, {
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    url: {
-                      type: string;
-                      nullable: boolean;
-                    };
-                    redirect: {
-                      type: string;
-                    };
-                    electron_authorization_code: {
-                      type: string;
+      user?: better_auth0.User & Record<string, any>;
+      token?: string;
+    } | undefined>;
+    electronTransferUser: better_call0.StrictEndpoint<"/electron/transfer-user", {
+      method: "POST";
+      query: z.ZodObject<{
+        client_id: z.ZodString;
+        state: z.ZodString;
+        code_challenge: z.ZodString;
+        code_challenge_method: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      body: z.ZodObject<{
+        callbackURL: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+        session: {
+          session: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          };
+          user: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        };
+      }>)[];
+      requireHeaders: true;
+      metadata: {
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      url: {
+                        type: string;
+                        nullable: boolean;
+                      };
+                      redirect: {
+                        type: string;
+                      };
+                      electron_authorization_code: {
+                        type: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
+    }, {
+      url: string | null;
+      redirect: boolean;
+      electron_authorization_code: string;
+    }>;
   };
   options: {
     codeExpiresIn: number;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-BqMHXjG-.mjs";
+import { t as PACKAGE_VERSION } from "./version-Cf5gNNxE.mjs";
 import { createAuthMiddleware } from "@better-auth/core/api";
 import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
 import { base64Url } from "@better-auth/utils/base64";