nuxt-auth-utils 0.3.5 → 0.3.6

package/README.md

@@ -199,6 +199,7 @@ It can also be set using environment variables:
 - PayPal
 - Spotify
 - Steam
+- TikTok
 - Twitch
 - X (Twitter)
 - XSUAA
@@ -250,7 +251,7 @@ export default defineNitroPlugin(() => {
     // throw createError({ ... }) if session is invalid for example
   })
 
-  // Called when we call useServerSession().clear() or clearUserSession(event)
+  // Called when we call useUserSession().clear() or clearUserSession(event)
   sessionHooks.hook('clear', async (session, event) => {
     // Log that user logged out
   })

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "auth-utils",
   "configKey": "auth",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "builder": {
     "@nuxt/module-builder": "0.8.3",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -149,6 +149,11 @@ const module = defineNuxtModule({
       clientSecret: "",
       redirectURL: ""
     });
+    runtimeConfig.oauth.tiktok = defu(runtimeConfig.oauth.tiktok, {
+      clientKey: "",
+      clientSecret: "",
+      redirectURL: ""
+    });
   }
 });
 

package/dist/runtime/server/lib/oauth/auth0.js

@@ -1,21 +1,21 @@
-import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleMissingConfiguration, handleAccessTokenErrorResponse } from "../utils.js";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.auth0, {
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.domain) {
       return handleMissingConfiguration(event, "auth0", ["clientId", "clientSecret", "domain"], onError);
     }
     const authorizationURL = `https://${config.domain}/authorize`;
     const tokenURL = `https://${config.domain}/oauth/token`;
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid", "offline_access"];
       if (config.emailRequired && !config.scope.includes("email")) {
         config.scope.push("email");
@@ -34,23 +34,17 @@ export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
-      tokenURL,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: {
-          grant_type: "authorization_code",
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          redirect_uri: parsePath(redirectURL).pathname,
-          code
-        }
+    const tokens = await requestAccessToken(tokenURL, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      return { error };
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "auth0", tokens, onError);

package/dist/runtime/server/lib/oauth/battledotnet.js

@@ -1,9 +1,9 @@
-import { randomUUID } from "node:crypto";
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
+import { randomUUID } from "uncrypto";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.battledotnet, {
@@ -12,7 +12,6 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
       authorizationParams: {}
     });
     const query = getQuery(event);
-    const { code } = query;
     if (query.error) {
       const error = createError({
         statusCode: 401,
@@ -30,8 +29,8 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
         onError
       );
     }
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid"];
       config.region = config.region || "EU";
       if (config.region === "CN") {
@@ -55,24 +54,16 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
     if (!config.scope.includes("openid")) {
       config.scope.push("openid");
     }
-    const authCode = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
-    const tokens = await $fetch(
-      config.tokenURL,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          "Authorization": `Basic ${authCode}`
-        },
-        params: {
-          code,
-          grant_type: "authorization_code",
-          scope: config.scope.join(" "),
-          redirect_uri: parsePath(redirectURL).pathname
-        }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      headers: {
+        Authorization: `Basic ${Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64")}`
+      },
+      params: {
+        grant_type: "authorization_code",
+        scope: config.scope.join(" "),
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      return { error };
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "battle.net", tokens, onError);

package/dist/runtime/server/lib/oauth/cognito.js

@@ -1,22 +1,22 @@
-import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.cognito, {
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.userPoolId || !config.region) {
       return handleMissingConfiguration(event, "cognito", ["clientId", "clientSecret", "userPoolId", "region"], onError);
     }
     const urlBase = config?.domain || `${config.userPoolId}.auth.${config.region}.amazoncognito.com`;
     const authorizationURL = `https://${urlBase}/oauth2/authorize`;
     const tokenURL = `https://${urlBase}/oauth2/token`;
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid", "profile"];
       return sendRedirect(
         event,
@@ -29,18 +29,18 @@ export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
+    const tokens = await requestAccessToken(
       tokenURL,
       {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: `grant_type=authorization_code&client_id=${config.clientId}&client_secret=${config.clientSecret}&redirect_uri=${parsePath(redirectURL).pathname}&code=${code}`
+        body: {
+          grant_type: "authorization_code",
+          client_id: config.clientId,
+          client_secret: config.clientSecret,
+          redirect_uri: redirectURL,
+          code: query.code
+        }
       }
-    ).catch((error) => {
-      return { error };
-    });
+    );
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "cognito", tokens, onError);
     }

package/dist/runtime/server/lib/oauth/discord.js

@@ -1,7 +1,7 @@
-import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parseURL, stringifyParsedURL } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -11,12 +11,12 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
       profileRequired: true,
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
+    const query = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
       return handleMissingConfiguration(event, "discord", ["clientId", "clientSecret"], onError);
     }
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("email")) {
         config.scope.push("email");
@@ -35,25 +35,14 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const parsedRedirectUrl = parseURL(redirectURL);
-    parsedRedirectUrl.search = "";
-    const tokens = await $fetch(
-      config.tokenURL,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: new URLSearchParams({
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          grant_type: "authorization_code",
-          redirect_uri: stringifyParsedURL(parsedRedirectUrl),
-          code
-        }).toString()
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        grant_type: "authorization_code",
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      return { error };
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "discord", tokens, onError);

package/dist/runtime/server/lib/oauth/facebook.js

@@ -1,14 +1,8 @@
-import {
-  eventHandler,
-  createError,
-  getQuery,
-  getRequestURL,
-  sendRedirect
-} from "h3";
+import { eventHandler, getQuery, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthFacebookEventHandler({
   config,
   onSuccess,
@@ -33,7 +27,7 @@ export function oauthFacebookEventHandler({
     if (!config.clientId) {
       return handleMissingConfiguration(event, "facebook", ["clientId"], onError);
     }
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
     if (!query.code) {
       config.scope = config.scope || [];
       return sendRedirect(
@@ -45,11 +39,11 @@ export function oauthFacebookEventHandler({
         })
       );
     }
-    const tokens = await $fetch(config.tokenURL, {
-      method: "POST",
+    const tokens = await requestAccessToken(config.tokenURL, {
       body: {
         client_id: config.clientId,
         client_secret: config.clientSecret,
+        grant_type: "authorization_code",
         redirect_uri: redirectURL,
         code: query.code
       }

package/dist/runtime/server/lib/oauth/github.js

@@ -1,8 +1,8 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.github, {
@@ -23,12 +23,12 @@ export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
     if (!config.clientId || !config.clientSecret) {
       return handleMissingConfiguration(event, "github", ["clientId", "clientSecret"], onError);
     }
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
     if (!query.code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("user:email")) {
         config.scope.push("user:email");
       }
-      const redirectURL = config.redirectURL || getRequestURL(event).href;
       return sendRedirect(
         event,
         withQuery(config.authorizationURL, {
@@ -39,17 +39,15 @@ export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
-      config.tokenURL,
-      {
-        method: "POST",
-        body: {
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          code: query.code
-        }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    );
+    });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "github", tokens, onError);
     }

package/dist/runtime/server/lib/oauth/google.js

@@ -1,12 +1,7 @@
-import {
-  eventHandler,
-  getQuery,
-  getRequestURL,
-  sendRedirect
-} from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthGoogleEventHandler({
   config,
@@ -20,12 +15,12 @@ export function oauthGoogleEventHandler({
       userURL: "https://www.googleapis.com/oauth2/v3/userinfo",
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
+    const query = getQuery(event);
     if (!config.clientId) {
       return handleMissingConfiguration(event, "google", ["clientId"], onError);
     }
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["email", "profile"];
       return sendRedirect(
         event,
@@ -38,18 +33,14 @@ export function oauthGoogleEventHandler({
         })
       );
     }
-    const body = {
-      grant_type: "authorization_code",
-      redirect_uri: parsePath(redirectURL).pathname,
-      client_id: config.clientId,
-      client_secret: config.clientSecret,
-      code
-    };
-    const tokens = await $fetch(config.tokenURL, {
-      method: "POST",
-      body
-    }).catch((error) => {
-      return { error };
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        code: query.code,
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL
+      }
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "google", tokens, onError);

package/dist/runtime/server/lib/oauth/keycloak.js

@@ -1,14 +1,8 @@
-import {
-  eventHandler,
-  createError,
-  getQuery,
-  getRequestURL,
-  sendRedirect
-} from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthKeycloakEventHandler({
   config,
   onSuccess,
@@ -19,7 +13,6 @@ export function oauthKeycloakEventHandler({
       authorizationParams: {}
     });
     const query = getQuery(event);
-    const { code } = query;
     if (query.error) {
       const error = createError({
         statusCode: 401,
@@ -35,8 +28,8 @@ export function oauthKeycloakEventHandler({
     const realmURL = `${config.serverUrl}/realms/${config.realm}`;
     const authorizationURL = `${realmURL}/protocol/openid-connect/auth`;
     const tokenURL = `${realmURL}/protocol/openid-connect/token`;
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid"];
       return sendRedirect(
         event,
@@ -53,20 +46,14 @@ export function oauthKeycloakEventHandler({
     if (!config.scope.includes("openid")) {
       config.scope.push("openid");
     }
-    const tokens = await $fetch(tokenURL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
+    const tokens = await requestAccessToken(tokenURL, {
+      body: {
+        grant_type: "authorization_code",
         client_id: config.clientId,
         client_secret: config.clientSecret,
-        grant_type: "authorization_code",
-        redirect_uri: parsePath(redirectURL).pathname,
-        code
-      }).toString()
-    }).catch((error) => {
-      return { error };
+        redirect_uri: redirectURL,
+        code: query.code
+      }
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "keycloak", tokens, onError);

package/dist/runtime/server/lib/oauth/linkedin.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event, H3Error } from 'h3';
+import type { OAuthConfig } from '#auth-utils';
 export interface OAuthLinkedInConfig {
     /**
      * LinkedIn OAuth Client ID
@@ -42,13 +42,4 @@ export interface OAuthLinkedInConfig {
      */
     redirectURL?: string;
 }
-interface OAuthConfig {
-    config?: OAuthLinkedInConfig;
-    onSuccess: (event: H3Event, result: {
-        user: any;
-        tokens: any;
-    }) => Promise<void> | void;
-    onError?: (event: H3Event, error: H3Error) => Promise<void> | void;
-}
-export declare function oauthLinkedInEventHandler({ config, onSuccess, onError }: OAuthConfig): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
-export {};
+export declare function oauthLinkedInEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthLinkedInConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

package/dist/runtime/server/lib/oauth/linkedin.js

@@ -1,7 +1,7 @@
-import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parseURL, stringifyParsedURL } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -10,12 +10,12 @@ export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
       tokenURL: "https://www.linkedin.com/oauth/v2/accessToken",
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
+    const query = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
       return handleMissingConfiguration(event, "linkedin", ["clientId", "clientSecret"], onError);
     }
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || [];
       if (!config.scope.length) {
         config.scope.push("profile", "openid", "email");
@@ -34,25 +34,14 @@ export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const parsedRedirectUrl = parseURL(redirectURL);
-    parsedRedirectUrl.search = "";
-    const tokens = await $fetch(
-      config.tokenURL,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: new URLSearchParams({
-          grant_type: "authorization_code",
-          code,
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          redirect_uri: stringifyParsedURL(parsedRedirectUrl)
-        }).toString()
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        code: query.code,
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL
       }
-    ).catch((error) => {
-      return { error };
     });
     if (tokens.error) {
       return handleAccessTokenErrorResponse(event, "linkedin", tokens, onError);

package/dist/runtime/server/lib/oauth/microsoft.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event, H3Error } from 'h3';
+import type { OAuthConfig } from '#auth-utils';
 export interface OAuthMicrosoftConfig {
     /**
      * Microsoft OAuth Client ID
@@ -51,13 +51,4 @@ export interface OAuthMicrosoftConfig {
      */
     redirectURL?: string;
 }
-interface OAuthConfig {
-    config?: OAuthMicrosoftConfig;
-    onSuccess: (event: H3Event, result: {
-        user: any;
-        tokens: any;
-    }) => Promise<void> | void;
-    onError?: (event: H3Event, error: H3Error) => Promise<void> | void;
-}
-export declare function oauthMicrosoftEventHandler({ config, onSuccess, onError }: OAuthConfig): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
-export {};
+export declare function oauthMicrosoftEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthMicrosoftConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;