@absolutejs/auth 0.22.4 → 0.22.5

package/dist/src/oauthLinkedProviderResolver.d.ts

@@ -0,0 +1,9 @@
+import type { LinkedProviderBindingStore, LinkedProviderGrantStore } from '@absolutejs/linked-providers';
+import type { OAuth2ConfigurationOptions } from './types';
+export type CreateOAuthLinkedProviderCredentialResolverOptions = {
+    grantStore: LinkedProviderGrantStore;
+    bindingStore: LinkedProviderBindingStore;
+    providersConfiguration: OAuth2ConfigurationOptions;
+    now?: () => number;
+};
+export declare const createOAuthLinkedProviderCredentialResolver: ({ bindingStore, grantStore, now, providersConfiguration }: CreateOAuthLinkedProviderCredentialResolverOptions) => Promise<import("@absolutejs/linked-providers").LinkedProviderCredentialResolver>;

package/dist/src/profile.d.ts

@@ -34,7 +34,7 @@ export declare const profile: <UserType>({ clientProviders, profileRoute, onProf
             response: {
                 200: Response;
                 400: "Cookies are missing";
-                401: "Client provider not found" | "No auth provider found" | "Invalid provider" | "No user session found";
+                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "Invalid provider" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/src/protectRoute.d.ts

@@ -1,10 +1,15 @@
 import { Elysia } from 'elysia';
-import { getStatus } from './utils';
-type AuthFailError = Exclude<Awaited<ReturnType<typeof getStatus>>['error'], null> | {
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
+type AuthFailError = {
+    readonly code: 'Bad Request';
+    readonly message: 'Cookies are missing';
+} | {
     readonly code: 'Unauthorized';
     readonly message: 'User is not authenticated';
 };
-export declare const protectRoutePlugin: <UserType>() => Elysia<"", {
+export declare const protectRoutePlugin: <UserType>({ authSessionStore }?: {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+}) => Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType>;

package/dist/src/providerClients.d.ts

@@ -0,0 +1,41 @@
+import { CredentialsFor, OAuth2Client, ProviderOption } from 'citra';
+import { OAuth2ConfigurationOptions, OAuth2ProviderClientConfiguration, ClientProviderEntry, ClientProviderGroup } from './types';
+export declare const normalizeProvidersConfiguration: (providersConfiguration: OAuth2ConfigurationOptions) => Record<ProviderOption, Record<string, OAuth2ProviderClientConfiguration<ProviderOption>>>;
+export declare const resolveProviderClientConfiguration: ({ clientName, providerName, providersConfiguration }: {
+    providerName: ProviderOption;
+    clientName?: string;
+    providersConfiguration: OAuth2ConfigurationOptions;
+}) => {
+    error: "Client provider not found";
+    config?: undefined;
+} | {
+    config: OAuth2ProviderClientConfiguration<"42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom"> | undefined;
+    error?: undefined;
+} | {
+    error: "Client variant is required";
+    config?: undefined;
+} | {
+    error: "Client variant not found";
+    config?: undefined;
+};
+export declare const buildClientProviders: (providersConfiguration: OAuth2ConfigurationOptions, createOAuth2ClientFn: <P extends ProviderOption>(providerName: P, config: CredentialsFor<P>) => Promise<OAuth2Client<P>>) => Promise<Record<string, ClientProviderGroup>>;
+export declare const resolveClientProviderEntry: ({ clientName, clientProviders, providerName }: {
+    providerName: string | undefined;
+    clientName?: string;
+    clientProviders: Record<string, ClientProviderGroup>;
+}) => {
+    error: "Provider is required";
+    entry?: undefined;
+} | {
+    error: "Client provider not found";
+    entry?: undefined;
+} | {
+    entry: ClientProviderEntry;
+    error?: undefined;
+} | {
+    error: "Client variant is required";
+    entry?: undefined;
+} | {
+    error: "Client variant not found";
+    entry?: undefined;
+};

package/dist/src/refresh.d.ts

@@ -1,13 +1,15 @@
 import { Elysia } from 'elysia';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
 import { ClientProviders, OnRefreshError, OnRefreshSuccess, RouteString } from './types';
-type RefreshProps = {
+type RefreshProps<UserType> = {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     clientProviders: ClientProviders;
     refreshRoute?: RouteString;
     onRefreshSuccess: OnRefreshSuccess;
     onRefreshError: OnRefreshError;
     sessionDurationMs?: number;
 };
-export declare const refresh: <UserType>({ clientProviders, refreshRoute, onRefreshSuccess, onRefreshError, sessionDurationMs }: RefreshProps) => Elysia<"", {
+export declare const refresh: <UserType>({ authSessionStore, clientProviders, refreshRoute, onRefreshSuccess, onRefreshError, sessionDurationMs }: RefreshProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType>;
@@ -35,7 +37,7 @@ export declare const refresh: <UserType>({ clientProviders, refreshRoute, onRefr
             response: {
                 200: Response;
                 400: "Cookies are missing" | "Invalid provider" | "No refresh token found";
-                401: "Client provider not found" | "No auth provider found" | "No user session found";
+                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/src/revoke.d.ts

@@ -1,12 +1,14 @@
 import { Elysia } from 'elysia';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
 import { ClientProviders, OnRevocationError, OnRevocationSuccess, RouteString } from './types';
-type RevokeProps = {
+type RevokeProps<UserType> = {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     clientProviders: ClientProviders;
     revokeRoute?: RouteString;
     onRevocationSuccess: OnRevocationSuccess;
     onRevocationError: OnRevocationError;
 };
-export declare const revoke: <UserType>({ clientProviders, revokeRoute, onRevocationSuccess, onRevocationError }: RevokeProps) => Elysia<"", {
+export declare const revoke: <UserType>({ authSessionStore, clientProviders, revokeRoute, onRevocationSuccess, onRevocationError }: RevokeProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType>;
@@ -34,7 +36,7 @@ export declare const revoke: <UserType>({ clientProviders, revokeRoute, onRevoca
             response: {
                 200: Response;
                 400: "Cookies are missing" | "Invalid provider";
-                401: "Client provider not found" | "No auth provider found" | "No user session found";
+                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/src/sessionAccess.d.ts

@@ -0,0 +1,31 @@
+import type { Cookie } from 'elysia';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
+import type { SessionData, SessionRecord, UnregisteredSessionRecord, UserSessionId } from './types';
+export declare const loadSessionFromSource: <UserType>({ authSessionStore, session, userSessionId, removeExpired }: {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+    session?: SessionRecord<UserType>;
+    userSessionId?: UserSessionId;
+    removeExpired?: boolean;
+}) => Promise<SessionData<UserType> | undefined>;
+export declare const getStatusFromSource: <UserType>({ authSessionStore, session, user_session_id }: {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+    session?: SessionRecord<UserType>;
+    user_session_id: Cookie<UserSessionId | undefined>;
+}) => Promise<{
+    error: {
+        readonly code: "Bad Request";
+        readonly message: "Cookies are missing";
+    };
+    user: null;
+} | {
+    error: null;
+    user: NonNullable<UserType> | null;
+}>;
+export declare const createSessionCompatibilityLayer: <UserType>({ authSessionStore, userSessionId }: {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+    userSessionId?: UserSessionId;
+}) => Promise<{
+    session: SessionRecord<UserType>;
+    unregisteredSession: UnregisteredSessionRecord;
+    persist: () => Promise<void>;
+}>;

package/dist/src/sessionCleanup.d.ts

@@ -1,11 +1,13 @@
 import { Elysia } from 'elysia';
-import { OnSessionCleanup, SessionRecord, UnregisteredSessionRecord } from './types';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
+import type { OnSessionCleanup, SessionRecord, UnregisteredSessionRecord } from './types';
 type SessionCleanupProps<UserType> = {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     cleanupIntervalMs?: number;
     maxSessions?: number;
     onSessionCleanup?: OnSessionCleanup<UserType>;
 };
-export declare const sessionCleanup: <UserType>({ cleanupIntervalMs, maxSessions, onSessionCleanup }: SessionCleanupProps<UserType>) => Elysia<"", {
+export declare const sessionCleanup: <UserType>({ authSessionStore, cleanupIntervalMs, maxSessions, onSessionCleanup }: SessionCleanupProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
         session: SessionRecord<UserType>;

package/dist/src/sessionTypes.d.ts

@@ -0,0 +1,11 @@
+import type { SessionData, UnregisteredSessionData, UserSessionId } from './types';
+export type AbsoluteAuthSessionStore<UserType> = {
+    getSession: (id: UserSessionId) => Promise<SessionData<UserType> | undefined>;
+    setSession: (id: UserSessionId, value: SessionData<UserType>) => Promise<void>;
+    removeSession: (id: UserSessionId) => Promise<void>;
+    getUnregisteredSession: (id: UserSessionId) => Promise<UnregisteredSessionData | undefined>;
+    setUnregisteredSession: (id: UserSessionId, value: UnregisteredSessionData) => Promise<void>;
+    removeUnregisteredSession: (id: UserSessionId) => Promise<void>;
+    listSessionIds?: () => Promise<UserSessionId[]>;
+    listUnregisteredSessionIds?: () => Promise<UserSessionId[]>;
+};

package/dist/src/signout.d.ts

@@ -1,10 +1,12 @@
 import { Elysia } from 'elysia';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
 import { OnSignOut, RouteString } from './types';
 type SignOutProps<UserType> = {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     signoutRoute?: RouteString;
     onSignOut: OnSignOut<UserType>;
 };
-export declare const signout: <UserType>({ signoutRoute, onSignOut }: SignOutProps<UserType>) => Elysia<"", {
+export declare const signout: <UserType>({ authSessionStore, signoutRoute, onSignOut }: SignOutProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType>;

package/dist/src/typeGuards.d.ts

@@ -1,5 +1,6 @@
-import { StatusReturn, UserSessionId } from './types';
+import { AuthIntent, StatusReturn, UserSessionId } from './types';
 export declare const isValidUser: <UserType>(user: unknown) => user is UserType;
 export declare const isUserSessionId: (key: string) => key is UserSessionId;
 export declare const isNonEmptyString: (str: string | null | undefined) => str is string;
 export declare const isStatusResponse: (value: unknown) => value is StatusReturn;
+export declare const isAuthIntent: (value: unknown) => value is AuthIntent;

package/dist/src/typebox.d.ts

@@ -2,3 +2,5 @@ export declare const userSessionIdTypebox: import("@sinclair/typebox").TOptional
 export declare const authProviderOption: import("@sinclair/typebox").TEnum<{
     [k: string]: "42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom";
 }>;
+export declare const authClientOption: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+export declare const authIntentOption: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"login">, import("@sinclair/typebox").TLiteral<"link_identity">, import("@sinclair/typebox").TLiteral<"link_connector">]>>;

package/dist/src/types.d.ts

@@ -1,15 +1,20 @@
 import { CredentialsFor, NonEmptyArray, OAuth2Client, OAuth2TokenResponse, ProviderOption, ProvidersMap } from 'citra';
 import { Cookie, status as statusType, redirect as redirectType } from 'elysia';
 import { ElysiaCustomStatusResponse } from 'elysia/error';
+import type { AuthIdentityConflict } from './errors';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
+export type AuthIntent = 'login' | 'link_identity' | 'link_connector';
+export type OAuth2ProviderClientConfiguration<Provider extends ProviderOption> = {
+    credentials: CredentialsFor<Provider>;
+    searchParams?: [string, string][];
+} & (ProvidersMap[Provider]['scopeRequired'] extends true ? {
+    scope: NonEmptyArray<string>;
+} : {
+    scope?: string[];
+});
+export type OAuth2ProviderConfiguration<Provider extends ProviderOption> = OAuth2ProviderClientConfiguration<Provider> | Record<string, OAuth2ProviderClientConfiguration<Provider>>;
 export type OAuth2ConfigurationOptions = {
-    [Provider in ProviderOption]?: {
-        credentials: CredentialsFor<Provider>;
-        searchParams?: [string, string][];
-    } & (ProvidersMap[Provider]['scopeRequired'] extends true ? {
-        scope: NonEmptyArray<string>;
-    } : {
-        scope?: string[];
-    });
+    [Provider in ProviderOption]?: OAuth2ProviderConfiguration<Provider>;
 };
 export type UserSessionId = `${string}-${string}-${string}-${string}-${string}`;
 export type SessionData<UserType> = {
@@ -27,59 +32,95 @@ export type UnregisteredSessionData = {
     refreshToken?: string;
 };
 export type UnregisteredSessionRecord = Record<UserSessionId, UnregisteredSessionData>;
+export type ResolvedOAuthAuthorization = {
+    userIdentity: Record<string, unknown>;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    tokenType?: string;
+};
 export type StatusReturn = ElysiaCustomStatusResponse<any, any, any>;
 export type OnNewUser<UserType> = (userIdentity: Record<string, unknown>) => UserType | StatusReturn | Response | Promise<UserType | StatusReturn | Response>;
 export type GetUser<UserType> = (userIdentity: Record<string, unknown>) => UserType | null | undefined | Promise<UserType | null | undefined>;
 export type CallbackCookie = Record<string, Cookie<unknown>> & {
+    auth_client: Cookie<string | undefined>;
+    auth_intent: Cookie<AuthIntent | undefined>;
     user_session_id: Cookie<UserSessionId | undefined>;
 };
-export type OnCallbackSuccess<UserType> = (({ authProvider, tokenResponse, providerInstance, session, userSessionId, originUrl, cookie, redirect, status }: {
+export type CallbackContext<UserType> = {
     providerInstance: OAuth2Client<ProviderOption>;
     authProvider: ProviderOption;
+    authClient?: string;
+    authIntent: AuthIntent;
     tokenResponse: OAuth2TokenResponse;
     session: SessionRecord<UserType>;
     unregisteredSession: UnregisteredSessionRecord;
     userSessionId: UserSessionId;
     originUrl: string;
     cookie: CallbackCookie;
+    currentUser?: UserType;
     status: typeof statusType;
     redirect: typeof redirectType;
+};
+export type ResolveAuthIntent<UserType> = (({ authProvider, authClient, originUrl, session, userSessionId, currentUser }: {
+    authProvider: ProviderOption;
+    authClient?: string;
+    originUrl: string;
+    session: SessionRecord<UserType>;
+    userSessionId?: UserSessionId;
+    currentUser?: UserType;
+}) => AuthIntent | Promise<AuthIntent>) | undefined;
+export type OnCallbackSuccess<UserType> = ((context: CallbackContext<UserType>) => void | Response | StatusReturn | Promise<void | Response | StatusReturn>) | undefined;
+export type OnLinkIdentity<UserType> = ((context: CallbackContext<UserType>) => void | Response | StatusReturn | Promise<void | Response | StatusReturn>) | undefined;
+export type OnLinkIdentityConflict<UserType> = ((context: CallbackContext<UserType> & {
+    conflict: AuthIdentityConflict;
 }) => void | Response | StatusReturn | Promise<void | Response | StatusReturn>) | undefined;
+export type OnLinkConnector<UserType> = ((context: CallbackContext<UserType>) => void | Response | StatusReturn | Promise<void | Response | StatusReturn>) | undefined;
 export type OnCallbackError = (({ error, authProvider, originUrl }: {
     authProvider: string;
+    authClient?: string;
     error: unknown;
     originUrl: string;
 }) => void | Promise<void>) | undefined;
-export type OnAuthorizeSuccess = (({ authProvider, authorizationUrl }: {
+export type OnAuthorizeSuccess = (({ authProvider, authClient, authIntent, authorizationUrl }: {
     authProvider: string;
+    authClient?: string;
+    authIntent?: AuthIntent;
     authorizationUrl: URL;
 }) => void | Promise<void>) | undefined;
 export type OnAuthorizeError = (({ error, authProvider }: {
     authProvider: string;
+    authClient?: string;
     error: unknown;
 }) => void | Promise<void>) | undefined;
 export type OnRefreshSuccess = (({ tokenResponse, authProvider }: {
     tokenResponse: OAuth2TokenResponse;
     authProvider: string;
+    authClient?: string;
 }) => void | Promise<void>) | undefined;
 export type OnRefreshError = (({ error, authProvider }: {
     authProvider: string;
+    authClient?: string;
     error: unknown;
 }) => void | Promise<void>) | undefined;
 export type OnProfileSuccess = (({ userProfile, authProvider }: {
     userProfile: Record<string, unknown>;
     authProvider: string;
+    authClient?: string;
 }) => void | Promise<void>) | undefined;
 export type OnProfileError = (({ error, authProvider }: {
     authProvider: string;
+    authClient?: string;
     error: unknown;
 }) => void | Promise<void>) | undefined;
 export type OnRevocationSuccess = (({ tokenToRevoke, authProvider }: {
     tokenToRevoke: string;
     authProvider: string;
+    authClient?: string;
 }) => void | Promise<void>) | undefined;
 export type OnRevocationError = (({ error, authProvider }: {
     authProvider: string;
+    authClient?: string;
     error: unknown;
 }) => void | Promise<void>) | undefined;
 export type OnStatus<UserType> = (({ user }: {
@@ -108,10 +149,15 @@ export type AbsoluteAuthProps<UserType> = {
     cleanupIntervalMs?: number;
     maxSessions?: number;
     sessionDurationMs?: number;
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     unregisteredSessionDurationMs?: number;
+    resolveAuthIntent?: ResolveAuthIntent<UserType>;
     onAuthorizeSuccess?: OnAuthorizeSuccess;
     onAuthorizeError?: OnAuthorizeError;
     onCallbackSuccess?: OnCallbackSuccess<UserType>;
+    onLinkIdentity?: OnLinkIdentity<UserType>;
+    onLinkIdentityConflict?: OnLinkIdentityConflict<UserType>;
+    onLinkConnector?: OnLinkConnector<UserType>;
     onCallbackError?: OnCallbackError;
     onStatus?: OnStatus<UserType>;
     onRefreshSuccess?: OnRefreshSuccess;
@@ -123,11 +169,17 @@ export type AbsoluteAuthProps<UserType> = {
     onProfileError?: OnProfileError;
     onSessionCleanup?: OnSessionCleanup<UserType>;
 };
-export type ClientProviders = Record<string, {
+export type ClientProviderEntry = {
+    clientName?: string;
     providerInstance: OAuth2Client<ProviderOption>;
     scope?: string[];
     searchParams?: [string, string][];
-}>;
+};
+export type ClientProviderGroup = {
+    entries: Record<string, ClientProviderEntry>;
+    isSingleClient: boolean;
+};
+export type ClientProviders = Record<string, ClientProviderGroup>;
 export type InsantiateUserSessionProps<UserType> = {
     authProvider: ProviderOption;
     tokenResponse: OAuth2TokenResponse;
@@ -137,6 +189,7 @@ export type InsantiateUserSessionProps<UserType> = {
     user_session_id: Cookie<UserSessionId | undefined>;
     onNewUser: OnNewUser<UserType>;
     getUser: GetUser<UserType>;
+    resolvedAuthorization?: ResolvedOAuthAuthorization;
     sessionDurationMs?: number;
     unregisteredSessionDurationMs?: number;
 };

package/dist/src/userStatus.d.ts

@@ -1,10 +1,12 @@
 import { Elysia } from 'elysia';
+import type { AbsoluteAuthSessionStore } from './sessionTypes';
 import { OnStatus, RouteString } from './types';
 type StatusProps<UserType> = {
+    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
     statusRoute?: RouteString;
     onStatus: OnStatus<UserType>;
 };
-export declare const userStatus: <UserType>({ statusRoute, onStatus }: StatusProps<UserType>) => Elysia<"", {
+export declare const userStatus: <UserType>({ authSessionStore, statusRoute, onStatus }: StatusProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType>;

package/dist/src/utils.d.ts

@@ -1,6 +1,14 @@
+import { OAuth2Client, OAuth2TokenResponse, ProviderOption } from 'citra';
 import { Cookie } from 'elysia';
-import { AbsoluteAuthProps, InsantiateUserSessionProps, OAuth2ConfigurationOptions, SessionRecord, UnregisteredSessionRecord, UserSessionId } from './types';
-export declare const instantiateUserSession: <UserType>({ authProvider, session, user_session_id, unregisteredSession, tokenResponse, providerInstance, getUser, onNewUser, sessionDurationMs, unregisteredSessionDurationMs }: InsantiateUserSessionProps<UserType>) => Promise<import("./types").StatusReturn | Response | undefined>;
+import { AbsoluteAuthProps, InsantiateUserSessionProps, OAuth2ConfigurationOptions, ResolvedOAuthAuthorization, SessionRecord, UnregisteredSessionRecord, UserSessionId } from './types';
+export declare const resolveOAuthTokenExpiresAt: (tokenResponse: OAuth2TokenResponse, now?: number) => number | undefined;
+export declare const resolveOAuthAuthorization: ({ authProvider, providerInstance, tokenResponse, now }: {
+    authProvider: ProviderOption;
+    providerInstance: OAuth2Client<ProviderOption>;
+    tokenResponse: OAuth2TokenResponse;
+    now?: number;
+}) => Promise<ResolvedOAuthAuthorization>;
+export declare const instantiateUserSession: <UserType>({ authProvider, session, user_session_id, unregisteredSession, tokenResponse, providerInstance, getUser, onNewUser, resolvedAuthorization, sessionDurationMs, unregisteredSessionDurationMs }: InsantiateUserSessionProps<UserType>) => Promise<import("./types").StatusReturn | Response | undefined>;
 export declare const createAuthConfiguration: <UserType>(configuration: AbsoluteAuthProps<UserType>) => AbsoluteAuthProps<UserType>;
 export declare const createProvidersConfiguration: (providersConfiguration: OAuth2ConfigurationOptions) => OAuth2ConfigurationOptions;
 export declare const getStatus: <UserType>(session: SessionRecord<UserType>, user_session_id: Cookie<UserSessionId | undefined>) => Promise<{

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "0.22.4",
+	"version": "0.22.5",
 	"name": "@absolutejs/auth",
 	"description": "An authorization library for absolutejs",
 	"repository": {
@@ -33,21 +33,22 @@
 		"elysia": ">= 1.4.26"
 	},
 	"dependencies": {
-		"citra": "0.25.9"
+		"@absolutejs/linked-providers": "0.0.2",
+		"citra": "0.25.11",
+		"@neondatabase/serverless": "1.0.0",
+		"drizzle-orm": "0.41.0"
 	},
 	"devDependencies": {
 		"@absolutejs/absolute": "0.12.3",
 		"@tanstack/react-query": "5.79.0",
 		"@elysiajs/eden": "1.2.0",
 		"@elysiajs/static": "1.2.0",
-		"@neondatabase/serverless": "1.0.0",
 		"@react-spring/web": "10.0.0-beta.0",
 		"@stylistic/eslint-plugin-ts": "4.2.0",
 		"@types/bun": "1.2.9",
 		"@types/react": "19.1.1",
 		"@types/react-dom": "19.1.2",
 		"drizzle-kit": "0.30.6",
-		"drizzle-orm": "0.41.0",
 		"elysia": "1.4.26",
 		"eslint": "9.26.0",
 		"eslint-plugin-absolute": "0.0.3",
@@ -65,5 +66,11 @@
 		"typescript": "5.8.3",
 		"typescript-eslint": "8.32.0"
 	},
-	"module": "dist/index.js"
+	"module": "dist/index.js",
+	"exports": {
+		".": {
+			"types": "./dist/src/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	}
 }