@flink-app/generic-auth-plugin 0.12.1-alpha.7 → 0.13.0

package/src/coreFunctions.ts

@@ -1,4 +1,4 @@
-import { FlinkRepo, FlinkAuthUser, log } from "@flink-app/flink";
+import { FlinkRepo, FlinkAuthUser, log, FlinkRequest } from "@flink-app/flink";
 import { JwtAuthPlugin, jwtAuthPlugin } from "@flink-app/jwt-auth-plugin";
 
 import { User } from "./schemas/User";
@@ -45,7 +45,7 @@ export async function createUser(
     auth: JwtAuthPlugin,
     username: string,
     password: string,
-    authentificationMethod: "password" | "sms",
+    authentificationMethod: "password" | "sms" | "bankid",
     roles: string[],
     profile: UserProfile,
     createPasswordHashAndSaltMethod?: {
@@ -53,7 +53,8 @@ export async function createUser(
     },
     onUserCreated?: {
         (user: User): Promise<void>;
-    }
+    },
+    personalNumber?: string
 ): Promise<UserCreateRes> {
     if (!roles.includes("user")) roles.push("user");
 
@@ -71,6 +72,17 @@ export async function createUser(
         pushNotificationTokens: [],
     };
 
+    if (personalNumber) {
+        userData.personalNumber = personalNumber;
+    }
+
+    if (authentificationMethod == "bankid") {
+        if (!personalNumber) {
+            log.warn("BankID login requested but no personal number found for user");
+            return { status: "error" };
+        }
+    }
+
     if (authentificationMethod == "password") {
         let passwordAndSalt = null;
         if (createPasswordHashAndSaltMethod != null) {
@@ -152,8 +164,9 @@ export async function loginUser(
     },
     smsOptions?: GenericAuthsmsOptions,
     onSuccessfulLogin?: {
-        (user: User): Promise<void>;
-    }
+        (user: User, req?: FlinkRequest): Promise<void>;
+    },
+    req?: FlinkRequest
 ): Promise<UserLoginRes> {
     const user = await repo.getOne({ username: username.toLowerCase() });
     if (user == null) {
@@ -205,12 +218,21 @@ export async function loginUser(
             validationToken: token,
         };
     }
+    if (user.authentificationMethod == "bankid") {
+        if (!user.personalNumber) {
+            log.warn("BankID login requested but no personal number found for user");
+            return { status: "failed" };
+        }
+
+        log.warn("BankID login required to be handled in other way, i.e. using flink bankid plugin");
+        return { status: "failed" };
+    }
 
     if (valid) {
         const token = await auth.createToken({ username: username.toLowerCase(), _id: user._id }, user.roles);
 
         if (onSuccessfulLogin) {
-            await onSuccessfulLogin(user);
+            await onSuccessfulLogin(user, req);
         }
 
         return {
@@ -382,7 +404,7 @@ export async function passwordResetComplete(
         pwdResetStartedAt: null,
     });
 
-    return { status: "success" };
+    return { status: "success", user };
 }
 
 function generate(n: number): string {

package/src/genericAuthContext.ts

@@ -1,4 +1,4 @@
-import { FlinkRepo } from "@flink-app/flink";
+import { FlinkRepo, FlinkRequest } from "@flink-app/flink";
 import { JwtAuthPlugin } from "@flink-app/jwt-auth-plugin";
 import { User } from "./schemas/User";
 import { UserCreateRes } from "./schemas/UserCreateRes";
@@ -19,7 +19,8 @@ export interface genericAuthContext {
             password?: string,
             validatePasswordMethod?: { (password: string, hash: string, salt: string): Promise<boolean> },
             smsOptions?: GenericAuthsmsOptions,
-            onSuccessfulLogin?: (user: User) => Promise<void>
+            onSuccessfulLogin?: (user: User, req?: FlinkRequest) => Promise<void>,
+            req?: FlinkRequest
         ): Promise<UserLoginRes>;
         loginByToken(repo: FlinkRepo<any, User>, auth: JwtAuthPlugin, token: string, code: string, jwtSecret: string): Promise<UserLoginRes>;
         createUser(
@@ -27,13 +28,14 @@ export interface genericAuthContext {
             auth: JwtAuthPlugin,
             username: string,
             password: string,
-            authentificationMethod: "password" | "sms",
+            authentificationMethod: "password" | "sms" | "bankid",
             roles: string[],
             profile: UserProfile,
             createPasswordHashAndSaltMethod?: {
                 (password: string): Promise<{ hash: string; salt: string } | null>;
             },
-            onUserCreated?: (user: User) => Promise<void>
+            onUserCreated?: (user: User) => Promise<void>,
+            personalNumber?: string
         ): Promise<UserCreateRes>;
         changePassword(
             repo: FlinkRepo<any, User>,
@@ -67,7 +69,8 @@ export interface genericAuthContext {
         validatePasswordMethod?: { (password: string, hash: string, salt: string): Promise<boolean> };
         usernameFormat: RegExp;
         smsOptions?: GenericAuthsmsOptions;
-        onSuccessfulLogin?: { (user: User): Promise<void> };
+        onSuccessfulLogin?: { (user: User, req?: FlinkRequest): Promise<void> };
         onUserCreated?: { (user: User): Promise<void> };
+        onUserUpdated?: { (user: User, updatedData: UserProfile): Promise<void> };
     };
 }

package/src/genericAuthPluginOptions.ts

@@ -1,5 +1,7 @@
+import { FlinkRequest } from "@flink-app/flink";
 import { User } from "./schemas/User";
 import { UserPasswordResetSettings } from "./schemas/UserPasswordResetSettings";
+import { UserProfile } from "./schemas/UserProfile";
 import { client as smsClient } from "@flink-app/sms-plugin";
 export interface GenericAuthPluginOptions {
     repoName: string;
@@ -23,11 +25,14 @@ export interface GenericAuthPluginOptions {
     usernameFormat?: RegExp;
     sms?: GenericAuthsmsOptions;
     onSuccessfulLogin?: {
-        (user: User): Promise<void>;
+        (user: User, req?: FlinkRequest): Promise<void>;
     };
     onUserCreated?: {
         (user: User): Promise<void>;
     };
+    onUserUpdated?: {
+        (user: User, updatedData: UserProfile): Promise<void>;
+    };
     /**
      * If true, when a new device is registered, all other devices identified by `deviceId`
      * will be deregistered to avoid duplicate notifications.

package/src/handlers/Management/PutUserProfileByUserid.ts

@@ -23,6 +23,12 @@ const PutManagementUserProfileByUserid: Handler<
 
   await repo.updateOne(user._id, { profile: req.body });
 
+  const updatedUser = await repo.getById(req.params.userid);
+
+  if ((<any>ctx.plugins)[pluginName].onUserUpdated) {
+    await (<any>ctx.plugins)[pluginName].onUserUpdated(updatedUser, req.body);
+  }
+
   return {
     data: {},
     status: 200,

package/src/handlers/UserCreate.ts

@@ -5,7 +5,7 @@ import { UserCreateReq } from "../schemas/UserCreateReq";
 import { UserCreateRes } from "../schemas/UserCreateRes";
 
 const userCreateHandler: Handler<FlinkContext<genericAuthContext>, UserCreateReq, UserCreateRes> = async ({ ctx, req, origin }) => {
-    let { password, username, authentificationMethod, profile } = req.body;
+    let { password, username, authentificationMethod, profile, personalNumber } = req.body;
     if (authentificationMethod == null) {
         authentificationMethod = "password";
     }
@@ -36,7 +36,8 @@ const userCreateHandler: Handler<FlinkContext<genericAuthContext>, UserCreateReq
         roles,
         profile,
         (<any>ctx.plugins)[pluginName].createPasswordHashAndSaltMethod,
-        (<any>ctx.plugins)[pluginName].onUserCreated
+        (<any>ctx.plugins)[pluginName].onUserCreated,
+        personalNumber
     );
     if (createUserResponse.status != "success") {
         switch (createUserResponse.status) {

package/src/handlers/UserLogin.ts

@@ -1,41 +1,66 @@
-import { FlinkContext, Handler, unauthorized } from "@flink-app/flink";
+import { FlinkContext, FlinkResponse, Handler, internalServerError, log, unauthorized } from "@flink-app/flink";
+import { JwtAuthPlugin } from "@flink-app/jwt-auth-plugin";
 import { genericAuthContext } from "../genericAuthContext";
 import { UserLoginReq } from "../schemas/UserLoginReq";
 import { UserLoginRes } from "../schemas/UserLoginRes";
-import { JwtAuthPlugin } from "@flink-app/jwt-auth-plugin";
 
-const userLoginHandler: Handler<
-  FlinkContext<genericAuthContext>,
-  UserLoginReq,
-  UserLoginRes
-> = async ({ ctx, req, origin }) => {
-  let pluginName = origin || "genericAuthPlugin";
-  let repo = ctx.repos[(<any>ctx.plugins)[pluginName].repoName];
-  
-  const loginRespons = await ctx.plugins.genericAuthPlugin.loginUser(
-    repo,
-    <JwtAuthPlugin>ctx.auth,
-    req.body.username,
-    req.body.password,
-    ctx.plugins.genericAuthPlugin.validatePasswordMethod,
-    (<any>ctx.plugins)[pluginName].smsOptions,
-    (<any>ctx.plugins)[pluginName].onSuccessfulLogin
-  );
-
-  if (loginRespons.status != "success") {
-    switch (loginRespons.status) {
-      case "failed":
-        return unauthorized(
-          "Invalid username or password",
-          loginRespons.status
+const userLoginHandler: Handler<FlinkContext<genericAuthContext>, UserLoginReq, UserLoginRes> = async ({ ctx, req, origin }) => {
+    let pluginName = origin || "genericAuthPlugin";
+    let repo = ctx.repos[(<any>ctx.plugins)[pluginName].repoName];
+
+    let loginResponse: UserLoginRes | undefined = undefined;
+
+    try {
+        loginResponse = await ctx.plugins.genericAuthPlugin.loginUser(
+            repo,
+            <JwtAuthPlugin>ctx.auth,
+            req.body.username,
+            req.body.password,
+            ctx.plugins.genericAuthPlugin.validatePasswordMethod,
+            (<any>ctx.plugins)[pluginName].smsOptions,
+            (<any>ctx.plugins)[pluginName].onSuccessfulLogin,
+            req
         );
+    } catch (error: any) {
+        // Convert any thrown error that conforms to flink error structure to a proper response
+        // Note that any auth failures would not have been thrown, but returned as part of loginResponse
+        // but with this it is possible to throw errors from callbacks like onSuccessfulLogin
+        if (isFlinkError(error)) {
+            log.debug("Caught FlinkError in userLoginHandler:", error);
+            return {
+                status: error.status,
+                error: {
+                    id: error.error.id,
+                    title: error.error.title,
+                    code: error.error.code,
+                    detail: error.error.detail,
+                },
+            } as FlinkResponse;
+        }
+
+        // For other errors, return a generic 500 response
+        log.error("Error in userLoginHandler:", error);
+        return internalServerError();
     }
-  }
 
-  return {
-    data: loginRespons,
-    status: 200,
-  };
+    if (loginResponse?.status != "success") {
+        switch (loginResponse?.status) {
+            case "failed":
+                return unauthorized("Invalid username or password", loginResponse.status);
+        }
+    }
+
+    return {
+        data: loginResponse,
+        status: 200,
+    };
 };
 
 export default userLoginHandler;
+
+function isFlinkError(res: any) {
+    if (res && res.status && typeof res.status === "number" && res.error && res.error.id) {
+        return true;
+    }
+    return false;
+}

package/src/handlers/UserProfilePut.ts

@@ -2,34 +2,32 @@ import { FlinkContext, Handler, notFound } from "@flink-app/flink";
 import { genericAuthContext } from "../genericAuthContext";
 import { UserProfile } from "../schemas/UserProfile";
 
-const putUserProfileHandler: Handler<
-  FlinkContext<genericAuthContext>,
-  UserProfile,
-  UserProfile
-> = async ({ ctx, req, origin }) => {
-  let pluginName = origin || "genericAuthPlugin";
-  let repo = ctx.repos[(<any>ctx.plugins)[pluginName].repoName];
+const putUserProfileHandler: Handler<FlinkContext<genericAuthContext>, UserProfile, UserProfile> = async ({ ctx, req, origin }) => {
+    let pluginName = origin || "genericAuthPlugin";
+    let repo = ctx.repos[(<any>ctx.plugins)[pluginName].repoName];
 
-  let userId = req.user._id;
-  let user = await repo.getById(userId);
-  if (user == null) {
-    return notFound();
-  }
+    let userId = req.user._id;
+    let user = await repo.getById(userId);
+    if (user == null) {
+        return notFound();
+    }
 
+    const updatedProfile = {
+        ...user.profile,
+        ...req.body,
+    };
 
-  const updatedProfile = {
-    ...user.profile,
-    ...req.body,
-}
+    await repo.updateOne(userId, { profile: updatedProfile });
 
+    user = await repo.getById(userId);
 
-  await repo.updateOne(userId, { profile: updatedProfile });
+    if ((<any>ctx.plugins)[pluginName].onUserUpdated) {
+        await (<any>ctx.plugins)[pluginName].onUserUpdated(user, req.body);
+    }
 
-  user = await repo.getById(userId);
-
-  return {
-    data: user.profile,
-  };
+    return {
+        data: user.profile,
+    };
 };
 
 export default putUserProfileHandler;

package/src/handlers/UserPushRegisterToken.ts

@@ -43,7 +43,7 @@ const postUserPushRegisterTokenHandler: Handler<FlinkContext<genericAuthContext>
     if (deregisterOtherDevices) {
         const otherRegistrations = <User[]>await repo.findAll({
             $or: [{ "pushNotificationTokens.deviceId": req.body.deviceId }, { "pushNotificationTokens.token": req.body.token }],
-            _id: { $ne: user._id },
+            _id: { $ne: repo.buildId(user._id) },
         });
 
         log.debug(`Found ${otherRegistrations.length} other registrations for device ${req.body.deviceId} or token ${req.body.token}`);

package/src/index.ts

@@ -12,7 +12,7 @@ export * from "./management";
 export const genericAuthPlugin = (options: GenericAuthPluginOptions): FlinkPlugin => {
     if (options.pluginId == null) options.pluginId = "genericAuthPlugin";
 
-    const { sms, usernameFormat, ...restOptions } = options;
+    const { sms, usernameFormat, onUserUpdated, ...restOptions } = options;
 
     return {
         id: options.pluginId,
@@ -27,6 +27,7 @@ export const genericAuthPlugin = (options: GenericAuthPluginOptions): FlinkPlugi
             passwordResetComplete,
             usernameFormat: usernameFormat || /.{1,}$/,
             smsOptions: sms,
+            onUserUpdated,
         },
     };
 };

package/src/init.ts

@@ -1,4 +1,4 @@
-import { FlinkApp, HttpMethod } from "@flink-app/flink";
+import { FlinkApp, HttpMethod, ExpressRequest, ExpressResponse } from "@flink-app/flink";
 import * as userLoginHandler from "./handlers/UserLogin";
 import * as userLoginByTokenHandler from "./handlers/UserLoginByToken";
 import * as userCreateHandler from "./handlers/UserCreate";
@@ -11,140 +11,128 @@ import { GenericAuthPluginOptions } from "./genericAuthPluginOptions";
 import * as postUserPushRegisterTokenHandler from "./handlers/UserPushRegisterToken";
 import * as postUserRemoveTokenHandler from "./handlers/UserPushRemoveToken";
 import * as getUserTokenHandler from "./handlers/UserToken";
-import {
-  handleUserPasswordResetForm,
-  resetPasswordFormCss,
-  resetPasswordFormScript,
-} from "./handlers/UserPasswordResetForm";
+import { handleUserPasswordResetForm, resetPasswordFormCss, resetPasswordFormScript } from "./handlers/UserPasswordResetForm";
 
 export function init(app: FlinkApp<any>, options: GenericAuthPluginOptions) {
-  if (options.enableUserCreation == null) options.enableUserCreation = true;
-  if (options.enableProfileUpdate == null) options.enableProfileUpdate = true;
-  if (options.enablePasswordUpdate == null) options.enablePasswordUpdate = true;
-  if (options.enableUserLogin == null) options.enableUserLogin = true;
-  
-  if (options.baseUrl == null) options.baseUrl = "/user";
+    if (options.enableUserCreation == null) options.enableUserCreation = true;
+    if (options.enableProfileUpdate == null) options.enableProfileUpdate = true;
+    if (options.enablePasswordUpdate == null) options.enablePasswordUpdate = true;
+    if (options.enableUserLogin == null) options.enableUserLogin = true;
 
-  if (options.enableRoutes) {
-    if(options.enableUserLogin){
-      app.addHandler(userLoginHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/login",
-        docs: "Authenticates a user",
-        origin: options.pluginId,
-      });
-    }
-    if(options.sms){
-      app.addHandler(userLoginByTokenHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/login-by-token",
-        docs: "Authenticates a user by token",
-        origin: options.pluginId,
-      });
-    }
-    if (options.enableUserCreation) {
-      app.addHandler(userCreateHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/create",
-        docs: "Creates a new user",
-        origin: options.pluginId,
-      });
-    }
+    if (options.baseUrl == null) options.baseUrl = "/user";
 
-    app.addHandler(getProfileHandler, {
-      method: HttpMethod.get,
-      path: options.baseUrl + "/profile",
-      docs: "Gets the user profile",
-      permissions: "authenticated",
-      origin: options.pluginId,
-    });
+    if (options.enableRoutes) {
+        if (options.enableUserLogin) {
+            app.addHandler(userLoginHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/login",
+                docs: "Authenticates a user",
+                origin: options.pluginId,
+            });
+        }
+        if (options.sms) {
+            app.addHandler(userLoginByTokenHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/login-by-token",
+                docs: "Authenticates a user by token",
+                origin: options.pluginId,
+            });
+        }
+        if (options.enableUserCreation) {
+            app.addHandler(userCreateHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/create",
+                docs: "Creates a new user",
+                origin: options.pluginId,
+            });
+        }
 
-    app.addHandler(getUserTokenHandler, {
-      method: HttpMethod.get,
-      path: options.baseUrl + "/token",
-      docs: "Gets a refreshed token for the user",
-      permissions: "authenticated",
-      origin: options.pluginId,
-    });
+        app.addHandler(getProfileHandler, {
+            method: HttpMethod.get,
+            path: options.baseUrl + "/profile",
+            docs: "Gets the user profile",
+            permissions: "authenticated",
+            origin: options.pluginId,
+        });
 
-    if (options.enableProfileUpdate) {
-      app.addHandler(putUserProfileHandler, {
-        method: HttpMethod.put,
-        path: options.baseUrl + "/profile",
-        docs: "Updates the user profile",
-        permissions: "authenticated",
-        origin: options.pluginId,
-      });
-    }
+        app.addHandler(getUserTokenHandler, {
+            method: HttpMethod.get,
+            path: options.baseUrl + "/token",
+            docs: "Gets a refreshed token for the user",
+            permissions: "authenticated",
+            origin: options.pluginId,
+        });
 
-    if (options.enablePasswordUpdate) {
-      app.addHandler(putUserPasswordHandler, {
-        method: HttpMethod.put,
-        path: options.baseUrl + "/password",
-        docs: "Updates the user password",
-        permissions: "authenticated",
-        origin: options.pluginId,
-      });
-    }
+        if (options.enableProfileUpdate) {
+            app.addHandler(putUserProfileHandler, {
+                method: HttpMethod.put,
+                path: options.baseUrl + "/profile",
+                docs: "Updates the user profile",
+                permissions: "authenticated",
+                origin: options.pluginId,
+            });
+        }
 
-    if (options.enablePasswordReset) {
-      app.addHandler(postPasswordResetStartHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/password/reset",
-        docs: "Start the password reset process for a user",
-        origin: options.pluginId,
-      });
+        if (options.enablePasswordUpdate) {
+            app.addHandler(putUserPasswordHandler, {
+                method: HttpMethod.put,
+                path: options.baseUrl + "/password",
+                docs: "Updates the user password",
+                permissions: "authenticated",
+                origin: options.pluginId,
+            });
+        }
 
-      app.addHandler(postPasswordResetCompleteHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/password/reset/complete",
-        docs: "Completes a password reset for a user",
-        origin: options.pluginId,
-      });
+        if (options.enablePasswordReset) {
+            app.addHandler(postPasswordResetStartHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/password/reset",
+                docs: "Start the password reset process for a user",
+                origin: options.pluginId,
+            });
 
-      if (options.passwordResetSettings?.enablePasswordResetForm) {
-        app.expressApp?.get(
-          options.baseUrl + "/password/reset/form",
-          (req, res) =>
-            handleUserPasswordResetForm(req, res, {
-              templateFile: options.passwordResetSettings?.passwordResetForm,
-              completeUrl: options.baseUrl + "/password/reset/complete",
-            })
-        );
-        app.expressApp?.get(
-            options.baseUrl + "/password/reset/form/script.js",
-            (req, res) => {
-              resetPasswordFormScript(req, res, { completeUrl: options.baseUrl + "/password/reset/complete"});
-            }
-        );
+            app.addHandler(postPasswordResetCompleteHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/password/reset/complete",
+                docs: "Completes a password reset for a user",
+                origin: options.pluginId,
+            });
 
-        app.expressApp?.get(
-            options.baseUrl + "/password/reset/form/style.css",
-            (req, res) => {
-              resetPasswordFormCss(res);
+            if (options.passwordResetSettings?.enablePasswordResetForm) {
+                app.expressApp?.get(options.baseUrl + "/password/reset/form", (req: ExpressRequest, res: ExpressResponse) =>
+                    handleUserPasswordResetForm(req, res, {
+                        templateFile: options.passwordResetSettings?.passwordResetForm,
+                        completeUrl: options.baseUrl + "/password/reset/complete",
+                    })
+                );
+                app.expressApp?.get(options.baseUrl + "/password/reset/form/script.js", (req: ExpressRequest, res: ExpressResponse) => {
+                    resetPasswordFormScript(req, res, { completeUrl: options.baseUrl + "/password/reset/complete" });
+                });
+
+                app.expressApp?.get(options.baseUrl + "/password/reset/form/style.css", (_req: ExpressRequest, res: ExpressResponse) => {
+                    resetPasswordFormCss(res);
+                });
             }
-        );
-      }
-    }
+        }
 
-    if (options.enablePushNotificationTokens) {
-      app.addHandler(postUserPushRegisterTokenHandler, {
-        method: HttpMethod.post,
-        path: options.baseUrl + "/push",
-        docs: "Register a push notification on current user",
-        permissions: "authenticated",
-        origin: options.pluginId,
-      });
+        if (options.enablePushNotificationTokens) {
+            app.addHandler(postUserPushRegisterTokenHandler, {
+                method: HttpMethod.post,
+                path: options.baseUrl + "/push",
+                docs: "Register a push notification on current user",
+                permissions: "authenticated",
+                origin: options.pluginId,
+            });
 
-      app.addHandler(postUserRemoveTokenHandler, {
-        method: HttpMethod.delete,
-        path: options.baseUrl + "/push",
-        docs: "Removes a push notification token from current user",
-        permissions: "authenticated",
-        origin: options.pluginId,
-      });
+            app.addHandler(postUserRemoveTokenHandler, {
+                method: HttpMethod.delete,
+                path: options.baseUrl + "/push",
+                docs: "Removes a push notification token from current user",
+                permissions: "authenticated",
+                origin: options.pluginId,
+            });
+        }
     }
-  }
 }
 
 export {};

package/src/schemas/User.ts

@@ -4,6 +4,7 @@ import { UserProfile } from "./UserProfile";
 export interface User {
     _id: string;
     username: string;
+    personalNumber?: string;
 
     password?: string;
     salt?: string;
@@ -11,7 +12,7 @@ export interface User {
     pwdResetStartedAt?: string | null;
     roles: string[];
 
-    authentificationMethod: "password" | "sms";
+    authentificationMethod: "password" | "sms" | "bankid";
     profile: UserProfile;
     pushNotificationTokens: Array<PushNotificationToken>;
 }

package/src/schemas/UserCreateReq.ts

@@ -1,8 +1,9 @@
 import { UserProfile } from "./UserProfile";
 
-export interface UserCreateReq{
+export interface UserCreateReq {
     username: string;
     password?: string;
-    authentificationMethod? : "password" | "sms"
-    profile? : UserProfile
-}
+    personalNumber?: string;
+    authentificationMethod?: "password" | "sms" | "bankid";
+    profile?: UserProfile;
+}