@boxyhq/saml-jackson 1.1.4 → 1.2.0

package/dist/directory-sync/Users.d.ts

@@ -0,0 +1,47 @@
+import type { User, DatabaseStore, ApiError } from '../typings';
+import { Base } from './Base';
+export declare class Users extends Base {
+    constructor({ db }: {
+        db: DatabaseStore;
+    });
+    create(param: {
+        first_name: string;
+        last_name: string;
+        email: string;
+        active: boolean;
+        raw: any;
+    }): Promise<{
+        data: User | null;
+        error: ApiError | null;
+    }>;
+    get(id: string): Promise<{
+        data: User | null;
+        error: ApiError | null;
+    }>;
+    update(id: string, param: {
+        first_name: string;
+        last_name: string;
+        email: string;
+        active: boolean;
+        raw: object;
+    }): Promise<{
+        data: User | null;
+        error: ApiError | null;
+    }>;
+    delete(id: string): Promise<{
+        data: null;
+        error: ApiError | null;
+    }>;
+    list({ pageOffset, pageLimit, }: {
+        pageOffset?: number;
+        pageLimit?: number;
+    }): Promise<{
+        data: User[] | null;
+        error: ApiError | null;
+    }>;
+    search(userName: string): Promise<{
+        data: User[] | null;
+        error: ApiError | null;
+    }>;
+    clear(): Promise<void>;
+}

package/dist/directory-sync/Users.js

@@ -0,0 +1,135 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const error_1 = require("../controller/error");
+const Base_1 = require("./Base");
+class Users extends Base_1.Base {
+    constructor({ db }) {
+        super({ db });
+    }
+    // Create a new user
+    create(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { first_name, last_name, email, active, raw } = param;
+                const id = this.createId();
+                raw['id'] = id;
+                const user = {
+                    id,
+                    first_name,
+                    last_name,
+                    email,
+                    active,
+                    raw,
+                };
+                yield this.store('users').put(id, user, {
+                    name: 'userName',
+                    value: email,
+                });
+                return { data: user, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Get a user by id
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const user = yield this.store('users').get(id);
+                if (user === null) {
+                    throw new error_1.JacksonError('User not found', 404);
+                }
+                return { data: user, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Update the user data
+    update(id, param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { first_name, last_name, email, active, raw } = param;
+                raw['id'] = id;
+                const user = {
+                    id,
+                    first_name,
+                    last_name,
+                    email,
+                    active,
+                    raw,
+                };
+                yield this.store('users').put(id, user);
+                return { data: user, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Delete a user by id
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.get(id);
+                if (error || !data) {
+                    throw error;
+                }
+                yield this.store('users').delete(id);
+                return { data: null, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Get all users in a directory
+    list({ pageOffset, pageLimit, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const users = (yield this.store('users').getAll(pageOffset, pageLimit));
+                return { data: users, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Search users by userName
+    search(userName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const users = (yield this.store('users').getByIndex({ name: 'userName', value: userName }));
+                return { data: users, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Clear all the users
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: users, error } = yield this.list({});
+            if (!users || error) {
+                return;
+            }
+            yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
+                return this.delete(user.id);
+            })));
+        });
+    }
+}
+exports.Users = Users;

package/dist/directory-sync/WebhookEventsLogger.d.ts

@@ -0,0 +1,13 @@
+import type { Directory, DatabaseStore, WebhookEventLog, DirectorySyncEvent, IWebhookEventsLogger } from '../typings';
+import { Base } from './Base';
+export declare class WebhookEventsLogger extends Base implements IWebhookEventsLogger {
+    constructor({ db }: {
+        db: DatabaseStore;
+    });
+    log(directory: Directory, event: DirectorySyncEvent): Promise<WebhookEventLog>;
+    get(id: string): Promise<WebhookEventLog>;
+    getAll(): Promise<WebhookEventLog[]>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+    updateStatus(log: WebhookEventLog, statusCode: number): Promise<WebhookEventLog>;
+}

package/dist/directory-sync/WebhookEventsLogger.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEventsLogger = void 0;
+const Base_1 = require("./Base");
+class WebhookEventsLogger extends Base_1.Base {
+    constructor({ db }) {
+        super({ db });
+    }
+    log(directory, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = this.createId();
+            const log = Object.assign(Object.assign({}, event), { id, webhook_endpoint: directory.webhook.endpoint, created_at: new Date() });
+            yield this.store('logs').put(id, log);
+            return log;
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.store('logs').get(id);
+        });
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.store('logs').getAll());
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.store('logs').delete(id);
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const events = yield this.getAll();
+            yield Promise.all(events.map((event) => __awaiter(this, void 0, void 0, function* () {
+                yield this.delete(event.id);
+            })));
+        });
+    }
+    updateStatus(log, statusCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updatedLog = Object.assign(Object.assign({}, log), { status_code: statusCode, delivered: statusCode === 200 });
+            yield this.store('logs').put(log.id, updatedLog);
+            return updatedLog;
+        });
+    }
+}
+exports.WebhookEventsLogger = WebhookEventsLogger;

package/dist/directory-sync/events.d.ts

@@ -0,0 +1,7 @@
+import type { DirectorySyncEventType, Directory, User, Group, EventCallback, DirectorySyncEvent, DirectoryConfig, IWebhookEventsLogger } from '../typings';
+export declare const sendEvent: (event: DirectorySyncEventType, payload: {
+    directory: Directory;
+    group?: Group | null;
+    user?: User | null;
+}, callback?: EventCallback) => Promise<void>;
+export declare const handleEventCallback: (directories: DirectoryConfig, webhookEventsLogger: IWebhookEventsLogger) => Promise<(event: DirectorySyncEvent) => Promise<void>>;

package/dist/directory-sync/events.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEventCallback = exports.sendEvent = void 0;
+const utils_1 = require("./utils");
+const axios_1 = __importDefault(require("axios"));
+const sendEvent = (event, payload, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    const eventTransformed = (0, utils_1.transformEventPayload)(event, payload);
+    return callback ? yield callback(eventTransformed) : Promise.resolve();
+});
+exports.sendEvent = sendEvent;
+const handleEventCallback = (directories, webhookEventsLogger) => __awaiter(void 0, void 0, void 0, function* () {
+    return (event) => __awaiter(void 0, void 0, void 0, function* () {
+        const { tenant, product, directory_id: directoryId } = event;
+        const { data: directory } = yield directories.get(directoryId);
+        if (!directory) {
+            return;
+        }
+        const { webhook } = directory;
+        // If there is no webhook, then we don't need to send an event
+        if (webhook.endpoint === '') {
+            return;
+        }
+        webhookEventsLogger.setTenantAndProduct(tenant, product);
+        const headers = yield (0, utils_1.createHeader)(webhook.secret, event);
+        // Log the events only if `log_webhook_events` is enabled
+        const log = directory.log_webhook_events ? yield webhookEventsLogger.log(directory, event) : undefined;
+        let status = 200;
+        try {
+            yield axios_1.default.post(webhook.endpoint, event, {
+                headers,
+            });
+        }
+        catch (err) {
+            status = err.response ? err.response.status : 500;
+        }
+        if (log) {
+            yield webhookEventsLogger.updateStatus(log, status);
+        }
+    });
+});
+exports.handleEventCallback = handleEventCallback;

package/dist/directory-sync/index.d.ts

@@ -0,0 +1,6 @@
+import type { DatabaseStore, DirectorySync, JacksonOption } from '../typings';
+declare const directorySync: ({ db, opts, }: {
+    db: DatabaseStore;
+    opts: JacksonOption;
+}) => Promise<DirectorySync>;
+export default directorySync;

package/dist/directory-sync/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DirectoryConfig_1 = require("./DirectoryConfig");
+const DirectoryUsers_1 = require("./DirectoryUsers");
+const DirectoryGroups_1 = require("./DirectoryGroups");
+const Users_1 = require("./Users");
+const Groups_1 = require("./Groups");
+const utils_1 = require("./utils");
+const request_1 = require("./request");
+const events_1 = require("./events");
+const WebhookEventsLogger_1 = require("./WebhookEventsLogger");
+const directorySync = ({ db, opts, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const directories = new DirectoryConfig_1.DirectoryConfig({ db, opts });
+    const users = new Users_1.Users({ db });
+    const groups = new Groups_1.Groups({ db });
+    const directoryUsers = new DirectoryUsers_1.DirectoryUsers({ directories, users });
+    const directoryGroups = new DirectoryGroups_1.DirectoryGroups({ directories, users, groups });
+    const webhookEventsLogger = new WebhookEventsLogger_1.WebhookEventsLogger({ db });
+    return {
+        users,
+        groups,
+        directories,
+        webhookLogs: webhookEventsLogger,
+        requests: new request_1.DirectorySyncRequestHandler(directoryUsers, directoryGroups),
+        events: {
+            callback: yield (0, events_1.handleEventCallback)(directories, webhookEventsLogger),
+        },
+        providers: () => {
+            return (0, utils_1.getDirectorySyncProviders)();
+        },
+    };
+});
+exports.default = directorySync;

package/dist/directory-sync/request.d.ts

@@ -0,0 +1,7 @@
+import type { DirectorySyncResponse, IDirectoryGroups, IDirectoryUsers, EventCallback, DirectorySyncRequest } from '../typings';
+export declare class DirectorySyncRequestHandler {
+    private directoryUsers;
+    private directoryGroups;
+    constructor(directoryUsers: IDirectoryUsers, directoryGroups: IDirectoryGroups);
+    handle(request: DirectorySyncRequest, callback?: EventCallback): Promise<DirectorySyncResponse>;
+}

package/dist/directory-sync/request.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectorySyncRequestHandler = void 0;
+class DirectorySyncRequestHandler {
+    constructor(directoryUsers, directoryGroups) {
+        this.directoryUsers = directoryUsers;
+        this.directoryGroups = directoryGroups;
+    }
+    handle(request, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (request.resourceType === 'users') {
+                return yield this.directoryUsers.handleRequest(request, callback);
+            }
+            else if (request.resourceType === 'groups') {
+                return yield this.directoryGroups.handleRequest(request, callback);
+            }
+            return { status: 404, data: {} };
+        });
+    }
+}
+exports.DirectorySyncRequestHandler = DirectorySyncRequestHandler;

package/dist/directory-sync/transform.d.ts

@@ -0,0 +1,7 @@
+import { Group, User } from '../typings';
+declare const transformUser: (user: User) => User;
+declare const transformGroup: (group: Group) => Group;
+declare const transformUserGroup: (user: User, group: Group) => User & {
+    group: Group;
+};
+export { transformUser, transformGroup, transformUserGroup };

package/dist/directory-sync/transform.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformUserGroup = exports.transformGroup = exports.transformUser = void 0;
+const transformUser = (user) => {
+    return {
+        id: user.id,
+        first_name: user.first_name,
+        last_name: user.last_name,
+        email: user.email,
+        active: user.active,
+        raw: user.raw,
+    };
+};
+exports.transformUser = transformUser;
+const transformGroup = (group) => {
+    return {
+        id: group.id,
+        name: group.name,
+        raw: group.raw,
+    };
+};
+exports.transformGroup = transformGroup;
+const transformUserGroup = (user, group) => {
+    return Object.assign(Object.assign({}, transformUser(user)), { group: transformGroup(group) });
+};
+exports.transformUserGroup = transformUserGroup;

package/dist/directory-sync/utils.d.ts

@@ -0,0 +1,39 @@
+import type { Directory, DirectorySyncEvent, DirectorySyncEventType, DirectorySyncGroupMember, Group, User } from '../typings';
+declare const parseGroupOperations: (operations: {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value: any;
+}[]) => {
+    action: 'addGroupMember' | 'removeGroupMember';
+    members: DirectorySyncGroupMember[];
+} | {
+    action: 'updateGroupName';
+    displayName: string;
+} | {
+    action: 'unknown';
+};
+declare const toGroupMembers: (users: {
+    user_id: string;
+}[]) => DirectorySyncGroupMember[];
+export declare const parseUserOperations: (operations: {
+    op: 'replace';
+    value: any;
+}) => {
+    action: 'updateUser' | 'unknown';
+    raw: any;
+    attributes: Partial<User>;
+};
+declare const getDirectorySyncProviders: () => {
+    [K: string]: string;
+};
+declare const transformEventPayload: (event: DirectorySyncEventType, payload: {
+    directory: Directory;
+    group?: Group | null;
+    user?: User | null;
+}) => DirectorySyncEvent;
+declare const createHeader: (secret: string, event: DirectorySyncEvent) => Promise<{
+    'Content-Type': string;
+    'BoxyHQ-Signature': string;
+}>;
+declare const createSignatureString: (secret: string, event: DirectorySyncEvent) => Promise<string>;
+export { parseGroupOperations, toGroupMembers, getDirectorySyncProviders, transformEventPayload, createHeader, createSignatureString, };

package/dist/directory-sync/utils.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignatureString = exports.createHeader = exports.transformEventPayload = exports.getDirectorySyncProviders = exports.toGroupMembers = exports.parseGroupOperations = exports.parseUserOperations = void 0;
+const typings_1 = require("../typings");
+const transform_1 = require("./transform");
+const crypto_1 = __importDefault(require("crypto"));
+const parseGroupOperations = (operations) => {
+    const { op, path, value } = operations[0];
+    // Add group members
+    if (op === 'add' && path === 'members') {
+        return {
+            action: 'addGroupMember',
+            members: value,
+        };
+    }
+    // Remove group members
+    if (op === 'remove' && path === 'members') {
+        return {
+            action: 'removeGroupMember',
+            members: value,
+        };
+    }
+    // Remove group members
+    if (op === 'remove' && path.startsWith('members[value eq')) {
+        return {
+            action: 'removeGroupMember',
+            members: [{ value: path.split('"')[1] }],
+        };
+    }
+    // Update group name
+    if (op === 'replace') {
+        return {
+            action: 'updateGroupName',
+            displayName: value.displayName,
+        };
+    }
+    return {
+        action: 'unknown',
+    };
+};
+exports.parseGroupOperations = parseGroupOperations;
+const toGroupMembers = (users) => {
+    return users.map((user) => ({
+        value: user.user_id,
+    }));
+};
+exports.toGroupMembers = toGroupMembers;
+const parseUserOperations = (operations) => {
+    const { op, value } = operations[0];
+    const attributes = {};
+    // Update the user
+    if (op === 'replace') {
+        if ('active' in value) {
+            attributes['active'] = value.active;
+        }
+        if ('name.givenName' in value) {
+            attributes['first_name'] = value['name.givenName'];
+        }
+        if ('name.familyName' in value) {
+            attributes['last_name'] = value['name.familyName'];
+        }
+        return {
+            action: 'updateUser',
+            raw: value,
+            attributes,
+        };
+    }
+    return {
+        action: 'unknown',
+        raw: value,
+        attributes,
+    };
+};
+exports.parseUserOperations = parseUserOperations;
+// List of directory sync providers
+// TODO: Fix the return type
+const getDirectorySyncProviders = () => {
+    return Object.entries(typings_1.DirectorySyncProviders).reduce((acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+exports.getDirectorySyncProviders = getDirectorySyncProviders;
+const transformEventPayload = (event, payload) => {
+    const { directory, group, user } = payload;
+    const { tenant, product, id: directory_id } = directory;
+    const eventPayload = {
+        event,
+        tenant,
+        product,
+        directory_id,
+    };
+    // User events
+    if (['user.created', 'user.updated', 'user.deleted'].includes(event) && user) {
+        eventPayload['data'] = (0, transform_1.transformUser)(user);
+    }
+    // Group events
+    if (['group.created', 'group.updated', 'group.deleted'].includes(event) && group) {
+        eventPayload['data'] = (0, transform_1.transformGroup)(group);
+    }
+    // Group membership events
+    if (['group.user_added', 'group.user_removed'].includes(event) && user && group) {
+        eventPayload['data'] = (0, transform_1.transformUserGroup)(user, group);
+    }
+    return eventPayload;
+};
+exports.transformEventPayload = transformEventPayload;
+// Create request headers
+const createHeader = (secret, event) => __awaiter(void 0, void 0, void 0, function* () {
+    return {
+        'Content-Type': 'application/json',
+        'BoxyHQ-Signature': yield createSignatureString(secret, event),
+    };
+});
+exports.createHeader = createHeader;
+// Create a signature string
+const createSignatureString = (secret, event) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!secret) {
+        return '';
+    }
+    const timestamp = new Date().getTime();
+    const signature = crypto_1.default
+        .createHmac('sha256', secret)
+        .update(`${timestamp}.${JSON.stringify(event)}`)
+        .digest('hex');
+    return `t=${timestamp},s=${signature}`;
+});
+exports.createSignatureString = createSignatureString;

package/dist/index.d.ts

@@ -1,17 +1,20 @@
+import type { DirectorySync, JacksonOption } from './typings';
 import { AdminController } from './controller/admin';
 import { APIController } from './controller/api';
 import { OAuthController } from './controller/oauth';
 import { HealthCheckController } from './controller/health-check';
 import { LogoutController } from './controller/logout';
 import { OidcDiscoveryController } from './controller/oidc-discovery';
-import { JacksonOption } from './typings';
+import { SPSAMLConfig } from './controller/sp-config';
 export declare const controllers: (opts: JacksonOption) => Promise<{
     apiController: APIController;
     oauthController: OAuthController;
     adminController: AdminController;
     logoutController: LogoutController;
     healthCheckController: HealthCheckController;
+    directorySync: DirectorySync;
     oidcDiscoveryController: OidcDiscoveryController;
+    spConfig: SPSAMLConfig;
 }>;
 export default controllers;
 export * from './typings';