@auth/qwik

new AuthError(message?, errorOptions?): AuthError

optional cause: Record<string, unknown> & {
  err: Error;
};

optional err: Error;

message: string;

name: string;

optional stack: string;

type: ErrorType;

static optional prepareStackTrace: (err, stackTraces) => any;

static stackTraceLimit: number;

static captureStackTrace(targetObject, constructorOpt?): void

new CredentialsSignin(message?, errorOptions?): CredentialsSignin

optional cause: Record<string, unknown> & {
  err: Error;
};

optional err: Error;

code: string;

message: string;

name: string;

optional stack: string;

type: ErrorType;

static kind: string;

static optional prepareStackTrace: (err, stackTraces) => any;

static stackTraceLimit: number;

static type: string;

static captureStackTrace(targetObject, constructorOpt?): void

optional readonly access_token: string;

optional readonly authorization_details: AuthorizationDetails[];

optional expires_at: number;

optional readonly expires_in: number;

optional readonly id_token: string;

provider: string;

providerAccountId: string;

optional readonly refresh_token: string;

optional readonly scope: string;

optional readonly token_type: Lowercase<string>;

type: ProviderType;

optional userId: string;

expires: string;

optional user: User;

optional address: null | {
  country: null | string;
  formatted: null | string;
  locality: null | string;
  postal_code: null | string;
  region: null | string;
  street_address: null | string;
};

optional birthdate: null | string;

optional email: null | string;

optional email_verified: null | boolean;

optional family_name: null | string;

optional gender: null | string;

optional given_name: null | string;

optional id: null | string;

optional locale: null | string;

optional middle_name: null | string;

optional name: null | string;

optional nickname: null | string;

optional phone_number: null | string;

optional picture: any;

optional preferred_username: null | string;

optional profile: null | string;

optional sub: null | string;

optional updated_at: null | string | number | Date;

optional website: null | string;

optional zoneinfo: null | string;

optional adapter: Adapter;

optional basePath: string;

"/api/auth" in "next-auth"; "/auth" with all other frameworks

optional callbacks: {
  jwt: (params) => Awaitable<null | JWT>;
  redirect: (params) => Awaitable<string>;
  session: (params) => Awaitable<Session | DefaultSession>;
  signIn: (params) => Awaitable<string | boolean>;
};

optional jwt: (params) => Awaitable<null | JWT>;

optional redirect: (params) => Awaitable<string>;

callbacks: {
  async redirect({ url, baseUrl }) {
    // Allows relative callback URLs
    if (url.startsWith("/")) return `${baseUrl}${url}`
 
    // Allows callback URLs on the same origin
    if (new URL(url).origin === baseUrl) return url
 
    return baseUrl
  }
}

optional session: (params) => Awaitable<Session | DefaultSession>;

callbacks: {
  async session({ session, token, user }) {
    // Send properties to the client, like an access_token from a provider.
    session.accessToken = token.accessToken
 
    return session
  }
}

optional signIn: (params) => Awaitable<string | boolean>;

callbacks: {
 async signIn({ profile }) {
  // Only allow sign in for users with email addresses ending with "yourdomain.com"
  return profile?.email?.endsWith("@yourdomain.com")
}

optional cookies: Partial<CookiesOptions>;

{}

optional debug: boolean;

false

optional events: {
  createUser: (message) => Awaitable<void>;
  linkAccount: (message) => Awaitable<void>;
  session: (message) => Awaitable<void>;
  signIn: (message) => Awaitable<void>;
  signOut: (message) => Awaitable<void>;
  updateUser: (message) => Awaitable<void>;
};

{}

optional createUser: (message) => Awaitable<void>;

optional linkAccount: (message) => Awaitable<void>;

optional session: (message) => Awaitable<void>;

optional signIn: (message) => Awaitable<void>;

optional signOut: (message) => Awaitable<void>;

optional updateUser: (message) => Awaitable<void>;

optional experimental: {
  enableWebAuthn: boolean;
};

{}

optional enableWebAuthn: boolean;

false

optional jwt: Partial<JWTOptions>;

optional logger: Partial<LoggerInstance>;

// /auth.ts
import log from "logging-service"
 
export const { handlers, auth, signIn, signOut } = NextAuth({
  logger: {
    error(code, ...message) {
      log.error(code, message)
    },
    warn(code, ...message) {
      log.warn(code, message)
    },
    debug(code, ...message) {
      log.debug(code, message)
    }
  }
})

console

optional pages: Partial<PagesOptions>;

{}

  pages: {
    signIn: '/auth/signin',
    signOut: '/auth/signout',
    error: '/auth/error',
    verifyRequest: '/auth/verify-request',
    newUser: '/auth/new-user'
  }

providers: Provider[];

[]

optional redirectProxyUrl: string;

"https://authjs.example.com/api/auth"

GitHub({
  ...
  redirectProxyUrl: "https://github.example.com/api/auth"
})

optional secret: string | string[];

optional session: {
  generateSessionToken: () => string;
  maxAge: number;
  strategy: "jwt" | "database";
  updateAge: number;
};

optional generateSessionToken: () => string;

optional maxAge: number;

2592000 // 30 days

optional strategy: "jwt" | "database";

optional updateAge: number;

86400 // 1 day

optional skipCSRFCheck: typeof skipCSRFCheck;

optional theme: Theme;

optional trustHost: boolean;

optional useSecureCookies: boolean;

expires: string;

optional user: User;

optional email: null | string;

optional id: string;

optional image: null | string;

optional name: null | string;

type GetSessionResult: Promise<{
  cookie: any;
  data: Session | null;
}>;

cookie: any;

data: Session | null;

const customFetch: unique symbol;

import { Auth, customFetch } from "@auth/core"
import GitHub from "@auth/core/providers/github"
 
const dispatcher = new ProxyAgent("my.proxy.server")
function proxy(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {
  return undici(args[0], { ...(args[1] ?? {}), dispatcher })
}
 
const response = await Auth(request, {
  providers: [GitHub({ [customFetch]: proxy })]
})

QwikAuth$(qrl, ...rest): {
  onRequest: (req) => Promise<void>;
  useSession: Loader_2<null | Session>;
  useSignIn: Action<{
     failed: undefined;
     fieldErrors: undefined;
     formErrors: undefined;
     } | {
     failed: true;
     fieldErrors: {
        authorizationParams: undefined | string[];
        options: undefined | string[];
        providerId: undefined | string[];
        redirectTo: undefined | string[];
     };
     formErrors: string[];
     }, {
     authorizationParams: string | URLSearchParams | Record<string, string>;
     options: objectOutputType<{
        redirectTo: ZodOptional<ZodString>;
     }, ZodTypeAny, "passthrough">;
     providerId: string;
     redirectTo: string;
  }, false>;
  useSignOut: Action<{
     failed: undefined;
     fieldErrors: undefined;
     formErrors: undefined;
     } | {
     failed: true;
     fieldErrors: {
        redirectTo: undefined | string[];
     };
     formErrors: string[];
     }, {
     redirectTo: string;
  }, false>;
}

{
  onRequest: (req) => Promise<void>;
  useSession: Loader_2<null | Session>;
  useSignIn: Action<{
     failed: undefined;
     fieldErrors: undefined;
     formErrors: undefined;
     } | {
     failed: true;
     fieldErrors: {
        authorizationParams: undefined | string[];
        options: undefined | string[];
        providerId: undefined | string[];
        redirectTo: undefined | string[];
     };
     formErrors: string[];
     }, {
     authorizationParams: string | URLSearchParams | Record<string, string>;
     options: objectOutputType<{
        redirectTo: ZodOptional<ZodString>;
     }, ZodTypeAny, "passthrough">;
     providerId: string;
     redirectTo: string;
  }, false>;
  useSignOut: Action<{
     failed: undefined;
     fieldErrors: undefined;
     formErrors: undefined;
     } | {
     failed: true;
     fieldErrors: {
        redirectTo: undefined | string[];
     };
     formErrors: string[];
     }, {
     redirectTo: string;
  }, false>;
}

onRequest: (req) => Promise<void>;

useSession: Loader_2<null | Session>;

useSignIn: Action<{
  failed: undefined;
  fieldErrors: undefined;
  formErrors: undefined;
  } | {
  failed: true;
  fieldErrors: {
     authorizationParams: undefined | string[];
     options: undefined | string[];
     providerId: undefined | string[];
     redirectTo: undefined | string[];
  };
  formErrors: string[];
  }, {
  authorizationParams: string | URLSearchParams | Record<string, string>;
  options: objectOutputType<{
     redirectTo: ZodOptional<ZodString>;
  }, ZodTypeAny, "passthrough">;
  providerId: string;
  redirectTo: string;
}, false>;

useSignOut: Action<{
  failed: undefined;
  fieldErrors: undefined;
  formErrors: undefined;
  } | {
  failed: true;
  fieldErrors: {
     redirectTo: undefined | string[];
  };
  formErrors: string[];
  }, {
  redirectTo: string;
}, false>;

import { QwikAuth } from "@auth/qwik"
import GitHub from "@auth/qwik/providers/github"
 
export const {
  onRequest, useSession, useSignIn, useSignOut
} = QwikAuth$(() => ({ providers: [GitHub] }))

setEnvDefaults(env, config): void