better-auth 1.7.12 → 1.7.13

package/dist/plugins/device-authorization/index.d.mts

@@ -3,10 +3,7 @@ import { DeviceCode } from "./schema.mjs";
 import { DeviceCodeRedemptionAuthorization, DeviceCodeRedemptionResult, redeemDeviceCode } from "./routes.mjs";
 import { GenericEndpointContext, StandardSchemaV1 } from "@better-auth/core";
 import { DBFieldAttribute } from "@better-auth/core/db";
-import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
-import * as _$better_call0 from "better-call";
 import * as z from "zod";
-
 //#region src/plugins/device-authorization/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -15,7 +12,7 @@ declare module "@better-auth/core" {
     };
   }
 }
-declare const deviceAuthorizationOptionsSchema: z.ZodObject<{
+export declare const deviceAuthorizationOptionsSchema: z.ZodObject<{
   expiresIn: z.ZodDefault<z.ZodCustom<TimeString, TimeString>>;
   interval: z.ZodDefault<z.ZodCustom<TimeString, TimeString>>;
   deviceCodeLength: z.ZodDefault<z.ZodNumber>;
@@ -57,14 +54,14 @@ declare const deviceAuthorizationOptionsSchema: z.ZodObject<{
     } | undefined;
   }>>;
 }, z.core.$strip>;
-type DeviceAuthorizationOptions = z.infer<typeof deviceAuthorizationOptionsSchema>;
-interface DeviceAuthorizationRequest {
+export type DeviceAuthorizationOptions = z.infer<typeof deviceAuthorizationOptionsSchema>;
+export interface DeviceAuthorizationRequest {
   client_id?: string | undefined;
   user_id?: string | undefined;
   scope?: string | undefined;
 }
 /** The client binding and grant-owned fields produced by request authorization. */
-interface DeviceAuthorizationGrantAuthorization {
+export interface DeviceAuthorizationGrantAuthorization {
   /** The client identifier that owns the device code. */
   clientId: string;
   /** Additional grant-owned fields persisted with the device code. */
@@ -74,7 +71,7 @@ interface DeviceAuthorizationGrantAuthorization {
  * A token grant that contributes its request state to device authorization
  * without expanding the standalone plugin's database or endpoint contracts.
  */
-interface DeviceAuthorizationGrant<RequestFields extends z.ZodRawShape = z.ZodRawShape, VerificationContext extends Record<string, unknown> = Record<string, unknown>> {
+export interface DeviceAuthorizationGrant<RequestFields extends z.ZodRawShape = z.ZodRawShape, VerificationContext extends Record<string, unknown> = Record<string, unknown>> {
   /** Additional request fields accepted only when this grant is configured. */
   requestSchemaFields: RequestFields;
   /** Additional request errors introduced by the grant's protocol extensions. */
@@ -100,10 +97,11 @@ interface DeviceAuthorizationGrant<RequestFields extends z.ZodRawShape = z.ZodRa
   /** OpenAPI properties matching `getVerificationContext()`. */
   verificationOpenAPIProperties?: Record<string, Record<string, unknown>>;
 }
-type DeviceAuthorizationPluginOptions<Grant extends DeviceAuthorizationGrant | undefined = undefined> = Partial<DeviceAuthorizationOptions> & {
-  /** Optional token grant that extends the device authorization flow. */grant?: Grant;
+export type DeviceAuthorizationPluginOptions<Grant extends DeviceAuthorizationGrant | undefined = undefined> = Partial<DeviceAuthorizationOptions> & {
+  /** Optional token grant that extends the device authorization flow. */
+  grant?: Grant;
 };
-declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | undefined = undefined>(options?: DeviceAuthorizationPluginOptions<Grant>) => {
+export declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | undefined = undefined>(options?: DeviceAuthorizationPluginOptions<Grant>) => {
   id: "device-authorization";
   version: string;
   schema: {
@@ -153,7 +151,7 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
     };
   };
   endpoints: {
-    deviceCode: _$better_call0.StrictEndpoint<"/device/code", {
+    deviceCode: import("better-call").StrictEndpoint<"/device/code", {
       method: "POST";
       cloneRequest: true;
       body: z.ZodObject<(("scope" | "user_id" | "client_id") & keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
@@ -164,15 +162,15 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
         scope: z.ZodOptional<z.ZodString>;
       } & ((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P] } : never) : ({
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends (infer T_1) ? { -readonly [P in keyof T_1]: T_1[P]; } : never) : ({
         client_id: z.ZodString;
         user_id: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodString>;
-      } extends infer T_2 extends z.core.util.SomeObject ? { [K in keyof T_2 as K extends keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
+      } extends (infer T_2 extends z.core.util.SomeObject) ? { [K in keyof T_2 as K extends keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) ? never : K]: T_2[K] } : never) & (((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) ? never : K]: T_2[K]; } : never) & (((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends infer T_4 ? { -readonly [P in keyof T_4]: T_4[P] } : never) extends infer T_3 extends z.core.util.SomeObject ? { [K_1 in keyof T_3]: T_3[K_1] } : never)) extends infer T ? { [k in keyof T]: T[k] } : never, z.core.$strip> | z.ZodObject<(("scope" | "user_id" | "client_id") & keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends (infer T_4) ? { -readonly [P in keyof T_4]: T_4[P]; } : never) extends (infer T_3 extends z.core.util.SomeObject) ? { [K_1 in keyof T_3]: T_3[K_1]; } : never)) extends (infer T) ? { [k in keyof T]: T[k]; } : never, z.core.$strip> | z.ZodObject<(("scope" | "user_id" | "client_id") & keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
       }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends never ? {
         user_id: z.ZodOptional<z.ZodString>;
@@ -180,27 +178,24 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
         client_id: z.ZodOptional<z.ZodString>;
       } & ((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends infer T_6 ? { -readonly [P in keyof T_6]: T_6[P] } : never) : ({
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends (infer T_6) ? { -readonly [P in keyof T_6]: T_6[P]; } : never) : ({
         user_id: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodString>;
         client_id: z.ZodOptional<z.ZodString>;
-      } extends infer T_7 extends z.core.util.SomeObject ? { [K_2 in keyof T_7 as K_2 extends keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
+      } extends (infer T_7 extends z.core.util.SomeObject) ? { [K_2 in keyof T_7 as K_2 extends keyof (Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) ? never : K_2]: T_7[K_2] } : never) & (((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) ? never : K_2]: T_7[K_2]; } : never) & (((Grant extends DeviceAuthorizationGrant<infer RequestFields extends Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends infer T_9 ? { -readonly [P in keyof T_9]: T_9[P] } : never) extends infer T_8 extends z.core.util.SomeObject ? { [K_1 in keyof T_8]: T_8[K_1] } : never)) extends infer T_5 ? { [k_1 in keyof T_5]: T_5[k_1] } : never, z.core.$strip>;
+      }>, Record<string, unknown>> ? RequestFields : Record<never, never>) extends (infer T_9) ? { -readonly [P in keyof T_9]: T_9[P]; } : never) extends (infer T_8 extends z.core.util.SomeObject) ? { [K_1 in keyof T_8]: T_8[K_1]; } : never)) extends (infer T_5) ? { [k_1 in keyof T_5]: T_5[k_1]; } : never, z.core.$strip>;
       error: z.ZodObject<{
         error: z.ZodEnum<{ [k_3 in (readonly ["invalid_request", "invalid_client", "unauthorized_client", "invalid_scope", ...Grant extends {
           requestErrorCodes: infer ErrorCodes extends readonly string[];
-        } ? ErrorCodes : readonly [], "server_error"])[number]]: k_3 } extends infer T_10 ? { [k_2 in keyof T_10]: T_10[k_2] } : never>;
+        } ? ErrorCodes : readonly [], "server_error"])[number]]: k_3; } extends (infer T_10) ? { [k_2 in keyof T_10]: T_10[k_2]; } : never>;
         error_description: z.ZodString;
       }, z.core.$strip>;
-      onValidationError: ({
-        issues,
-        message
-      }: {
+      onValidationError: ({ issues, message }: {
         message: string;
-        issues: readonly _$better_call0.StandardSchemaV1.Issue[];
+        issues: readonly import("better-call").StandardSchemaV1.Issue[];
       }) => never;
       metadata: {
         noStore: boolean;
@@ -297,7 +292,7 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
       expires_in: number;
       interval: number;
     }>;
-    deviceToken: _$better_call0.StrictEndpoint<"/device/token", {
+    deviceToken: import("better-call").StrictEndpoint<"/device/token", {
       method: "POST";
       body: z.ZodObject<{
         grant_type: z.ZodLiteral<"urn:ietf:params:oauth:grant-type:device_code">;
@@ -366,7 +361,7 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
       expires_in: number;
       scope: string;
     }>;
-    deviceVerify: _$better_call0.StrictEndpoint<"/device", {
+    deviceVerify: import("better-call").StrictEndpoint<"/device", {
       method: "GET";
       query: z.ZodObject<{
         user_code: z.ZodString;
@@ -421,7 +416,7 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
     } & Partial<Grant extends DeviceAuthorizationGrant<infer _RequestFields extends Readonly<{
       [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }>, infer VerificationContext extends Record<string, unknown>> ? VerificationContext : Record<never, never>>>;
-    deviceApprove: _$better_call0.StrictEndpoint<"/device/approve", {
+    deviceApprove: import("better-call").StrictEndpoint<"/device/approve", {
       method: "POST";
       body: z.ZodObject<{
         userCode: z.ZodString;
@@ -462,7 +457,7 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
     }, {
       success: boolean;
     }>;
-    deviceDeny: _$better_call0.StrictEndpoint<"/device/deny", {
+    deviceDeny: import("better-call").StrictEndpoint<"/device/deny", {
       method: "POST";
       body: z.ZodObject<{
         userCode: z.ZodString;
@@ -509,19 +504,19 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
     max: number;
   }[];
   $ERROR_CODES: {
-    USER_NOT_FOUND: _$_better_auth_core_utils_error_codes0.RawError<"USER_NOT_FOUND">;
-    FAILED_TO_CREATE_SESSION: _$_better_auth_core_utils_error_codes0.RawError<"FAILED_TO_CREATE_SESSION">;
-    INVALID_DEVICE_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_DEVICE_CODE">;
-    EXPIRED_DEVICE_CODE: _$_better_auth_core_utils_error_codes0.RawError<"EXPIRED_DEVICE_CODE">;
-    EXPIRED_USER_CODE: _$_better_auth_core_utils_error_codes0.RawError<"EXPIRED_USER_CODE">;
-    AUTHORIZATION_PENDING: _$_better_auth_core_utils_error_codes0.RawError<"AUTHORIZATION_PENDING">;
-    ACCESS_DENIED: _$_better_auth_core_utils_error_codes0.RawError<"ACCESS_DENIED">;
-    INVALID_USER_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_USER_CODE">;
-    DEVICE_CODE_ALREADY_PROCESSED: _$_better_auth_core_utils_error_codes0.RawError<"DEVICE_CODE_ALREADY_PROCESSED">;
-    DEVICE_CODE_NOT_CLAIMED: _$_better_auth_core_utils_error_codes0.RawError<"DEVICE_CODE_NOT_CLAIMED">;
-    POLLING_TOO_FREQUENTLY: _$_better_auth_core_utils_error_codes0.RawError<"POLLING_TOO_FREQUENTLY">;
-    INVALID_DEVICE_CODE_STATUS: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_DEVICE_CODE_STATUS">;
-    AUTHENTICATION_REQUIRED: _$_better_auth_core_utils_error_codes0.RawError<"AUTHENTICATION_REQUIRED">;
+    USER_NOT_FOUND: import("@better-auth/core/utils/error-codes").RawError<"USER_NOT_FOUND">;
+    FAILED_TO_CREATE_SESSION: import("@better-auth/core/utils/error-codes").RawError<"FAILED_TO_CREATE_SESSION">;
+    INVALID_DEVICE_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_DEVICE_CODE">;
+    EXPIRED_DEVICE_CODE: import("@better-auth/core/utils/error-codes").RawError<"EXPIRED_DEVICE_CODE">;
+    EXPIRED_USER_CODE: import("@better-auth/core/utils/error-codes").RawError<"EXPIRED_USER_CODE">;
+    AUTHORIZATION_PENDING: import("@better-auth/core/utils/error-codes").RawError<"AUTHORIZATION_PENDING">;
+    ACCESS_DENIED: import("@better-auth/core/utils/error-codes").RawError<"ACCESS_DENIED">;
+    INVALID_USER_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_USER_CODE">;
+    DEVICE_CODE_ALREADY_PROCESSED: import("@better-auth/core/utils/error-codes").RawError<"DEVICE_CODE_ALREADY_PROCESSED">;
+    DEVICE_CODE_NOT_CLAIMED: import("@better-auth/core/utils/error-codes").RawError<"DEVICE_CODE_NOT_CLAIMED">;
+    POLLING_TOO_FREQUENTLY: import("@better-auth/core/utils/error-codes").RawError<"POLLING_TOO_FREQUENTLY">;
+    INVALID_DEVICE_CODE_STATUS: import("@better-auth/core/utils/error-codes").RawError<"INVALID_DEVICE_CODE_STATUS">;
+    AUTHENTICATION_REQUIRED: import("@better-auth/core/utils/error-codes").RawError<"AUTHENTICATION_REQUIRED">;
   };
   options: {
     grant: DeviceAuthorizationGrant<Readonly<{
@@ -555,4 +550,4 @@ declare const deviceAuthorization: <Grant extends DeviceAuthorizationGrant | und
   };
 };
 //#endregion
-export { DeviceAuthorizationGrant, DeviceAuthorizationGrantAuthorization, DeviceAuthorizationOptions, DeviceAuthorizationPluginOptions, DeviceAuthorizationRequest, type DeviceCode, type DeviceCodeRedemptionAuthorization, type DeviceCodeRedemptionResult, TimeString, deviceAuthorization, deviceAuthorizationOptionsSchema, ms, redeemDeviceCode, sec };
+export { type DeviceCode, type DeviceCodeRedemptionAuthorization, type DeviceCodeRedemptionResult, type TimeString, type ms, redeemDeviceCode, type sec };

package/dist/plugins/device-authorization/index.mjs

@@ -28,12 +28,12 @@ const deviceAuthorizationOptionsSchema = z.object({
 	verificationUri: z.string().optional().describe("The URI where users verify their device code. Can be an absolute URL (https://example.com/device) or relative path (/custom-path). This will be returned as verification_uri in the device code response. If not provided, defaults to /device."),
 	schema: z.custom(() => true).optional()
 });
-const deviceAuthorizationRequestFields = new Set([
+const deviceAuthorizationRequestFields = /* @__PURE__ */ new Set([
 	"client_id",
 	"user_id",
 	"scope"
 ]);
-const deviceVerificationResponseFields = new Set([
+const deviceVerificationResponseFields = /* @__PURE__ */ new Set([
 	"user_code",
 	"status",
 	"client_id",
@@ -52,16 +52,17 @@ const deviceAuthorization = (options = {}) => {
 	const grant = configuredGrant;
 	const opts = deviceAuthorizationOptionsSchema.parse(deviceAuthorizationOptions);
 	assertGrantFieldsAreAdditional(grant);
+	const grantSchema = { deviceCode: {
+		...schema.deviceCode,
+		fields: {
+			...schema.deviceCode.fields,
+			...grant?.deviceCodeSchemaFields
+		}
+	} };
 	return {
 		id: "device-authorization",
 		version: PACKAGE_VERSION,
-		schema: mergeSchema({ deviceCode: {
-			...schema.deviceCode,
-			fields: {
-				...schema.deviceCode.fields,
-				...grant?.deviceCodeSchemaFields
-			}
-		} }, options.schema),
+		schema: mergeSchema(grantSchema, options.schema),
 		endpoints: {
 			deviceCode: deviceCode(opts, grant),
 			deviceToken: deviceToken(opts, grant),

package/dist/plugins/device-authorization/routes.d.mts

@@ -1,15 +1,18 @@
 import { Where } from "../../types/adapter.mjs";
 import { User } from "../../types/models.mjs";
+import "../../types/index.mjs";
 import { DeviceCode } from "./schema.mjs";
+import "./index.mjs";
 import { GenericEndpointContext } from "@better-auth/core";
+import "zod";
 //#region src/plugins/device-authorization/routes.d.ts
-interface DeviceCodeRedemptionAuthorization<AuthorizationContext> {
+export interface DeviceCodeRedemptionAuthorization<AuthorizationContext> {
   /** Additional ownership predicate used by the atomic claim. */
   ownershipWhere: Where;
   /** Issuer-specific state that survives until token issuance. */
   context: AuthorizationContext;
 }
-interface DeviceCodeRedemptionResult<DeviceCodeFields extends Record<string, unknown>, AuthorizationContext, RedemptionContext> {
+export interface DeviceCodeRedemptionResult<DeviceCodeFields extends Record<string, unknown>, AuthorizationContext, RedemptionContext> {
   claimedDeviceCode: DeviceCode & DeviceCodeFields & {
     userId: string;
   };
@@ -22,11 +25,10 @@ interface DeviceCodeRedemptionResult<DeviceCodeFields extends Record<string, unk
  * token issuer. Issuers supply ownership checks and grant-specific validation,
  * but cannot bypass expiry, polling, denial, or atomic consumption.
  */
-declare function redeemDeviceCode<DeviceCodeFields extends Record<string, unknown>, AuthorizationContext, RedemptionContext>(input: {
+export declare function redeemDeviceCode<DeviceCodeFields extends Record<string, unknown>, AuthorizationContext, RedemptionContext>(input: {
   ctx: GenericEndpointContext;
   deviceCode: string;
   authorizeRedemption: (deviceCode: DeviceCode & DeviceCodeFields) => DeviceCodeRedemptionAuthorization<AuthorizationContext> | Promise<DeviceCodeRedemptionAuthorization<AuthorizationContext>>;
   prepareRedemption: (deviceCode: DeviceCode & DeviceCodeFields, authorizationContext: AuthorizationContext) => RedemptionContext | Promise<RedemptionContext>;
 }): Promise<DeviceCodeRedemptionResult<DeviceCodeFields, AuthorizationContext, RedemptionContext>>;
-//#endregion
-export { DeviceCodeRedemptionAuthorization, DeviceCodeRedemptionResult, redeemDeviceCode };
+//#endregion

package/dist/plugins/device-authorization/routes.mjs

@@ -8,7 +8,7 @@ import * as z from "zod";
 //#region src/plugins/device-authorization/routes.ts
 const defaultCharset = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 const MAX_DEVICE_CODE_GENERATION_ATTEMPTS = 3;
-const UNIQUE_CONSTRAINT_ERROR_IDENTIFIERS = new Set([
+const UNIQUE_CONSTRAINT_ERROR_IDENTIFIERS = /* @__PURE__ */ new Set([
 	"11000",
 	"1062",
 	"2067",
@@ -108,14 +108,15 @@ const deviceCode = (opts, grant) => {
 	const requestSchema = (grant ? deviceCodeBodySchema.extend({ client_id: z.string().optional() }) : deviceCodeBodySchema).extend(requestFields);
 	const requestErrorCodes = [...deviceCodeBaseErrorCodes, ...grant?.requestErrorCodes ?? []];
 	const endpointErrorCodes = [...requestErrorCodes, "server_error"];
+	const requestErrorSchema = z.object({
+		error: z.enum(endpointErrorCodes).meta({ description: "Error code" }),
+		error_description: z.string().meta({ description: "Detailed error description" })
+	});
 	return createAuthEndpoint("/device/code", {
 		method: "POST",
 		cloneRequest: true,
 		body: requestSchema,
-		error: z.object({
-			error: z.enum(endpointErrorCodes).meta({ description: "Error code" }),
-			error_description: z.string().meta({ description: "Detailed error description" })
-		}),
+		error: requestErrorSchema,
 		onValidationError: ({ issues, message }) => {
 			grant?.onRequestValidationError?.(issues);
 			throw new APIError("BAD_REQUEST", {

package/dist/plugins/device-authorization/schema.d.mts

@@ -1,5 +1,4 @@
 import * as z from "zod";
-
 //#region src/plugins/device-authorization/schema.d.ts
 declare const deviceCode: z.ZodObject<{
   id: z.ZodString;
@@ -13,6 +12,6 @@ declare const deviceCode: z.ZodObject<{
   clientId: z.ZodOptional<z.ZodString>;
   scope: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-type DeviceCode = z.infer<typeof deviceCode>;
+export type DeviceCode = z.infer<typeof deviceCode>;
 //#endregion
-export { DeviceCode };
+export {};

package/dist/plugins/email-otp/client.d.mts

@@ -1,9 +1,7 @@
 import { emailOTP } from "./index.mjs";
 import { EMAIL_OTP_ERROR_CODES } from "./error-codes.mjs";
-import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
-
 //#region src/plugins/email-otp/client.d.ts
-declare const emailOTPClient: () => {
+export declare const emailOTPClient: () => {
   id: "email-otp";
   version: string;
   $InferServerPlugin: ReturnType<typeof emailOTP>;
@@ -12,10 +10,10 @@ declare const emailOTPClient: () => {
     signal: "$sessionSignal";
   }[];
   $ERROR_CODES: {
-    OTP_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_EXPIRED">;
-    INVALID_OTP: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_OTP">;
-    TOO_MANY_ATTEMPTS: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS">;
+    OTP_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_EXPIRED">;
+    INVALID_OTP: import("@better-auth/core/utils/error-codes").RawError<"INVALID_OTP">;
+    TOO_MANY_ATTEMPTS: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS">;
   };
 };
 //#endregion
-export { emailOTPClient };
+export { EMAIL_OTP_ERROR_CODES };

package/dist/plugins/email-otp/client.mjs

@@ -14,4 +14,4 @@ const emailOTPClient = () => {
 	};
 };
 //#endregion
-export { emailOTPClient };
+export { EMAIL_OTP_ERROR_CODES, emailOTPClient };

package/dist/plugins/email-otp/error-codes.d.mts

@@ -1,10 +1,7 @@
-import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
-
 //#region src/plugins/email-otp/error-codes.d.ts
-declare const EMAIL_OTP_ERROR_CODES: {
-  OTP_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_EXPIRED">;
-  INVALID_OTP: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_OTP">;
-  TOO_MANY_ATTEMPTS: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS">;
+export declare const EMAIL_OTP_ERROR_CODES: {
+  OTP_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_EXPIRED">;
+  INVALID_OTP: import("@better-auth/core/utils/error-codes").RawError<"INVALID_OTP">;
+  TOO_MANY_ATTEMPTS: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS">;
 };
-//#endregion
-export { EMAIL_OTP_ERROR_CODES };
+//#endregion