"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SamlService = void 0;
const backend_common_1 = require("@n8n/backend-common");
const config_1 = require("@n8n/config");
const db_1 = require("@n8n/db");
const decorators_1 = require("@n8n/decorators");
const di_1 = require("@n8n/di");
const axios_1 = __importDefault(require("axios"));
const crypto_1 = require("crypto");
const n8n_core_1 = require("n8n-core");
const n8n_workflow_1 = require("n8n-workflow");
const auth_error_1 = require("../../errors/response-errors/auth.error");
const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
const claims_context_builder_1 = require("../../modules/provisioning.ee/claims-context.builder");
const provisioning_service_ee_1 = require("../../modules/provisioning.ee/provisioning.service.ee");
const url_service_1 = require("../../services/url.service");
const sso_helpers_1 = require("../../sso.ee/sso-helpers");
const constants_1 = require("./constants");
const invalid_saml_metadata_url_error_1 = require("./errors/invalid-saml-metadata-url.error");
const invalid_saml_metadata_error_1 = require("./errors/invalid-saml-metadata.error");
const saml_helpers_1 = require("./saml-helpers");
const saml_validator_1 = require("./saml-validator");
const service_provider_ee_1 = require("./service-provider.ee");
let SamlService = class SamlService {
    get samlPreferences() {
        return {
            ...this._samlPreferences,
            loginEnabled: (0, sso_helpers_1.isSamlLoginEnabled)(),
            loginLabel: (0, sso_helpers_1.getSamlLoginLabel)(),
        };
    }
    constructor(logger, urlService, validator, userRepository, settingsRepository, instanceSettings, provisioningService, cipher) {
        this.logger = logger;
        this.urlService = urlService;
        this.validator = validator;
        this.userRepository = userRepository;
        this.settingsRepository = settingsRepository;
        this.instanceSettings = instanceSettings;
        this.provisioningService = provisioningService;
        this.cipher = cipher;
        this._samlPreferences = {
            mapping: {
                email: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress',
                firstName: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/firstname',
                lastName: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/lastname',
                userPrincipalName: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn',
            },
            metadata: '',
            metadataUrl: '',
            ignoreSSL: false,
            loginBinding: 'redirect',
            acsBinding: 'post',
            authnRequestsSigned: false,
            signingPrivateKey: undefined,
            signingCertificate: undefined,
            loginEnabled: false,
            loginLabel: 'SAML',
            wantAssertionsSigned: true,
            wantMessageSigned: true,
            relayState: this.urlService.getInstanceBaseUrl(),
            signatureConfig: {
                prefix: 'ds',
                location: {
                    reference: '/samlp:Response/saml:Issuer',
                    action: 'after',
                },
            },
        };
        this.isReloading = false;
    }
    isSignedSamlRequestsEnabled() {
        return process.env.N8N_ENV_FEAT_SIGNED_SAML_REQUESTS === 'true';
    }
    getDecryptedSigningPrivateKey() {
        if (!this.isSignedSamlRequestsEnabled())
            return undefined;
        if (!this._samlPreferences.signingPrivateKey)
            return undefined;
        try {
            return this.cipher.decrypt(this._samlPreferences.signingPrivateKey);
        }
        catch {
            throw new bad_request_error_1.BadRequestError('Failed to decrypt SAML signing private key. The key may be corrupted.');
        }
    }
    isValidPemPrivateKey(pem) {
        return /^-----BEGIN (?:RSA |EC )?PRIVATE KEY-----[\s\S]+-----END (?:RSA |EC )?PRIVATE KEY-----/.test(pem.trim());
    }
    isValidPemCertificate(pem) {
        return /^-----BEGIN CERTIFICATE-----[\s\S]+-----END CERTIFICATE-----/.test(pem.trim());
    }
    validateKeyPairMatch(privateKeyPem, certificatePem) {
        try {
            const pubKeyFromPrivate = (0, crypto_1.createPublicKey)(privateKeyPem);
            const cert = new crypto_1.X509Certificate(certificatePem);
            const pubKeyFromCert = cert.publicKey;
            return pubKeyFromPrivate
                .export({ type: 'spki', format: 'der' })
                .equals(pubKeyFromCert.export({ type: 'spki', format: 'der' }));
        }
        catch {
            return false;
        }
    }
    validateSigningKeyConfiguration(prefs) {
        const isClearingKey = prefs.signingPrivateKey === '';
        const isClearingCert = prefs.signingCertificate === '';
        const isNewKey = !!prefs.signingPrivateKey && prefs.signingPrivateKey !== n8n_workflow_1.CREDENTIAL_BLANKING_VALUE;
        const isNewCert = !!prefs.signingCertificate;
        const hasNewSigningFields = isNewKey || isNewCert;
        if (hasNewSigningFields && !this.isSignedSamlRequestsEnabled()) {
            throw new bad_request_error_1.BadRequestError('SAML request signing is not enabled. Set N8N_ENV_FEAT_SIGNED_SAML_REQUESTS=true to enable this feature.');
        }
        if (!this.isSignedSamlRequestsEnabled())
            return;
        if (isNewKey && !this.isValidPemPrivateKey(prefs.signingPrivateKey)) {
            throw new bad_request_error_1.BadRequestError('Invalid signing private key format. Must be a PEM-encoded private key.');
        }
        if (isNewCert && !this.isValidPemCertificate(prefs.signingCertificate)) {
            throw new bad_request_error_1.BadRequestError('Invalid signing certificate format. Must be a PEM-encoded certificate.');
        }
        const willHaveAuthnRequestsSigned = prefs.authnRequestsSigned ?? this._samlPreferences.authnRequestsSigned;
        if (willHaveAuthnRequestsSigned) {
            const effectiveKey = isClearingKey
                ? undefined
                : isNewKey
                    ? prefs.signingPrivateKey
                    : this.getDecryptedSigningPrivateKey();
            const effectiveCert = isClearingCert
                ? undefined
                : isNewCert
                    ? prefs.signingCertificate
                    : this._samlPreferences.signingCertificate;
            if (!effectiveKey || !effectiveCert) {
                throw new bad_request_error_1.BadRequestError('Both signingPrivateKey and signingCertificate are required when authnRequestsSigned is enabled.');
            }
            if (!this.validateKeyPairMatch(effectiveKey, effectiveCert)) {
                throw new bad_request_error_1.BadRequestError('The signing private key and certificate do not match. Please provide a matching key/certificate pair.');
            }
        }
    }
    async init() {
        try {
            await this.loadFromDbAndApplySamlPreferences(false);
            if ((0, sso_helpers_1.isSamlLicensedAndEnabled)()) {
                await this.validator.init();
                await this.loadSamlify();
                await this.loadFromDbAndApplySamlPreferences(true);
            }
        }
        catch (error) {
            if (error instanceof invalid_saml_metadata_url_error_1.InvalidSamlMetadataUrlError ||
                error instanceof invalid_saml_metadata_error_1.InvalidSamlMetadataError ||
                error instanceof SyntaxError) {
                this.logger.warn(`SAML initialization failed because of invalid metadata in database: ${error.message}. IMPORTANT: Disabling SAML and switching to email-based login for all users. Please review your configuration and re-enable SAML.`);
                await this.reset();
            }
            else {
                throw error;
            }
        }
    }
    async loadSamlify() {
        if (this.samlify === undefined) {
            this.logger.debug('Loading samlify library into memory');
            await this.validator.init();
            this.samlify = await Promise.resolve().then(() => __importStar(require('samlify')));
        }
        this.samlify.setSchemaValidator({
            validate: async (response) => {
                const valid = await this.validator.validateResponse(response);
                if (!valid) {
                    throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError();
                }
            },
        });
    }
    getIdentityProviderInstance(forceRecreate = false) {
        if (this.samlify === undefined) {
            throw new n8n_workflow_1.UnexpectedError('Samlify is not initialized');
        }
        if (!this._samlPreferences.metadata) {
            throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError('No IdP metadata configured. Please provide valid identity provider metadata.');
        }
        if (this.identityProviderInstance === undefined || forceRecreate) {
            this.identityProviderInstance = this.samlify.IdentityProvider({
                metadata: this._samlPreferences.metadata,
            });
        }
        this.validator.validateIdentityProvider(this.identityProviderInstance);
        return this.identityProviderInstance;
    }
    getServiceProviderInstance() {
        if (this.samlify === undefined) {
            throw new n8n_workflow_1.UnexpectedError('Samlify is not initialized');
        }
        return (0, service_provider_ee_1.getServiceProviderInstance)(this._samlPreferences, this.samlify);
    }
    async getLoginRequestUrl(relayState, binding, metadata) {
        await this.loadSamlify();
        if (this.samlify === undefined) {
            throw new n8n_workflow_1.UnexpectedError('Samlify is not initialized');
        }
        let idp;
        if (metadata) {
            const validationResult = await this.validator.validateMetadata(metadata);
            if (!validationResult) {
                throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError();
            }
            idp = this.samlify.IdentityProvider({ metadata });
            this.validator.validateIdentityProvider(idp);
        }
        else {
            idp = this.getIdentityProviderInstance();
        }
        binding ??= this._samlPreferences.loginBinding ?? 'redirect';
        const sp = this.getServiceProviderInstance();
        sp.entitySetting.relayState = relayState ?? this.urlService.getInstanceBaseUrl();
        const loginRequest = sp.createLoginRequest(idp, binding);
        return {
            binding,
            context: binding === 'post' ? loginRequest : loginRequest,
        };
    }
    async handleSamlLogin(req, binding) {
        const { mapped: attributes, raw: rawAttributes } = await this.getAttributesFromLoginResponse(req, binding);
        if (attributes.email) {
            const lowerCasedEmail = attributes.email.toLowerCase();
            if (!(0, db_1.isValidEmail)(lowerCasedEmail)) {
                throw new bad_request_error_1.BadRequestError('Invalid email format');
            }
            const user = await this.userRepository.findOne({
                where: { email: lowerCasedEmail },
                relations: ['authIdentities', 'role'],
            });
            if (user) {
                if (user.authIdentities.find((e) => e.providerType === 'saml' && e.providerId === attributes.userPrincipalName)) {
                    await this.applySsoProvisioning(user, attributes, rawAttributes);
                    return {
                        authenticatedUser: user,
                        attributes,
                        onboardingRequired: false,
                    };
                }
                else {
                    const updatedUser = await (0, saml_helpers_1.updateUserFromSamlAttributes)(user, attributes);
                    const onboardingRequired = !updatedUser.firstName || !updatedUser.lastName;
                    await this.applySsoProvisioning(updatedUser, attributes, rawAttributes);
                    return {
                        authenticatedUser: updatedUser,
                        attributes,
                        onboardingRequired,
                    };
                }
            }
            else {
                if ((0, sso_helpers_1.isSsoJustInTimeProvisioningEnabled)()) {
                    const newUser = await (0, saml_helpers_1.createUserFromSamlAttributes)(attributes);
                    await this.applySsoProvisioning(newUser, attributes, rawAttributes);
                    return {
                        authenticatedUser: newUser,
                        attributes,
                        onboardingRequired: !newUser.firstName || !newUser.lastName,
                    };
                }
            }
        }
        return {
            authenticatedUser: undefined,
            attributes,
            onboardingRequired: false,
        };
    }
    async applySsoProvisioning(user, attributes, rawAttributes) {
        if (await this.provisioningService.isExpressionMappingEnabled()) {
            const context = (0, claims_context_builder_1.buildSamlClaimsContext)(rawAttributes);
            await this.provisioningService.provisionExpressionMappedRolesForUser(user, context);
            return;
        }
        if (attributes?.n8nInstanceRole) {
            await this.provisioningService.provisionInstanceRoleForUser(user, attributes.n8nInstanceRole);
        }
        if (attributes?.n8nProjectRoles) {
            await this.provisioningService.provisionProjectRolesForUser(user.id, attributes.n8nProjectRoles);
        }
    }
    async broadcastReloadSAMLConfigurationCommand() {
        if (this.instanceSettings.isMultiMain) {
            const { Publisher } = await Promise.resolve().then(() => __importStar(require('../../scaling/pubsub/publisher.service')));
            await di_1.Container.get(Publisher).publishCommand({ command: 'reload-saml-config' });
        }
    }
    async reload() {
        if (this.isReloading) {
            this.logger.warn('SAML configuration reload already in progress');
            return;
        }
        this.isReloading = true;
        try {
            this.logger.debug('SAML configuration changed, starting to load it from the database');
            await this.loadFromDbAndApplySamlPreferences(true, false);
            await (0, sso_helpers_1.reloadAuthenticationMethod)();
            const samlLoginEnabled = (0, sso_helpers_1.isSamlLoginEnabled)();
            this.logger.debug(`SAML login is now ${samlLoginEnabled ? 'enabled' : 'disabled'}.`);
            di_1.Container.get(config_1.GlobalConfig).sso.saml.loginEnabled = samlLoginEnabled;
        }
        catch (error) {
            this.logger.error('SAML configuration changed, failed to reload SAML configuration', {
                error,
            });
        }
        finally {
            this.isReloading = false;
        }
    }
    async setSamlPreferences(prefs, tryFallback = false, broadcastReload = true) {
        await this.loadSamlify();
        this.validateSigningKeyConfiguration(prefs);
        const previousMetadataUrl = this._samlPreferences.metadataUrl;
        await this.loadPreferencesWithoutValidation(prefs);
        await this.applyLoadedPreferences(prefs, previousMetadataUrl, tryFallback);
        const result = await this.saveSamlPreferencesToDb();
        if (broadcastReload) {
            await this.broadcastReloadSAMLConfigurationCommand();
        }
        return result;
    }
    async applyLoadedPreferences(prefs, previousMetadataUrl, tryFallback = true) {
        if (prefs.metadataUrl) {
            try {
                const fetchedMetadata = await this.fetchMetadataFromUrl();
                if (fetchedMetadata) {
                    this._samlPreferences.metadata = fetchedMetadata;
                }
                else {
                    throw new invalid_saml_metadata_url_error_1.InvalidSamlMetadataUrlError(prefs.metadataUrl);
                }
            }
            catch (error) {
                this._samlPreferences.metadataUrl = previousMetadataUrl;
                if (!tryFallback) {
                    throw error;
                }
                this.logger.error('SAML initialization detected an invalid metadata URL in database. Trying to initialize from metadata in database if available.', { error });
            }
        }
        else if (prefs.metadata) {
            const validationResult = await this.validator.validateMetadata(prefs.metadata);
            if (!validationResult) {
                throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError();
            }
        }
        if ((0, sso_helpers_1.isSamlLoginEnabled)()) {
            if (this._samlPreferences.metadata) {
                const validationResult = await this.validator.validateMetadata(this._samlPreferences.metadata);
                if (!validationResult) {
                    throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError();
                }
            }
            else {
                throw new invalid_saml_metadata_error_1.InvalidSamlMetadataError();
            }
        }
        this.getIdentityProviderInstance(true);
    }
    async loadPreferencesWithoutValidation(prefs) {
        this._samlPreferences.loginBinding = prefs.loginBinding ?? this._samlPreferences.loginBinding;
        this._samlPreferences.metadata = prefs.metadata ?? this._samlPreferences.metadata;
        this._samlPreferences.mapping = prefs.mapping ?? this._samlPreferences.mapping;
        this._samlPreferences.ignoreSSL = prefs.ignoreSSL ?? this._samlPreferences.ignoreSSL;
        this._samlPreferences.acsBinding = prefs.acsBinding ?? this._samlPreferences.acsBinding;
        this._samlPreferences.signatureConfig =
            prefs.signatureConfig ?? this._samlPreferences.signatureConfig;
        this._samlPreferences.authnRequestsSigned =
            prefs.authnRequestsSigned ?? this._samlPreferences.authnRequestsSigned;
        this._samlPreferences.wantAssertionsSigned =
            prefs.wantAssertionsSigned ?? this._samlPreferences.wantAssertionsSigned;
        this._samlPreferences.wantMessageSigned =
            prefs.wantMessageSigned ?? this._samlPreferences.wantMessageSigned;
        if (prefs.signingCertificate === '') {
            this._samlPreferences.signingCertificate = undefined;
        }
        else {
            this._samlPreferences.signingCertificate =
                prefs.signingCertificate ?? this._samlPreferences.signingCertificate;
        }
        if (prefs.signingPrivateKey !== undefined &&
            prefs.signingPrivateKey !== n8n_workflow_1.CREDENTIAL_BLANKING_VALUE) {
            if (prefs.signingPrivateKey === '') {
                this._samlPreferences.signingPrivateKey = undefined;
            }
            else if (this.isValidPemPrivateKey(prefs.signingPrivateKey)) {
                this._samlPreferences.signingPrivateKey = this.cipher.encrypt(prefs.signingPrivateKey);
            }
            else {
                this._samlPreferences.signingPrivateKey = prefs.signingPrivateKey;
            }
        }
        if (prefs.metadataUrl) {
            this._samlPreferences.metadataUrl = prefs.metadataUrl;
        }
        else if (prefs.metadata) {
            this._samlPreferences.metadataUrl = undefined;
            this._samlPreferences.metadata = prefs.metadata;
        }
        await (0, saml_helpers_1.setSamlLoginEnabled)(prefs.loginEnabled ?? (0, sso_helpers_1.isSamlLoginEnabled)());
        (0, saml_helpers_1.setSamlLoginLabel)(prefs.loginLabel ?? (0, sso_helpers_1.getSamlLoginLabel)());
    }
    async loadFromDbAndApplySamlPreferences(apply = true, broadcastReload = true) {
        const samlPreferences = await this.settingsRepository.findOne({
            where: { key: constants_1.SAML_PREFERENCES_DB_KEY },
        });
        if (samlPreferences) {
            const prefs = (0, n8n_workflow_1.jsonParse)(samlPreferences.value);
            if (prefs) {
                if (apply) {
                    await this.loadSamlify();
                    const previousMetadataUrl = this._samlPreferences.metadataUrl;
                    await this.loadPreferencesWithoutValidation(prefs);
                    await this.applyLoadedPreferences(prefs, previousMetadataUrl);
                    if (broadcastReload) {
                        await this.broadcastReloadSAMLConfigurationCommand();
                    }
                }
                else {
                    await this.loadPreferencesWithoutValidation(prefs);
                }
                return prefs;
            }
        }
        return;
    }
    async saveSamlPreferencesToDb() {
        const samlPreferences = await this.settingsRepository.findOne({
            where: { key: constants_1.SAML_PREFERENCES_DB_KEY },
        });
        const settingsValue = JSON.stringify(this.samlPreferences);
        let result;
        if (samlPreferences) {
            samlPreferences.value = settingsValue;
            result = await this.settingsRepository.save(samlPreferences, {
                transaction: false,
            });
        }
        else {
            result = await this.settingsRepository.save({
                key: constants_1.SAML_PREFERENCES_DB_KEY,
                value: settingsValue,
                loadOnStartup: true,
            }, { transaction: false });
        }
        if (result)
            return (0, n8n_workflow_1.jsonParse)(result.value);
        return;
    }
    async fetchMetadataFromUrl(metadataUrl, ignoreSSL) {
        await this.loadSamlify();
        const url = metadataUrl ?? this._samlPreferences.metadataUrl;
        const shouldIgnoreSSL = ignoreSSL ?? this._samlPreferences.ignoreSSL;
        if (!url)
            throw new bad_request_error_1.BadRequestError('Error fetching SAML Metadata, no Metadata URL set');
        try {
            const httpsAgent = (0, n8n_core_1.createHttpsProxyAgent)(null, url, {
                rejectUnauthorized: !shouldIgnoreSSL,
            });
            const httpAgent = (0, n8n_core_1.createHttpProxyAgent)(null, url);
            const response = await axios_1.default.get(url, {
                httpsAgent,
                httpAgent,
            });
            if (response.status === 200 && response.data) {
                const xml = (await response.data);
                const validationResult = await this.validator.validateMetadata(xml);
                if (!validationResult) {
                    throw new bad_request_error_1.BadRequestError(`Data received from ${url} is not valid SAML metadata.`);
                }
                return xml;
            }
        }
        catch (error) {
            if (error instanceof bad_request_error_1.BadRequestError)
                throw error;
            throw new bad_request_error_1.BadRequestError(`Error fetching SAML Metadata from ${url}: ${error}`);
        }
        return;
    }
    async getAttributesFromLoginResponse(req, binding) {
        let parsedSamlResponse;
        if (!this._samlPreferences.mapping)
            throw new bad_request_error_1.BadRequestError('Error fetching SAML Attributes, no Attribute mapping set');
        try {
            await this.loadSamlify();
            parsedSamlResponse = await this.getServiceProviderInstance().parseLoginResponse(this.getIdentityProviderInstance(), binding, req);
        }
        catch (error) {
            throw new auth_error_1.AuthError(`SAML Authentication failed. Could not parse SAML response. ${error instanceof Error ? error.message : error}`);
        }
        const { attributes, missingAttributes, rawAttributes } = (0, saml_helpers_1.getMappedSamlAttributesFromFlowResult)(parsedSamlResponse, this._samlPreferences.mapping, {
            instanceRole: await this.provisioningService.getInstanceRoleClaimName(),
            projectRoles: await this.provisioningService.getProjectsRolesClaimName(),
        });
        if (!attributes) {
            throw new auth_error_1.AuthError('SAML Authentication failed. Invalid SAML response.');
        }
        if (missingAttributes.length > 0) {
            throw new auth_error_1.AuthError(`SAML Authentication failed. Invalid SAML response (missing attributes: ${missingAttributes.join(', ')}).`);
        }
        return { mapped: attributes, raw: rawAttributes };
    }
    async reset() {
        await (0, saml_helpers_1.setSamlLoginEnabled)(false);
        await this.settingsRepository.delete({ key: constants_1.SAML_PREFERENCES_DB_KEY });
    }
};
exports.SamlService = SamlService;
__decorate([
    (0, decorators_1.OnPubSubEvent)('reload-saml-config'),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", Promise)
], SamlService.prototype, "reload", null);
exports.SamlService = SamlService = __decorate([
    (0, di_1.Service)(),
    __metadata("design:paramtypes", [backend_common_1.Logger,
        url_service_1.UrlService,
        saml_validator_1.SamlValidator,
        db_1.UserRepository,
        db_1.SettingsRepository,
        n8n_core_1.InstanceSettings,
        provisioning_service_ee_1.ProvisioningService,
        n8n_core_1.Cipher])
], SamlService);
//# sourceMappingURL=saml.service.ee.js.map