@neondatabase/neon-js 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/index.d.mts

@@ -0,0 +1,1035 @@
+import * as better_auth_react0 from "better-auth/react";
+import { createAuthClient, useStore as useBetterAuthStore } from "better-auth/react";
+import { AuthClient, BetterAuthClientOptions, createAuthClient as createAuthClient$1 } from "better-auth/client";
+import * as better_auth0 from "better-auth";
+import * as _better_fetch_fetch0 from "@better-fetch/fetch";
+import * as nanostores0 from "nanostores";
+import * as _supabase_auth_js0 from "@supabase/auth-js";
+import { AuthApiError, AuthClient as AuthClient$1, AuthError, JwtHeader, JwtPayload, Session, User, isAuthError } from "@supabase/auth-js";
+import { PostgrestClient } from "@supabase/postgrest-js";
+
+//#region ../neon-auth/src/core/adapter-core.d.ts
+interface NeonAuthAdapterCoreAuthOptions extends Omit<BetterAuthClientOptions, 'plugins'> {}
+declare abstract class NeonAuthAdapterCore {
+  protected betterAuthOptions: BetterAuthClientOptions;
+  /**
+   * Better Auth adapter implementing the NeonAuthClient interface.
+   * See CLAUDE.md for architecture details and API mappings.
+   */
+  constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
+  abstract getBetterAuthInstance?(): AuthClient<BetterAuthClientOptions> | ReturnType<typeof createAuthClient>;
+  abstract getJWTToken(): Promise<string | null>;
+}
+//#endregion
+//#region ../neon-auth/src/adapters/better-auth-react/better-auth-react-adapter.d.ts
+type BetterAuthReactAdapterOptions = NeonAuthAdapterCoreAuthOptions;
+declare class BetterAuthReactAdapter extends NeonAuthAdapterCore {
+  private _betterAuth;
+  constructor(betterAuthClientOptions: BetterAuthReactAdapterOptions);
+  getBetterAuthInstance(): {
+    signIn: {
+      social: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+        provider: (string & {}) | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "huggingface" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linear" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar";
+        callbackURL?: string | undefined;
+        newUserCallbackURL?: string | undefined;
+        errorCallbackURL?: string | undefined;
+        disableRedirect?: boolean | undefined;
+        idToken?: {
+          token: string;
+          nonce?: string | undefined;
+          accessToken?: string | undefined;
+          refreshToken?: string | undefined;
+          expiresAt?: number | undefined;
+        } | undefined;
+        scopes?: string[] | undefined;
+        requestSignUp?: boolean | undefined;
+        loginHint?: string | undefined;
+        additionalData?: Record<string, any> | undefined;
+      }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+        provider: (string & {}) | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "huggingface" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linear" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar";
+        callbackURL?: string | undefined;
+        newUserCallbackURL?: string | undefined;
+        errorCallbackURL?: string | undefined;
+        disableRedirect?: boolean | undefined;
+        idToken?: {
+          token: string;
+          nonce?: string | undefined;
+          accessToken?: string | undefined;
+          refreshToken?: string | undefined;
+          expiresAt?: number | undefined;
+        } | undefined;
+        scopes?: string[] | undefined;
+        requestSignUp?: boolean | undefined;
+        loginHint?: string | undefined;
+        additionalData?: Record<string, any> | undefined;
+      } & {
+        fetchOptions?: FetchOptions | undefined;
+      }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<NonNullable<{
+        redirect: boolean;
+        url: string;
+      } | {
+        redirect: boolean;
+        token: string;
+        url: undefined;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined | undefined;
+        };
+      }>, {
+        code?: string | undefined;
+        message?: string | undefined;
+      }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+  } & {
+    signOut: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: Record<string, any> | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      success: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    signUp: {
+      email: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+        name: string;
+        email: string;
+        password: string;
+        image?: string | undefined;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+      }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+        email: string;
+        name: string;
+        password: string;
+        image?: string | undefined;
+        callbackURL?: string | undefined;
+        fetchOptions?: FetchOptions | undefined;
+      }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<NonNullable<{
+        token: null;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined | undefined;
+        };
+      } | {
+        token: string;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined | undefined;
+        };
+      }>, {
+        code?: string | undefined;
+        message?: string | undefined;
+      }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+  } & {
+    signIn: {
+      email: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+        email: string;
+        password: string;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+      }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+        email: string;
+        password: string;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+      } & {
+        fetchOptions?: FetchOptions | undefined;
+      }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+        redirect: boolean;
+        token: string;
+        url?: string | undefined;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined | undefined;
+        };
+      }, {
+        code?: string | undefined;
+        message?: string | undefined;
+      }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+  } & {
+    resetPassword: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      newPassword: string;
+      token?: string | undefined;
+    }> & Record<string, any>, Partial<{
+      token?: string | undefined;
+    }> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      newPassword: string;
+      token?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    verifyEmail: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<{
+      token: string;
+      callbackURL?: string | undefined;
+    }> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      query: {
+        token: string;
+        callbackURL?: string | undefined;
+      };
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<NonNullable<void | {
+      status: boolean;
+    }>, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    sendVerificationEmail: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      email: string;
+      callbackURL?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      email: string;
+      callbackURL?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    changeEmail: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      newEmail: string;
+      callbackURL?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      newEmail: string;
+      callbackURL?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    changePassword: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      newPassword: string;
+      currentPassword: string;
+      revokeOtherSessions?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      newPassword: string;
+      currentPassword: string;
+      revokeOtherSessions?: boolean | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      token: string | null;
+      user: {
+        id: string;
+        email: string;
+        name: string;
+        image: string | null | undefined;
+        emailVerified: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+      };
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    updateUser: <FetchOptions extends better_auth0.ClientFetchOption<Partial<Partial<{}> & {
+      name?: string | undefined;
+      image?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      image?: (string | null) | undefined;
+      name?: string | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    } & Partial<{}>> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    deleteUser: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      callbackURL?: string | undefined;
+      password?: string | undefined;
+      token?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      callbackURL?: string | undefined;
+      password?: string | undefined;
+      token?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      success: boolean;
+      message: string;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    requestPasswordReset: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      email: string;
+      redirectTo?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      email: string;
+      redirectTo?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+      message: string;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    resetPassword: {
+      ":token": <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<{
+        callbackURL: string;
+      }> & Record<string, any>, {
+        token: string;
+      }>>(data_0: better_auth_react0.Prettify<{
+        query: {
+          callbackURL: string;
+        };
+        fetchOptions?: FetchOptions | undefined;
+      }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<never, {
+        code?: string | undefined;
+        message?: string | undefined;
+      }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+  } & {
+    listSessions: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: Record<string, any> | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<better_auth_react0.Prettify<{
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      userId: string;
+      expiresAt: Date;
+      token: string;
+      ipAddress?: string | null | undefined | undefined;
+      userAgent?: string | null | undefined | undefined;
+    }>[], {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    revokeSession: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      token: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      token: string;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    revokeSessions: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: Record<string, any> | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    revokeOtherSessions: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: Record<string, any> | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    linkSocial: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      provider: unknown;
+      callbackURL?: string | undefined;
+      idToken?: {
+        token: string;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+      } | undefined;
+      requestSignUp?: boolean | undefined;
+      scopes?: string[] | undefined;
+      errorCallbackURL?: string | undefined;
+      disableRedirect?: boolean | undefined;
+      additionalData?: Record<string, any> | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      provider: unknown;
+      callbackURL?: string | undefined;
+      idToken?: {
+        token: string;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+      } | undefined;
+      requestSignUp?: boolean | undefined;
+      scopes?: string[] | undefined;
+      errorCallbackURL?: string | undefined;
+      disableRedirect?: boolean | undefined;
+      additionalData?: Record<string, any> | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      url: string;
+      redirect: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    listAccounts: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: Record<string, any> | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      id: string;
+      providerId: string;
+      createdAt: Date;
+      updatedAt: Date;
+      accountId: string;
+      userId: string;
+      scopes: string[];
+    }[], {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    deleteUser: {
+      callback: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<{
+        token: string;
+        callbackURL?: string | undefined;
+      }> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+        query: {
+          token: string;
+          callbackURL?: string | undefined;
+        };
+        fetchOptions?: FetchOptions | undefined;
+      }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+        success: boolean;
+        message: string;
+      }, {
+        code?: string | undefined;
+        message?: string | undefined;
+      }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+  } & {
+    unlinkAccount: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      providerId: string;
+      accountId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      providerId: string;
+      accountId?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      status: boolean;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    refreshToken: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      providerId: string;
+      accountId?: string | undefined;
+      userId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      providerId: string;
+      accountId?: string | undefined;
+      userId?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      accessToken: string | undefined;
+      refreshToken: string | undefined;
+      accessTokenExpiresAt: Date | undefined;
+      refreshTokenExpiresAt: Date | undefined;
+      scope: string | null | undefined;
+      idToken: string | null | undefined;
+      providerId: string;
+      accountId: string;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    getAccessToken: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
+      providerId: string;
+      accountId?: string | undefined;
+      userId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: better_auth_react0.Prettify<{
+      providerId: string;
+      accountId?: string | undefined;
+      userId?: string | undefined;
+    } & {
+      fetchOptions?: FetchOptions | undefined;
+    }>, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      accessToken: string;
+      accessTokenExpiresAt: Date | undefined;
+      scopes: string[];
+      idToken: string | undefined;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    accountInfo: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<{
+      accountId?: string | undefined;
+    }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: {
+        accountId?: string | undefined;
+      } | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      user: better_auth0.OAuth2UserInfo;
+      data: Record<string, any>;
+    }, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    getSession: <FetchOptions extends better_auth0.ClientFetchOption<never, Partial<{
+      disableCookieCache?: unknown;
+      disableRefresh?: unknown;
+    }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: better_auth_react0.Prettify<{
+      query?: {
+        disableCookieCache?: unknown;
+        disableRefresh?: unknown;
+      } | undefined;
+      fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<_better_fetch_fetch0.BetterFetchResponse<{
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      };
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      };
+    } | null, {
+      code?: string | undefined;
+      message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+  } & {
+    useSession: () => {
+      data: {
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+      } | null;
+      isPending: boolean;
+      isRefetching: boolean;
+      error: _better_fetch_fetch0.BetterFetchError | null;
+      refetch: (queryParams?: {
+        query?: better_auth0.SessionQueryParams;
+      } | undefined) => Promise<void>;
+    };
+    $Infer: {
+      Session: {
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+      };
+    };
+    $fetch: _better_fetch_fetch0.BetterFetch<{
+      plugins: (_better_fetch_fetch0.BetterFetchPlugin | {
+        id: string;
+        name: string;
+        hooks: {
+          onSuccess(context: _better_fetch_fetch0.SuccessContext<any>): void;
+        };
+      } | {
+        id: string;
+        name: string;
+        hooks: {
+          onRequest<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>): void;
+        };
+      } | {
+        id: string;
+        name: string;
+        hooks: {
+          onSuccess: ((context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
+          onError: ((context: _better_fetch_fetch0.ErrorContext) => Promise<void> | void) | undefined;
+          onRequest: (<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>) => Promise<_better_fetch_fetch0.RequestContext | void> | _better_fetch_fetch0.RequestContext | void) | undefined;
+          onResponse: ((context: _better_fetch_fetch0.ResponseContext) => Promise<Response | void | _better_fetch_fetch0.ResponseContext> | Response | _better_fetch_fetch0.ResponseContext | void) | undefined;
+        };
+      })[];
+      cache?: RequestCache | undefined;
+      method: string;
+      headers?: (HeadersInit & (HeadersInit | {
+        accept: "application/json" | "text/plain" | "application/octet-stream";
+        "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+        authorization: "Bearer" | "Basic";
+      })) | undefined;
+      redirect?: RequestRedirect | undefined;
+      credentials?: RequestCredentials;
+      integrity?: string | undefined;
+      keepalive?: boolean | undefined;
+      mode?: RequestMode | undefined;
+      priority?: RequestPriority | undefined;
+      referrer?: string | undefined;
+      referrerPolicy?: ReferrerPolicy | undefined;
+      signal?: (AbortSignal | null) | undefined;
+      window?: null | undefined;
+      onRetry?: ((response: _better_fetch_fetch0.ResponseContext) => Promise<void> | void) | undefined;
+      hookOptions?: {
+        cloneResponse?: boolean;
+      } | undefined;
+      timeout?: number | undefined;
+      customFetchImpl: _better_fetch_fetch0.FetchEsque;
+      baseURL: string;
+      throw?: boolean | undefined;
+      auth?: ({
+        type: "Bearer";
+        token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+      } | {
+        type: "Basic";
+        username: string | (() => string | undefined) | undefined;
+        password: string | (() => string | undefined) | undefined;
+      } | {
+        type: "Custom";
+        prefix: string | (() => string | undefined) | undefined;
+        value: string | (() => string | undefined) | undefined;
+      }) | undefined;
+      body?: any;
+      query?: any;
+      params?: any;
+      duplex?: "full" | "half" | undefined;
+      jsonParser: (text: string) => Promise<any> | any;
+      retry?: _better_fetch_fetch0.RetryOptions | undefined;
+      retryAttempt?: number | undefined;
+      output?: (_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+      errorSchema?: _better_fetch_fetch0.StandardSchemaV1 | undefined;
+      disableValidation?: boolean | undefined;
+      disableSignal?: boolean | undefined;
+    }, unknown, unknown, {}>;
+    $store: {
+      notify: (signal?: (Omit<string, "$sessionSignal"> | "$sessionSignal") | undefined) => void;
+      listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+      atoms: Record<string, nanostores0.WritableAtom<any>>;
+    };
+    $ERROR_CODES: {
+      readonly USER_NOT_FOUND: "User not found";
+      readonly FAILED_TO_CREATE_USER: "Failed to create user";
+      readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+      readonly FAILED_TO_UPDATE_USER: "Failed to update user";
+      readonly FAILED_TO_GET_SESSION: "Failed to get session";
+      readonly INVALID_PASSWORD: "Invalid password";
+      readonly INVALID_EMAIL: "Invalid email";
+      readonly INVALID_EMAIL_OR_PASSWORD: "Invalid email or password";
+      readonly SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked";
+      readonly PROVIDER_NOT_FOUND: "Provider not found";
+      readonly INVALID_TOKEN: "Invalid token";
+      readonly ID_TOKEN_NOT_SUPPORTED: "id_token not supported";
+      readonly FAILED_TO_GET_USER_INFO: "Failed to get user info";
+      readonly USER_EMAIL_NOT_FOUND: "User email not found";
+      readonly EMAIL_NOT_VERIFIED: "Email not verified";
+      readonly PASSWORD_TOO_SHORT: "Password too short";
+      readonly PASSWORD_TOO_LONG: "Password too long";
+      readonly USER_ALREADY_EXISTS: "User already exists.";
+      readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+      readonly EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated";
+      readonly CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found";
+      readonly SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.";
+      readonly FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account";
+      readonly ACCOUNT_NOT_FOUND: "Account not found";
+      readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
+    };
+  };
+  getJWTToken(): Promise<string | null>;
+}
+//#endregion
+//#region ../neon-auth/src/adapters/better-auth-vanilla/better-auth-vanilla-adapter.d.ts
+type BetterAuthVanillaAdapterOptions = NeonAuthAdapterCoreAuthOptions;
+declare class BetterAuthVanillaAdapter extends NeonAuthAdapterCore {
+  private _betterAuth;
+  constructor(betterAuthClientOptions: BetterAuthVanillaAdapterOptions);
+  getBetterAuthInstance(): AuthClient<BetterAuthClientOptions>;
+  getJWTToken(): Promise<string | null>;
+}
+//#endregion
+//#region ../neon-auth/src/adapters/supabase/auth-interface.d.ts
+type _UpstreamAuthClientInstance = InstanceType<typeof AuthClient$1>;
+type _AuthClientBase = { [K in keyof _UpstreamAuthClientInstance as _UpstreamAuthClientInstance[K] extends never ? never : K]: _UpstreamAuthClientInstance[K] };
+type SupabaseAuthClientInterface = _AuthClientBase;
+//#endregion
+//#region ../neon-auth/src/adapters/supabase/supabase-adapter.d.ts
+type SupabaseAuthAdapterOptions = NeonAuthAdapterCoreAuthOptions;
+declare class SupabaseAuthAdapter extends NeonAuthAdapterCore implements SupabaseAuthClientInterface {
+  admin: SupabaseAuthClientInterface['admin'];
+  mfa: SupabaseAuthClientInterface['mfa'];
+  oauth: SupabaseAuthClientInterface['oauth'];
+  private _betterAuth;
+  private _stateChangeEmitters;
+  constructor(betterAuthClientOptions: SupabaseAuthAdapterOptions);
+  getBetterAuthInstance(): AuthClient<BetterAuthClientOptions>;
+  getJWTToken(): Promise<string | null>;
+  initialize: SupabaseAuthClientInterface['initialize'];
+  getSession(options?: {
+    forceFetch?: boolean;
+  }): ReturnType<SupabaseAuthClientInterface['getSession']>;
+  refreshSession: SupabaseAuthClientInterface['refreshSession'];
+  setSession: SupabaseAuthClientInterface['setSession'];
+  signUp: SupabaseAuthClientInterface['signUp'];
+  signInAnonymously: SupabaseAuthClientInterface['signInAnonymously'];
+  signInWithPassword: SupabaseAuthClientInterface['signInWithPassword'];
+  signInWithOAuth: SupabaseAuthClientInterface['signInWithOAuth'];
+  signInWithOtp: SupabaseAuthClientInterface['signInWithOtp'];
+  signInWithIdToken: SupabaseAuthClientInterface['signInWithIdToken'];
+  signInWithSSO: SupabaseAuthClientInterface['signInWithSSO'];
+  signInWithWeb3: SupabaseAuthClientInterface['signInWithWeb3'];
+  signOut: SupabaseAuthClientInterface['signOut'];
+  getUser: SupabaseAuthClientInterface['getUser'];
+  getClaims: (jwtArg?: string) => Promise<{
+    data: {
+      header: JwtHeader;
+      claims: JwtPayload;
+      signature: Uint8Array<ArrayBufferLike>;
+    };
+    error: null;
+  } | {
+    data: null;
+    error: _supabase_auth_js0.AuthError;
+  }>;
+  updateUser: SupabaseAuthClientInterface['updateUser'];
+  getUserIdentities: SupabaseAuthClientInterface['getUserIdentities'];
+  linkIdentity: SupabaseAuthClientInterface['linkIdentity'];
+  unlinkIdentity: SupabaseAuthClientInterface['unlinkIdentity'];
+  verifyOtp: SupabaseAuthClientInterface['verifyOtp'];
+  resetPasswordForEmail: SupabaseAuthClientInterface['resetPasswordForEmail'];
+  reauthenticate: SupabaseAuthClientInterface['reauthenticate'];
+  resend: SupabaseAuthClientInterface['resend'];
+  exchangeCodeForSession: SupabaseAuthClientInterface['exchangeCodeForSession'];
+  onAuthStateChange: SupabaseAuthClientInterface['onAuthStateChange'];
+  isThrowOnErrorEnabled: SupabaseAuthClientInterface['isThrowOnErrorEnabled'];
+  startAutoRefresh: SupabaseAuthClientInterface['startAutoRefresh'];
+  stopAutoRefresh: SupabaseAuthClientInterface['stopAutoRefresh'];
+  private verifyEmailOtp;
+  private verifyPhoneOtp;
+  private emitInitialSession;
+}
+//#endregion
+//#region ../neon-auth/src/neon-auth.d.ts
+/**
+ * Type representing the Better Auth React client
+ */
+type ReactBetterAuthClient = ReturnType<typeof createAuthClient>;
+/**
+ * Type representing the Better Auth Vanilla client
+ */
+type VanillaBetterAuthClient = ReturnType<typeof createAuthClient$1>;
+/**
+ * Union type of all supported auth adapter CLASSES (not instances)
+ * Use this when you need to pass an adapter class as a parameter
+ */
+type NeonAuthAdapterClass = typeof BetterAuthVanillaAdapter | typeof BetterAuthReactAdapter | typeof SupabaseAuthAdapter;
+/**
+ * Union type of all supported auth adapter instances
+ */
+type NeonAuthAdapter = BetterAuthVanillaAdapter | BetterAuthReactAdapter | SupabaseAuthAdapter;
+/**
+ * Configuration for createNeonAuth
+ * T is the adapter CLASS type (typeof SupabaseAuthAdapter), not the instance type
+ */
+interface NeonAuthConfig<T extends NeonAuthAdapterClass> {
+  /** The adapter class to use (e.g., SupabaseAuthAdapter, BetterAuthVanillaAdapter) */
+  adapter: T;
+  /** Additional options to pass to the adapter (baseURL is auto-injected) */
+  options?: Omit<ConstructorParameters<T>[0], 'baseURL'>;
+}
+/**
+ * Resolves the public API type for an adapter.
+ * - SupabaseAuthAdapter: exposes its own methods directly (Supabase-compatible API)
+ * - BetterAuth adapters: expose the Better Auth client directly
+ */
+type NeonAuthPublicApi<T extends NeonAuthAdapter> = T extends BetterAuthVanillaAdapter ? VanillaBetterAuthClient : T extends BetterAuthReactAdapter ? ReactBetterAuthClient : T;
+/**
+ * NeonAuth type - combines base functionality with the appropriate public API
+ * This is the return type of createNeonAuth()
+ *
+ * For SupabaseAuthAdapter: exposes Supabase-compatible methods (signInWithPassword, getSession, etc.)
+ * For BetterAuth adapters: exposes the Better Auth client directly (signIn.email, signUp.email, etc.)
+ */
+type NeonAuth<T extends NeonAuthAdapter> = {
+  adapter: NeonAuthPublicApi<T>;
+  getJWTToken: () => Promise<string | null>;
+};
+/**
+ * Create a NeonAuth instance that exposes the appropriate API based on the adapter.
+ *
+ * @param url - The auth service URL (e.g., 'https://auth.example.com')
+ * @param config - Configuration with adapter class and optional adapter-specific options
+ * @returns NeonAuth instance with the adapter's API exposed directly
+ *
+ * @example SupabaseAuthAdapter - Supabase-compatible API
+ * ```typescript
+ * import { createNeonAuth, SupabaseAuthAdapter } from '@neondatabase/neon-auth';
+ *
+ * const auth = createNeonAuth('https://auth.example.com', {
+ *   adapter: SupabaseAuthAdapter,
+ * });
+ *
+ * // Supabase-compatible methods
+ * await auth.signInWithPassword({ email, password });
+ * await auth.getSession();
+ * ```
+ *
+ * @example BetterAuthVanillaAdapter - Direct Better Auth API
+ * ```typescript
+ * import { createNeonAuth, BetterAuthVanillaAdapter } from '@neondatabase/neon-auth';
+ *
+ * const auth = createNeonAuth('https://auth.example.com', {
+ *   adapter: BetterAuthVanillaAdapter,
+ * });
+ *
+ * // Direct Better Auth API access
+ * await auth.signIn.email({ email, password });
+ * await auth.signUp.email({ email, password, name: 'John' });
+ * await auth.getSession();
+ * ```
+ *
+ * @example BetterAuthReactAdapter - Better Auth with React hooks
+ * ```typescript
+ * import { createNeonAuth, BetterAuthReactAdapter } from '@neondatabase/neon-auth';
+ *
+ * const auth = createNeonAuth('https://auth.example.com', {
+ *   adapter: BetterAuthReactAdapter,
+ * });
+ *
+ * // Direct Better Auth API with React hooks
+ * await auth.signIn.email({ email, password });
+ * const session = auth.useSession(); // React hook
+ * ```
+ */
+declare function createInternalNeonAuth<T extends NeonAuthAdapterClass>(url: string, config: NeonAuthConfig<T>): NeonAuth<InstanceType<T>>;
+declare function createNeonAuth<T extends NeonAuthAdapterClass>(url: string, config: NeonAuthConfig<T>): NeonAuthPublicApi<InstanceType<T>>;
+//#endregion
+//#region ../neon-auth/src/utils/jwt.d.ts
+/**
+ * Extract expiration timestamp from JWT payload
+ * @param jwt - The JWT token string
+ * @returns Expiration timestamp in seconds (Unix time) or null if invalid
+ */
+declare function getJwtExpiration(jwt: string): number | null;
+/**
+ * Extract expiration timestamp from JWT payload in milliseconds
+ * @param jwt - The JWT token string
+ * @returns Expiration timestamp in milliseconds or null if invalid
+ */
+declare function getJwtExpirationMs(jwt: string): number | null;
+//#endregion
+//#region ../postgrest-js/src/client/postgrest-client.d.ts
+type NeonPostgrestClientConstructorOptions<SchemaName> = {
+  dataApiUrl: string;
+  options?: {
+    db?: {
+      schema?: Exclude<SchemaName, '__InternalSupabase'>;
+    };
+    global?: {
+      fetch: typeof fetch;
+      headers?: Record<string, string>;
+    };
+  };
+};
+type DefaultSchemaName<Database> = 'public' extends keyof Database ? 'public' : string & keyof Database;
+/**
+ * Neon PostgreSQL client for querying the Neon Data API
+ *
+ * This is a generic PostgreSQL client without authentication built-in.
+ * For auth-integrated clients, use @neondatabase/neon-js instead.
+ *
+ * Extends the upstream PostgrestClient with Neon-specific configuration.
+ */
+declare class NeonPostgrestClient<Database = any, SchemaName extends string & keyof Database = DefaultSchemaName<Database>> extends PostgrestClient<Database, {
+  PostgrestVersion: '12';
+}, Exclude<SchemaName, '__InternalSupabase'>> {
+  constructor({
+    dataApiUrl,
+    options
+  }: NeonPostgrestClientConstructorOptions<SchemaName>);
+}
+//#endregion
+//#region src/client/neon-client.d.ts
+type NeonClientConstructorOptions<SchemaName, TAuth extends NeonAuthAdapter = NeonAuthAdapter> = NeonPostgrestClientConstructorOptions<SchemaName> & {
+  authClient: NeonAuth<TAuth>;
+};
+/**
+ * Neon client with integrated authentication
+ *
+ * Extends NeonPostgrestClient with Neon Auth integration.
+ * For auth-free clients, use @neondatabase/postgrest-js instead.
+ */
+declare class NeonClient<Database = any, SchemaName extends string & keyof Database = DefaultSchemaName<Database>, TAuth extends NeonAuthAdapter = NeonAuthAdapter> extends NeonPostgrestClient<Database, SchemaName> {
+  auth: NeonAuthPublicApi<TAuth>;
+  constructor({
+    dataApiUrl,
+    options,
+    authClient
+  }: NeonClientConstructorOptions<SchemaName, TAuth>);
+}
+//#endregion
+//#region src/client/client-factory.d.ts
+/**
+ * Auth configuration for createClient
+ */
+type CreateClientAuthConfig<T extends NeonAuthAdapterClass> = {
+  /** The adapter class to use (e.g., SupabaseAuthAdapter, BetterAuthVanillaAdapter) */
+  adapter: T;
+  /** The auth service URL */
+  url: string;
+  /** Additional auth options (baseURL is set from url above) */
+  options?: Omit<ConstructorParameters<T>[0], 'baseURL'>;
+};
+/**
+ * Data API configuration for createClient
+ */
+type CreateClientDataApiConfig<SchemaName, TAuth extends NeonAuthAdapter> = {
+  /** The Data API URL */
+  url: string;
+  /** Additional client options */
+  options?: Omit<NeonClientConstructorOptions<SchemaName, TAuth>, 'dataApiUrl' | 'authClient'>['options'];
+};
+/**
+ * Configuration for createClient
+ */
+type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
+  /** Auth service configuration */
+  auth: CreateClientAuthConfig<T>;
+  /** Data API configuration */
+  dataApi: CreateClientDataApiConfig<SchemaName, InstanceType<T>>;
+};
+/**
+ * Factory function to create NeonClient with seamless auth integration.
+ *
+ * @param config - Configuration with auth and dataApi sections
+ * @returns NeonClient instance with auth-aware fetch wrapper
+ * @throws AuthRequiredError when making requests without authentication
+ *
+ * @example
+ * ```typescript
+ * import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
+ *
+ * const client = createClient({
+ *   auth: {
+ *     adapter: SupabaseAuthAdapter,
+ *     url: 'https://auth.example.com',
+ *   },
+ *   dataApi: {
+ *     url: 'https://data-api.example.com/rest/v1',
+ *   },
+ * });
+ *
+ * // Auth methods (API depends on adapter)
+ * await client.auth.signInWithPassword({ email, password });
+ *
+ * // Database queries (automatic token injection)
+ * const { data: items } = await client.from('items').select();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { createClient, BetterAuthVanillaAdapter } from '@neondatabase/neon-js';
+ *
+ * const client = createClient({
+ *   auth: {
+ *     adapter: BetterAuthVanillaAdapter,
+ *     url: 'https://auth.example.com',
+ *   },
+ *   dataApi: {
+ *     url: 'https://data-api.example.com/rest/v1',
+ *   },
+ * });
+ *
+ * // Access raw Better Auth client
+ * const betterAuth = client.auth.getBetterAuthInstance();
+ * await betterAuth.signIn.email({ email, password });
+ * ```
+ */
+/**
+ * Helper type to create NeonClient with proper schema resolution.
+ * Uses 'public' as the default schema since it's the most common case.
+ */
+type CreateClientResult<Database, TAdapter extends NeonAuthAdapter> = NeonClient<Database, DefaultSchemaName<Database>, TAdapter>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof SupabaseAuthAdapter>): CreateClientResult<Database, SupabaseAuthAdapter>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof BetterAuthVanillaAdapter>): CreateClientResult<Database, BetterAuthVanillaAdapter>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof BetterAuthReactAdapter>): CreateClientResult<Database, BetterAuthReactAdapter>;
+//#endregion
+export { AuthApiError, AuthError, BetterAuthReactAdapter, BetterAuthVanillaAdapter, type NeonAuth, type NeonAuthAdapter, type NeonAuthAdapterClass, type NeonAuthConfig, type NeonAuthPublicApi, type ReactBetterAuthClient, type Session, SupabaseAuthAdapter, type SupabaseAuthAdapterOptions, type User, type VanillaBetterAuthClient, createClient, createInternalNeonAuth, createNeonAuth, getJwtExpiration, getJwtExpirationMs, isAuthError, useBetterAuthStore };