@atlantjs/arch 1.0.0

package/objects/auth/entities/token/access-token.abstract.has-role.error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenHasRoleError = void 0;
+const application_error_abstract_1 = require("../../../arch/application/errors/application-error.abstract");
+class TokenHasRoleError extends application_error_abstract_1.ApplicationErrorAbstract {
+    constructor(error) {
+        super({
+            className: TokenHasRoleError.name,
+            message: "É necessário informar o clientId para verificar se possui a role",
+            error,
+        });
+    }
+}
+exports.TokenHasRoleError = TokenHasRoleError;

package/objects/auth/entities/token/access-token.abstract.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessTokenAbstract = void 0;
+const token_1 = require("./token");
+const return_type_1 = require("../../../../utils/ducts/return-type");
+const guardian_1 = require("../../../../utils/type-guard/guardian");
+class AccessTokenAbstract extends token_1.Token {
+    constructor(token) {
+        super(token);
+        this.token = token;
+    }
+    hasRoles(roles) {
+        if (guardian_1.Guardian.isEmpty(this.payload.resource_access)) {
+            return (0, return_type_1.Success)(false);
+        }
+        const rolesInToken = this.payload.realm_access.roles;
+        for (const role of roles) {
+            if (guardian_1.Guardian.isFalsy(guardian_1.Guardian.isAnyOf(role, rolesInToken))) {
+                return (0, return_type_1.Success)(false);
+            }
+        }
+        return (0, return_type_1.Success)(true);
+    }
+}
+exports.AccessTokenAbstract = AccessTokenAbstract;

package/objects/auth/entities/token/access-token.abstract.signature-verify.error.d.ts

@@ -0,0 +1,4 @@
+import { ApplicationErrorAbstract } from "../../../arch/application/errors/application-error.abstract";
+export declare class SignatureVerifyError extends ApplicationErrorAbstract {
+    constructor(message: string, error?: any);
+}

package/objects/auth/entities/token/access-token.abstract.signature-verify.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureVerifyError = void 0;
+const application_error_abstract_1 = require("../../../arch/application/errors/application-error.abstract");
+class SignatureVerifyError extends application_error_abstract_1.ApplicationErrorAbstract {
+    constructor(message, error) {
+        super({ className: SignatureVerifyError.name, message, error });
+    }
+}
+exports.SignatureVerifyError = SignatureVerifyError;

package/objects/auth/entities/token/access-token.abstract.type.d.ts

@@ -0,0 +1,44 @@
+import { ClientEnum } from "../../enums/client.enum";
+import { RoleEnum } from "../../enums/role.enum";
+export interface AccessTokenHeader {
+    alg: string;
+    typ: string;
+    kid?: string;
+}
+export type AuthTokenPayload = AccessTokenPayload | RefreshTokenPayload;
+export interface AccessTokenPayload {
+    iss: string;
+    sub: string;
+    aud: string;
+    exp: number;
+    iat: number;
+    resource_access?: {
+        [key in ClientEnum]: {
+            roles: RoleEnum[];
+        };
+    };
+    roles?: RoleEnum[];
+    realm_access: {
+        roles: RoleEnum[];
+    };
+    auth_time: number;
+    name: string;
+    authorization?: {
+        roles?: RoleEnum[];
+        permissions?: [
+            {
+                rsid?: string;
+                rsname?: string;
+                scopes?: string;
+            }
+        ];
+    };
+    email: string;
+}
+export interface RefreshTokenPayload {
+    sub: string;
+    aud: string;
+    exp: number;
+    iat: number;
+    scope: string;
+}

package/objects/auth/entities/token/access-token.abstract.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/objects/auth/entities/token/rotation.d.ts

@@ -0,0 +1,12 @@
+import { RotationConfig } from "./rotation.type";
+export declare class Rotation {
+    private realmUrl;
+    private minTimeBetweenJwksRequests;
+    private jwks;
+    private lastTimeRequesTime;
+    constructor(config: RotationConfig);
+    retrieveJWKs(callback?: unknown): Promise<any>;
+    getJWK(kid: unknown): Promise<string | undefined>;
+    clearCache(): void;
+    private nodeify;
+}

package/objects/auth/entities/token/rotation.js

@@ -0,0 +1,108 @@
+"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.Rotation = void 0;
+const node_url_1 = require("node:url");
+const jwk_to_pem_1 = __importDefault(require("jwk-to-pem"));
+const guardian_1 = require("../../../../utils/type-guard/guardian");
+class Rotation {
+    constructor(config) {
+        this.realmUrl = config.realmUrl;
+        this.minTimeBetweenJwksRequests = config.minTimeBetweenJwksRequests;
+        this.jwks = [];
+        this.lastTimeRequesTime = 0;
+    }
+    retrieveJWKs(callback) {
+        const urlString = `${this.realmUrl}/protocol/openid-connect/certs`;
+        const url = new node_url_1.URL(urlString);
+        // Prepare options for the HTTP request
+        const options = {
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80,
+            path: url.pathname + url.search,
+            method: "GET",
+        };
+        // Choose http or https based on the URL protocol
+        const protocol = url.protocol === "https:" ? require("node:https") : require("node:http");
+        const promise = new Promise((resolve, reject) => {
+            const req = protocol.request(options, (response) => {
+                if (response.statusCode &&
+                    (response.statusCode < 200 || response.statusCode >= 300)) {
+                    return reject(new Error("Error fetching JWK Keys"));
+                }
+                let json = "";
+                response.on("data", (chunk) => {
+                    json += chunk.toString();
+                });
+                response.on("end", () => {
+                    try {
+                        const data = JSON.parse(json);
+                        if (data.error) {
+                            reject(data);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    }
+                    catch (e) {
+                        reject(new Error("Failed to parse JSON"));
+                    }
+                });
+            });
+            req.on("error", reject);
+            req.end();
+        });
+        return this.nodeify(promise, callback);
+    }
+    getJWK(kid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.jwks.find((key) => {
+                return key.kid === kid;
+            });
+            if (guardian_1.Guardian.isNotEmpty(key)) {
+                return new Promise((resolve, reject) => {
+                    resolve((0, jwk_to_pem_1.default)(key));
+                });
+            }
+            const currentTime = new Date().getTime() / 1000;
+            if (currentTime >
+                this.lastTimeRequesTime + this.minTimeBetweenJwksRequests) {
+                return this.retrieveJWKs()
+                    .then((publicKeys) => {
+                    this.lastTimeRequesTime = currentTime;
+                    this.jwks = publicKeys.keys;
+                    const convertedKey = (0, jwk_to_pem_1.default)(this.jwks.find((key) => {
+                        return key.kid === kid;
+                    }));
+                    return convertedKey;
+                })
+                    .catch(() => {
+                    return undefined;
+                });
+            }
+            console.error("Not enough time elapsed since the last request, blocking the request");
+        });
+    }
+    clearCache() {
+        this.jwks.length = 0;
+    }
+    nodeify(promise, cb) {
+        if (typeof cb !== "function")
+            return promise;
+        return promise
+            .then((res) => cb(null, res))
+            .catch((err) => cb(err));
+    }
+}
+exports.Rotation = Rotation;

package/objects/auth/entities/token/rotation.type.d.ts

@@ -0,0 +1,5 @@
+export interface RotationConfig {
+    realmUrl: string;
+    minTimeBetweenJwksRequests: number;
+    publicKey: string;
+}

package/objects/auth/entities/token/rotation.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/objects/auth/entities/token/token.d.ts

@@ -0,0 +1,16 @@
+import { JwtPayload } from "jsonwebtoken";
+import { TokenHeader } from "./token.type";
+import { Optional } from "../../../../utils/ducts/optional-type";
+import { Return } from "../../../../utils/ducts/return-type";
+export declare class Token<TokenPayload extends JwtPayload> {
+    private _header;
+    private _token;
+    private _payload;
+    constructor(token: string);
+    static isValid(token: string): boolean;
+    getClaim<T>(key: string): Optional<T>;
+    get header(): TokenHeader;
+    get payload(): TokenPayload;
+    isExpired(): Return<boolean, undefined>;
+    toString(): string;
+}

package/objects/auth/entities/token/token.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const optional_type_1 = require("../../../../utils/ducts/optional-type");
+const return_type_1 = require("../../../../utils/ducts/return-type");
+const guardian_1 = require("../../../../utils/type-guard/guardian");
+class Token {
+    constructor(token) {
+        this._token = token.replace(/^bearer/i, "").trim();
+        const tokenParts = this._token.split(".");
+        this._header = JSON.parse(Buffer.from(tokenParts[0], "base64").toString());
+        const payload = jsonwebtoken_1.default.decode(this._token);
+        if (guardian_1.Guardian.isEmpty(payload) || guardian_1.Guardian.isTypeOf(payload, "string")) {
+            throw new Error("Invalid token");
+        }
+        this._payload = payload;
+    }
+    static isValid(token) {
+        try {
+            new Token(token);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    getClaim(key) {
+        return (0, optional_type_1.Optional)(this._payload[key]);
+    }
+    get header() {
+        return this._header;
+    }
+    get payload() {
+        return this._payload;
+    }
+    isExpired() {
+        if (guardian_1.Guardian.isEmpty(this._payload.exp)) {
+            return (0, return_type_1.Success)(false);
+        }
+        return (0, return_type_1.Success)(this._payload.exp * 1000 < Date.now());
+    }
+    toString() {
+        return this._token;
+    }
+}
+exports.Token = Token;

package/objects/auth/entities/token/token.type.d.ts

@@ -0,0 +1,5 @@
+export interface TokenHeader {
+    alg: string;
+    typ: string;
+    kid?: string;
+}

package/objects/auth/entities/token/token.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/objects/auth/entities/user/enums/user-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum UserStatusEnum {
+    active = "active",
+    inactive = "inactive"
+}

package/objects/auth/entities/user/enums/user-status.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatusEnum = void 0;
+var UserStatusEnum;
+(function (UserStatusEnum) {
+    UserStatusEnum["active"] = "active";
+    UserStatusEnum["inactive"] = "inactive";
+})(UserStatusEnum || (exports.UserStatusEnum = UserStatusEnum = {}));

package/objects/auth/entities/user/password/password.abstract.d.ts

@@ -0,0 +1,8 @@
+import { PasswordPolicyResult } from "./password.abstract.type";
+export declare abstract class PasswordAbstract {
+    private readonly password;
+    private readonly validationSteps;
+    constructor(password: string);
+    protected validate(password: string): PasswordPolicyResult;
+    toString(): string;
+}

package/objects/auth/entities/user/password/password.abstract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordAbstract = void 0;
+const with_at_least_one_letter_step_1 = require("./steps/with-at-least-one-letter-step");
+const with_at_least_one_number_digit_step_1 = require("./steps/with-at-least-one-number-digit-step");
+const with_at_least_one_special_char_step_1 = require("./steps/with-at-least-one-special-char-step");
+const with_length_step_1 = require("./steps/with-length-step");
+const guardian_1 = require("../../../../../utils/type-guard/guardian");
+class PasswordAbstract {
+    constructor(password) {
+        this.password = password;
+        this.validationSteps = [
+            new with_at_least_one_letter_step_1.WithAtLeastOneLetterStep(),
+            new with_at_least_one_number_digit_step_1.WithAtLeastOneNumberDigitStep(),
+            new with_at_least_one_special_char_step_1.WithAtLeastOneSpecialCharStep(),
+            new with_length_step_1.WithLengthStep({ min: 6, max: 999 }),
+        ];
+        const { valid, validationStepsResults } = this.validate(this.password);
+        if (guardian_1.Guardian.isFalsy(valid)) {
+            throw new Error(`Password is invalid: ${validationStepsResults.map((result) => result.name)}`);
+        }
+    }
+    validate(password) {
+        if (guardian_1.Guardian.isEqual(this.validationSteps.length, 0)) {
+            throw new Error("No validations found");
+        }
+        const validationStepsResults = [];
+        for (const step of this.validationSteps) {
+            validationStepsResults.push(step.validate(password));
+        }
+        const valid = validationStepsResults.every((result) => result.valid);
+        return {
+            valid,
+            validationStepsResults,
+        };
+    }
+    toString() {
+        return this.password;
+    }
+}
+exports.PasswordAbstract = PasswordAbstract;

package/objects/auth/entities/user/password/password.abstract.type.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStepResult } from "./validation-step.type";
+export interface PasswordPolicyResult {
+    valid: boolean;
+    validationStepsResults: ValidationStepResult[];
+}

package/objects/auth/entities/user/password/password.abstract.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/objects/auth/entities/user/password/steps/not-allowing-consecutive-chars-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingConsecutiveCharsStepOptions {
+    maxAllowedConsecutiveChars: number;
+}
+export declare class NotAllowingConsecutiveCharsStep extends ValidationStep {
+    private readonly params;
+    constructor(params: NotAllowingConsecutiveCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+    private getMaxNumberOfConsecutiveChars;
+}

package/objects/auth/entities/user/password/steps/not-allowing-consecutive-chars-step.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingConsecutiveCharsStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingConsecutiveCharsStep extends validation_step_1.ValidationStep {
+    constructor(params) {
+        super();
+        this.params = params;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfConsecutiveChars(password) <=
+                this.params.maxAllowedConsecutiveChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfConsecutiveChars(password) {
+        let numberOfConsecutiveChars = 1;
+        let maxNumberOfConsecutiveChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (Math.abs(previousChar.charCodeAt(0) - char.charCodeAt(0)) === 1) {
+                numberOfConsecutiveChars += 1;
+            }
+            else {
+                maxNumberOfConsecutiveChars = Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+                numberOfConsecutiveChars = 1;
+            }
+        }
+        return Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+    }
+}
+exports.NotAllowingConsecutiveCharsStep = NotAllowingConsecutiveCharsStep;

package/objects/auth/entities/user/password/steps/not-allowing-date-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingDateStep extends ValidationStep {
+    private readonly notAllowedDate;
+    constructor(notAllowedDate: Date);
+    validate(password: string): ValidationStepResult;
+    private possibleDateCombinations;
+    private buildDayFormats;
+    private buildMonthFormats;
+    private buildYearFormat;
+}

package/objects/auth/entities/user/password/steps/not-allowing-date-step.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingDateStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingDateStep extends validation_step_1.ValidationStep {
+    constructor(notAllowedDate) {
+        super();
+        this.notAllowedDate = notAllowedDate;
+    }
+    validate(password) {
+        const cleanPassword = password.replace(/[^\w]/gi, "");
+        const result = this.possibleDateCombinations().every((dateFormat) => !cleanPassword.includes(dateFormat.toLowerCase()));
+        return {
+            valid: result,
+            name: this.name,
+        };
+    }
+    possibleDateCombinations() {
+        const formats = [];
+        this.buildDayFormats().forEach((day) => {
+            this.buildMonthFormats().forEach((month) => {
+                this.buildYearFormat().forEach((year) => {
+                    formats.push(`${day}${month}`);
+                    formats.push(`${month}${day}`);
+                    formats.push(`${day}${month}${year}`);
+                    formats.push(`${month}${day}${year}`);
+                    formats.push(`${year}${month}${day}`);
+                });
+            });
+        });
+        return [...new Set(formats)];
+    }
+    buildDayFormats() {
+        const day = this.notAllowedDate.getUTCDate();
+        const dayLength = 2;
+        return [
+            ...new Set([day.toString(), day.toString().padStart(dayLength, "0")]),
+        ];
+    }
+    buildMonthFormats() {
+        const month = this.notAllowedDate.getUTCMonth() + 1;
+        const monthLength = 2;
+        return [
+            ...new Set([
+                month.toString(),
+                month.toString().padStart(monthLength, "0"),
+            ]),
+        ];
+    }
+    buildYearFormat() {
+        const year = this.notAllowedDate.getUTCFullYear();
+        const abbreviateYearLength = 2;
+        return [
+            ...new Set([
+                year.toString(),
+                year.toString().slice(-abbreviateYearLength),
+            ]),
+        ];
+    }
+}
+exports.NotAllowingDateStep = NotAllowingDateStep;

package/objects/auth/entities/user/password/steps/not-allowing-phone-step.d.ts

@@ -0,0 +1,7 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingPhoneStep extends ValidationStep {
+    private readonly notAllowedPhone?;
+    constructor(phone: string);
+    validate(password: string): ValidationStepResult;
+}

package/objects/auth/entities/user/password/steps/not-allowing-phone-step.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingPhoneStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingPhoneStep extends validation_step_1.ValidationStep {
+    constructor(phone) {
+        super();
+        const matches = phone.match(/\d{4}\-?\d{4}$/);
+        if (matches) {
+            this.notAllowedPhone = matches[0].replace(/\-/, "");
+        }
+    }
+    validate(password) {
+        if (!this.notAllowedPhone) {
+            return {
+                valid: true,
+                name: this.name,
+            };
+        }
+        const cleanPassword = password.replace(/[\-\s]/gi, "");
+        return {
+            valid: !cleanPassword.includes(this.notAllowedPhone),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingPhoneStep = NotAllowingPhoneStep;

package/objects/auth/entities/user/password/steps/not-allowing-repeated-chars-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingRepeatedCharsStepOptions {
+    maxAllowedRepeatedChars: number;
+}
+export declare class NotAllowingRepeatedCharsStep extends ValidationStep {
+    private readonly options;
+    constructor(options: NotAllowingRepeatedCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+    private getMaxNumberOfRepeatedChars;
+}

package/objects/auth/entities/user/password/steps/not-allowing-repeated-chars-step.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingRepeatedCharsStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingRepeatedCharsStep extends validation_step_1.ValidationStep {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfRepeatedChars(password) <=
+                this.options.maxAllowedRepeatedChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfRepeatedChars(password) {
+        let numberOfRepeatedChars = 1;
+        let maxNumberOfRepeatedChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (previousChar === char) {
+                numberOfRepeatedChars += 1;
+            }
+            else {
+                maxNumberOfRepeatedChars = Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+                numberOfRepeatedChars = 1;
+            }
+        }
+        return Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+    }
+}
+exports.NotAllowingRepeatedCharsStep = NotAllowingRepeatedCharsStep;

package/objects/auth/entities/user/password/steps/not-allowing-string-step.d.ts

@@ -0,0 +1,7 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingStringStep extends ValidationStep {
+    private readonly forbiddenString;
+    constructor(forbiddenString: string);
+    validate(password: string): ValidationStepResult;
+}

package/objects/auth/entities/user/password/steps/not-allowing-string-step.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingStringStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingStringStep extends validation_step_1.ValidationStep {
+    constructor(forbiddenString) {
+        super();
+        this.forbiddenString = forbiddenString;
+    }
+    validate(password) {
+        return {
+            valid: !password
+                .toLowerCase()
+                .includes(this.forbiddenString.toLowerCase()),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingStringStep = NotAllowingStringStep;

package/objects/auth/entities/user/password/steps/not-allowing-these-chars-step.d.ts

@@ -0,0 +1,10 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingTheseCharsStepOptions {
+    notAllowedCharsList: string[];
+}
+export declare class NotAllowingTheseCharsStep extends ValidationStep {
+    private readonly options;
+    constructor(options: NotAllowingTheseCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+}