zibri 1.2.0 → 1.3.0

package/dist/index.d.mts

@@ -1,34 +1,103 @@
 import { Request, Response, Express, NextFunction } from 'express';
-import { EntitySchemaRelationOptions, DataSourceOptions as DataSourceOptions$1, ColumnType as ColumnType$1, QueryRunner, FindOneOptions as FindOneOptions$1, FindManyOptions, Repository as Repository$1, FindOptionsWhere, DataSource as DataSource$1, EntitySchema, EntitySchemaColumnOptions } from 'typeorm';
-import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel';
 import { oas31 } from 'openapi3-ts';
+import { EntitySchemaRelationOptions, DataSourceOptions as DataSourceOptions$1, ColumnType as ColumnType$1, QueryRunner, FindOneOptions as FindOneOptions$1, FindManyOptions, Repository as Repository$1, FindOptionsWhere, EntityTarget, EntityMetadata as EntityMetadata$1, DataSource as DataSource$1, EntitySchema, EntitySchemaColumnOptions, TableColumnOptions } from 'typeorm';
+import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel';
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import { SecuritySchemeObject } from 'openapi3-ts/dist/oas31';
+import { JwtHeader, Secret, SignOptions } from 'jsonwebtoken';
 
-interface DataSourceServiceInterface {
-    init: () => Promise<void>;
+type Newable<T> = new (...args: any[]) => T;
+
+type DeepPartial<T> = T | (T extends (infer U)[] ? DeepPartial<U>[] : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer M> ? Set<DeepPartial<M>> : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T);
+
+type OmitStrict<T extends object, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+type Version = `${number}.${number}.${number}`;
+
+declare enum HttpMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete"
 }
 
-declare class DataSourceService implements DataSourceServiceInterface {
+declare enum HttpStatus {
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_FOUND_ERROR = 404,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401
+}
+
+declare enum MimeType {
+    JSON = "application/json",
+    HTML = "text/html"
+}
+declare function isMimeType(value: string): value is MimeType;
+
+type KnownHeader = 'Accept' | 'Accept-Encoding' | 'Authorization' | 'Cache-Control' | 'Content-Length' | 'Content-Type' | 'Cookie' | 'Host' | 'Origin' | 'Referer' | 'User-Agent' | 'X-Requested-With' | 'X-Forwarded-For' | 'X-Forwarded-Host' | 'X-Forwarded-Proto' | 'X-Real-IP' | 'X-Correlation-ID' | 'If-None-Match' | 'If-Modified-Since' | 'Connection' | 'DNT' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'TE';
+
+type Header = KnownHeader | (string & {});
+
+type HttpRequest = Request;
+
+type HttpResponse = Response;
+
+type Route = `/${string}`;
+type ControllerRouteConfiguration = {
+    httpMethod: HttpMethod;
+    route: Route;
+    controllerMethod: string;
+};
+
+type RouteConfiguration = {
+    httpMethod: HttpMethod;
+    route: Route;
+    handler: (req: HttpRequest, res: HttpResponse) => unknown | Promise<unknown>;
+};
+
+interface RouterInterface {
+    registerController: <T extends Object>(controllerClass: Newable<T>, ...params: any[]) => void;
+    register: (route: RouteConfiguration, ...params: any[]) => void;
+    attachTo: (app: ZibriApplication, ...params: any[]) => void;
+}
+
+declare class Router implements RouterInterface {
+    private readonly router;
     private readonly logger;
+    private readonly parser;
+    private readonly validationService;
+    private readonly authService;
     constructor();
-    init(): Promise<void>;
-    private checkForOrphanedEntities;
+    attachTo(app: ZibriApplication): void;
+    register(route: RouteConfiguration): void;
+    registerController<T extends Object>(controllerClass: Newable<T>): void;
+    private routeToRequestHandler;
+    private controllerRouteToRequestHandler;
+    private resolveRouteParams;
 }
 
-declare function DataSource(): ClassDecorator;
+declare function Controller(baseRoute: Route): ClassDecorator;
+
+declare function Get(path?: Route): MethodDecorator;
+
+declare function Post(path?: Route): MethodDecorator;
+
+declare function Delete(path?: Route): MethodDecorator;
+
+declare function Patch(path?: Route): MethodDecorator;
+
+type BaseParamMetadata = {
+    name: string;
+};
 
 type BasePropertyMetadata = {
     required: boolean;
     description: string | undefined;
 };
 
-type Newable<T> = new (...args: any[]) => T;
-
-type DeepPartial<T> = T | (T extends (infer U)[] ? DeepPartial<U>[] : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer M> ? Set<DeepPartial<M>> : T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T);
-
-type OmitStrict<T extends object, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-
 type StringFormat = 'uuid' | 'email';
 type StringPropertyMetadata = BasePropertyMetadata & {
     type: 'string';
@@ -52,12 +121,12 @@ type ObjectPropertyMetadata = BasePropertyMetadata & {
 type ObjectPropertyMetadataInput = Partial<OmitStrict<ObjectPropertyMetadata, 'type'>> & Pick<ObjectPropertyMetadata, 'cls'>;
 
 type BaseEntity = {
-    id: string | number;
+    id: string;
 };
 
 type ArrayPropertyMetadata = BasePropertyMetadata & {
     type: 'array';
-    items: PropertyMetadata;
+    items: Exclude<PropertyMetadata, RelationMetadata<BaseEntity>>;
 };
 type ArrayItemPropertyType = Exclude<PropertyMetadata['type'], RelationMetadata<BaseEntity>['type']>;
 type ArrayPropertyItemMetadata = PropertyMetadataInput & {
@@ -149,6 +218,350 @@ declare function PickType<T, K extends keyof T>(Base: Newable<T>, keys: readonly
 
 declare function OmitType<T, K extends keyof T>(Base: Newable<T>, keys: readonly K[]): Newable<Omit<T, K>>;
 
+type StringParamMetadata = BaseParamMetadata & OmitStrict<StringPropertyMetadata, 'primary'>;
+type StringParamMetadataInput = Partial<OmitStrict<StringParamMetadata, 'name'>>;
+
+type NumberParamMetadata = BaseParamMetadata & OmitStrict<NumberPropertyMetadata, 'primary'>;
+type NumberParamMetadataInput = Partial<OmitStrict<NumberParamMetadata, 'name'>>;
+
+type BooleanParamMetadata = BaseParamMetadata & BooleanPropertyMetadata;
+type BooleanParamMetadataInput = Partial<OmitStrict<BooleanParamMetadata, 'name'>>;
+
+type DateParamMetadata = BaseParamMetadata & DatePropertyMetadata;
+type DateParamMetadataInput = Partial<OmitStrict<DateParamMetadata, 'name'>>;
+
+type ObjectParamMetadata = BaseParamMetadata & ObjectPropertyMetadata;
+type ObjectParamMetadataInput = Partial<OmitStrict<ObjectParamMetadata, 'name'>> & Pick<ObjectParamMetadata, 'cls'>;
+
+type ArrayParamMetadata = BaseParamMetadata & ArrayPropertyMetadata;
+type ArrayParamMetadataInput = Partial<OmitStrict<ArrayParamMetadata, 'type' | 'items'>> & {
+    items: QueryParamMetadataInput & Pick<QueryParamMetadata, 'type'>;
+};
+
+type PathParamMetadata = StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata;
+type PathParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput;
+type QueryParamMetadata = StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata | ObjectParamMetadata | ArrayParamMetadata;
+type QueryParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput | ObjectParamMetadataInput | ArrayParamMetadataInput;
+type HeaderParamMetadata = (StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata | ObjectParamMetadata | ArrayParamMetadata) & {
+    name: Header;
+};
+type HeaderParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput | ObjectParamMetadataInput | ArrayParamMetadataInput;
+declare namespace Param {
+    function path(name: string, options?: PathParamMetadataInput): ParameterDecorator;
+    function query(name: string, options?: QueryParamMetadataInput): ParameterDecorator;
+    function header(name: Header, options?: HeaderParamMetadataInput): ParameterDecorator;
+}
+
+type BodyMetadata = BasePropertyMetadata & {
+    modelClass: Newable<unknown>;
+    index: number;
+    name: string;
+};
+type BodyMetadataInput = Partial<OmitStrict<BodyMetadata, 'modelClass' | 'index' | 'name'>>;
+declare function Body(modelClass: Newable<unknown>, options?: BodyMetadataInput): ParameterDecorator;
+
+type OpenApiDefinition = oas31.OpenAPIObject;
+type OpenApiPaths = oas31.PathsObject;
+type OpenApiOperation = oas31.OperationObject;
+type OpenApiParameter = (oas31.ParameterObject | oas31.ReferenceObject);
+type OpenApiRequestBodyObject = oas31.RequestBodyObject;
+type OpenApiSchemaObject = oas31.SchemaObject;
+type OpenApiSecuritySchemeObject = oas31.SecuritySchemeObject;
+type OpenApiSecurityRequirementObject = oas31.SecurityRequirementObject;
+
+interface OpenApiServiceInterface {
+    readonly openApiRoute: Route;
+    attachTo: (app: ZibriApplication) => void;
+    createOpenApiDefinition: (app: ZibriApplication) => OpenApiDefinition;
+}
+
+declare class OpenApiService implements OpenApiServiceInterface {
+    readonly openApiRoute: Route;
+    private readonly logger;
+    private readonly assetService;
+    private readonly authService;
+    constructor();
+    attachTo(app: ZibriApplication): void;
+    createOpenApiDefinition(): OpenApiDefinition;
+    private resolveSecuritySchemes;
+    private resolveOpenApiPaths;
+    private resolveOperationSecurity;
+    private buildOpenApiBody;
+    private buildOpenApiSchemaForProperties;
+    private buildParameters;
+    private paramToSchema;
+}
+
+type BaseUser<Role extends string> = BaseEntity & {
+    email: string;
+    roles: Role[];
+};
+
+interface AuthStrategyInterface<RoleType extends string, UserType extends BaseUser<RoleType>, AuthDataType, CredentialType> {
+    init: () => void;
+    resolveUser: (request: HttpRequest) => Promise<UserType | undefined>;
+    login: (credentials: CredentialType) => Promise<AuthDataType>;
+    isLoggedIn: (request: HttpRequest) => Promise<boolean>;
+    hasRole: (request: HttpRequest, allowedRoles: RoleType[]) => Promise<boolean>;
+    securityScheme: OpenApiSecuritySchemeObject;
+    name: string;
+}
+
+type AuthStrategies = Newable<AuthStrategyInterface<string, BaseUser<string>, any, any>>[];
+
+type IsLoggedInMetadata = {
+    allowedStrategies?: AuthStrategies;
+};
+type SkipIsLoggedInMetadata = {};
+
+interface UserRepositoryInterface<RoleType extends string, UserType extends BaseUser<RoleType>, CredentialsType> {
+    findById: (id: UserType['id']) => Promise<UserType>;
+    findByEmail: (email: UserType['email']) => Promise<UserType>;
+    resolveCredentialsFor: (user: UserType) => Promise<CredentialsType>;
+}
+
+type UserRepositories = Newable<UserRepositoryInterface<string, BaseUser<string>, any>>[];
+
+type HasRoleMetadata = {
+    allowedRoles: string[];
+    allowedStrategies?: AuthStrategies;
+};
+type SkipHasRoleMetadata = {};
+
+type IsNotLoggedInMetadata = {
+    allowedStrategies?: AuthStrategies;
+};
+type SkipIsNotLoggedInMetadata = {};
+
+interface HasRoleFn {
+    (allowedRoles: string[], allowedStrategies?: AuthStrategies): MethodDecorator & ClassDecorator;
+    skip: () => MethodDecorator & ClassDecorator;
+}
+
+interface IsLoggedInFn {
+    (allowedStrategies?: AuthStrategies): MethodDecorator & ClassDecorator;
+    skip: () => MethodDecorator & ClassDecorator;
+}
+
+interface IsNotLoggedInFn {
+    (allowedStrategies?: AuthStrategies): MethodDecorator & ClassDecorator;
+    skip: () => MethodDecorator & ClassDecorator;
+}
+
+declare namespace Auth {
+    const isLoggedIn: IsLoggedInFn;
+    const isNotLoggedIn: IsNotLoggedInFn;
+    const hasRole: HasRoleFn;
+}
+
+/**
+ * Marks the given class as a user repository.
+ * This registers it to be injected directly, without using "@InjectRepository".
+ *
+ * If you store your user in a database, you probably want to extend "Repository<UserEntityClass>" and implement the constructor, so that everything works:.
+ *
+ * ```ts
+ * \@UserRepo(User)
+ * export class UserRepository extends Repository<User, UserCreateData>
+ *     implements UserRepositoryInterface<Roles, User, JwtCredentials> {
+ *
+ *     constructor(
+ *         \@InjectRepository(User)
+ *         repo: Repository<User> // <-- The built in repository from zibri
+ *     ) {
+ *         super(User, repo);
+ *     }
+ *     // ...
+ * }
+ * ```
+ */
+declare function UserRepo<T extends string, EntityType extends Newable<BaseUser<T>>>(): ClassDecorator;
+
+type CurrentUserMetadata = {
+    index: number;
+    optional: boolean;
+    allowedStrategies?: AuthStrategies;
+};
+declare function CurrentUser(optional?: boolean, allowedStrategies?: AuthStrategies): ParameterDecorator;
+
+interface AuthServiceInterface {
+    readonly strategies: AuthStrategies;
+    init: (strategies: AuthStrategies) => void;
+    checkAccess: (controllerClass: Newable<Object>, controllerMethod: string, req: HttpRequest) => Promise<void>;
+    isLoggedIn: (request: HttpRequest, allowedStrategies: AuthStrategies) => Promise<boolean>;
+    hasRole: (request: HttpRequest, allowedStrategies: AuthStrategies, allowedRoles: string[]) => Promise<boolean>;
+    resolveIsLoggedInMetadata: (controllerClass: Newable<Object>, controllerMethod: string) => IsLoggedInMetadata | undefined;
+    resolveIsNotLoggedInMetadata: (controllerClass: Newable<Object>, controllerMethod: string) => IsNotLoggedInMetadata | undefined;
+    resolveHasRoleMetadata: (controllerClass: Newable<Object>, controllerMethod: string) => HasRoleMetadata | undefined;
+    login: <Role extends string, UserType extends BaseUser<Role>, AuthDataType, CredentialsType>(strategy: Newable<AuthStrategyInterface<Role, UserType, AuthDataType, CredentialsType>>, credentials: CredentialsType) => Promise<AuthDataType>;
+    getCurrentUser: <Role extends string, UserType extends BaseUser<Role>, B extends boolean = false>(request: HttpRequest, strategies: AuthStrategies, optional: B) => Promise<B extends true ? UserType | undefined : UserType>;
+}
+
+declare class AuthService implements AuthServiceInterface {
+    private readonly logger;
+    readonly strategies: AuthStrategies;
+    constructor();
+    init(authStrategies: AuthStrategies): void;
+    login<Role extends string, UserType extends BaseUser<Role>, AuthDataType, CredentialsType>(strategy: Newable<AuthStrategyInterface<Role, UserType, AuthDataType, CredentialsType>>, credentials: CredentialsType): Promise<AuthDataType>;
+    getCurrentUser<Role extends string, UserType extends BaseUser<Role>, B extends boolean = false>(request: HttpRequest, allowedStrategies: AuthStrategies, optional: B): Promise<B extends true ? UserType | undefined : UserType>;
+    checkAccess(controllerClass: Newable<Object>, controllerMethod: string, request: HttpRequest): Promise<void>;
+    isLoggedIn(request: HttpRequest, allowedStrategies: AuthStrategies): Promise<boolean>;
+    hasRole(request: HttpRequest, allowedStrategies: AuthStrategies, allowedRoles: string[]): Promise<boolean>;
+    resolveIsLoggedInMetadata(controllerClass: Newable<Object>, controllerMethod: string): IsLoggedInMetadata | undefined;
+    resolveIsNotLoggedInMetadata(controllerClass: Newable<Object>, controllerMethod: string): IsNotLoggedInMetadata | undefined;
+    resolveHasRoleMetadata(controllerClass: Newable<Object>, controllerMethod: string): HasRoleMetadata | undefined;
+}
+
+type AccessTokenPayload<Role extends string, T extends BaseUser<Role>> = {
+    /**
+     * The id of the user.
+     */
+    id: T['id'];
+    email: T['email'];
+    /**
+     * The roles of the user.
+     */
+    roles: T['roles'];
+};
+
+declare class Jwt {
+    /**
+     * The token value.
+     */
+    value: string;
+    /**
+     * The timestamp at which the token is no longer valid.
+     */
+    expirationDate: Date;
+}
+
+declare class JwtAuthData<Role extends string> {
+    userId: string;
+    accessToken: Jwt;
+    refreshToken: Jwt;
+    roles: Role[];
+}
+
+declare class JwtCredentials implements BaseEntity {
+    id: string;
+    userId: string;
+    username: string;
+    password: string;
+}
+declare const JwtCredentialsDto_base: Newable<Omit<JwtCredentials, "id" | "userId">>;
+declare class JwtCredentialsDto extends JwtCredentialsDto_base {
+}
+
+declare class JwtAuthStrategy<RoleType extends string, UserType extends BaseUser<RoleType> = BaseUser<RoleType>> implements AuthStrategyInterface<RoleType, UserType, JwtAuthData<RoleType>, JwtCredentialsDto> {
+    readonly name: string;
+    readonly securityScheme: SecuritySchemeObject;
+    private readonly accessTokenSecret;
+    private readonly accessTokenExpiresInMs;
+    private readonly refreshTokenSecret;
+    private readonly refreshTokenExpiresInMs;
+    private readonly userService;
+    constructor();
+    init(): void;
+    private checkForEntities;
+    login(credentials: JwtCredentialsDto): Promise<JwtAuthData<RoleType>>;
+    resolveUser(request: HttpRequest): Promise<UserType | undefined>;
+    isLoggedIn(request: HttpRequest): Promise<boolean>;
+    hasRole(request: HttpRequest, allowedRoles: RoleType[]): Promise<boolean>;
+    private extractTokenFromRequest;
+    private generateAccessToken;
+    private generateRefreshToken;
+}
+
+/**
+ * An encoded token.
+ */
+type EncodedAccessToken<Role extends string> = {
+    /**
+     * The header of the jwt, contains mostly metadata.
+     */
+    header: JwtHeader;
+    /**
+     * The payload of the jwt, everything that was put inside the token when generating it can be found here.
+     */
+    payload: AccessTokenPayload<Role, BaseUser<Role>>;
+    /**
+     * The signature of the jwt.
+     */
+    signature: string;
+};
+
+/**
+ * Encapsulates functionality of the jsonwebtoken package.
+ */
+declare abstract class JwtUtilities {
+    /**
+     * Asynchronously sign the given payload into a JSON Web Token string payload.
+     * @param payload - Any info that should be put inside the token.
+     * @param secret - The secret used to encrypt the token.
+     * @param options - Additional options like "expiresIn".
+     * @returns A promise of the jwt.
+     */
+    static sign(payload: string | Buffer | object, secret: Secret, options?: SignOptions): Promise<string>;
+    /**
+     * Asynchronously verify given token using a secret or a public key to get a decoded token.
+     * @param token - The token to encode.
+     * @param secret - The secret to encode the token with.
+     * @returns The encoded token.
+     */
+    static verify<Role extends string>(token: string, secret: Secret): Promise<EncodedAccessToken<Role> | undefined>;
+}
+
+type RefreshTokenPayload<Role extends string, T extends BaseUser<Role>> = {
+    /**
+     * The id of the user that this refresh token belongs to.
+     */
+    userId: T['id'];
+};
+
+declare class RefreshToken implements BaseEntity {
+    id: string;
+    userId: string;
+    value: string;
+    blacklisted: boolean;
+    expirationDate: Date;
+    familyId: string;
+}
+declare const RefreshTokenCreateDto_base: Newable<Omit<RefreshToken, "id">>;
+declare class RefreshTokenCreateDto extends RefreshTokenCreateDto_base {
+}
+
+interface UserServiceInterface {
+    findById: <Role extends string, T extends BaseUser<Role>>(id: T['id']) => Promise<T>;
+    findByEmail: <Role extends string, T extends BaseUser<Role>>(email: string) => Promise<T>;
+    resolveCredentialsFor: <Role extends string, T extends BaseUser<Role>, CredentialsType>(user: T) => Promise<CredentialsType>;
+}
+
+declare const NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE: string;
+declare class UserService implements UserServiceInterface {
+    findById<Role extends string, T extends BaseUser<Role>>(id: T['id']): Promise<T>;
+    findByEmail<Role extends string, T extends BaseUser<Role>>(email: string): Promise<T>;
+    resolveCredentialsFor<Role extends string, T extends BaseUser<Role>, CredentialsType>(user: T): Promise<CredentialsType>;
+}
+
+declare abstract class HashUtilities {
+    static hash(value: string): Promise<string>;
+    static equal(value: string, hash: string): Promise<boolean>;
+}
+
+interface DataSourceServiceInterface {
+    init: () => Promise<void>;
+}
+
+declare class DataSourceService implements DataSourceServiceInterface {
+    private readonly logger;
+    private readonly allowedOrphans;
+    constructor();
+    init(): Promise<void>;
+    private checkForOrphanedEntities;
+}
+
+declare function DataSource(): ClassDecorator;
+
 type DataSourceOptions = DataSourceOptions$1;
 
 type ColumnType = ColumnType$1;
@@ -181,21 +594,73 @@ type DeleteByIdOptions = BaseRepositoryOptions;
 
 type DeleteAllOptions<T extends BaseEntity> = FindAllOptions<T>;
 
-declare class Repository<T extends BaseEntity> {
+declare class Repository<T extends BaseEntity, CreateData extends DeepPartial<T> = DeepPartial<T>, UpdateData extends DeepPartial<T> = DeepPartial<T>> {
     private readonly entityClass;
-    private readonly typeOrmRepository;
     private readonly logger;
-    constructor(entityClass: Newable<T>, typeOrmRepository: Repository$1<T>);
+    private readonly typeOrmRepository;
+    constructor(entityClass: Newable<T>, repo: Repository$1<T> | Repository<T>);
     private getManager;
-    create(data: DeepPartial<T>, options?: CreateOptions): Promise<T>;
-    createAll(data: DeepPartial<T>[], options?: CreateAllOptions): Promise<T[]>;
+    create(data: CreateData, options?: CreateOptions): Promise<T>;
+    createAll(data: CreateData[], options?: CreateAllOptions): Promise<T[]>;
     findById(id: T['id'], options?: FindByIdOptions): Promise<T>;
     findOne(options: FindOneOptions<T>): Promise<T>;
     findAll(options?: FindAllOptions<T>): Promise<T[]>;
-    updateById(id: T['id'], data: DeepPartial<T>, options?: UpdateByIdOptions): Promise<T>;
-    updateAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], data: DeepPartial<T>, options?: UpdateAllOptions): Promise<T[]>;
+    updateById(id: T['id'], data: UpdateData, options?: UpdateByIdOptions): Promise<T>;
+    updateAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], data: UpdateData, options?: UpdateAllOptions): Promise<T[]>;
     deleteById(id: T['id'], options?: DeleteByIdOptions): Promise<void>;
-    deleteAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], options?: DeleteAllOptions<T>): Promise<T[]>;
+    deleteAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], options?: OmitStrict<DeleteAllOptions<T>, 'where'>): Promise<T[]>;
+}
+
+declare class MigrationEntity implements BaseEntity {
+    id: string;
+    name: string;
+    version: Version;
+    ranAt: Date;
+}
+
+declare abstract class Migration {
+    abstract readonly version: Version;
+    protected readonly dataSource: BaseDataSource;
+    protected readonly migrationRepository: Repository<MigrationEntity>;
+    constructor(dataSourceClass: Newable<BaseDataSource>);
+    runUp(): Promise<void>;
+    runDown(): Promise<void>;
+    protected abstract up(transaction: Transaction): Promise<void>;
+    protected abstract down(transaction: Transaction): Promise<void>;
+    protected addColumn<T extends BaseEntity>(entity: Newable<T>, key: keyof T, transaction: Transaction): Promise<void>;
+    protected changeColumn<T extends BaseEntity>(entity: Newable<T>, oldColumn: keyof T | string & {}, newColumn: PropertyMetadataInput & {
+        name?: keyof T;
+        type: Exclude<PropertyMetadata, RelationMetadata<BaseEntity>>['type'];
+    }, transaction: Transaction): Promise<void>;
+    protected getColumnMetadata<T extends BaseEntity>(target: EntityTarget<T>, propertyName: keyof T | string & {}, transaction: Transaction): ColumnMetadata;
+    protected getEntityMetadata<T extends BaseEntity>(target: EntityTarget<T>, transaction: Transaction): EntityMetadata$1;
+}
+
+interface LoggerInterface {
+    debug: (...messages: (string | number)[]) => void;
+    info: (...messages: (string | number)[]) => void;
+    warn: (...messages: (string | number)[]) => void;
+    error: (...messages: (string | number | Error)[]) => void;
+    critical: (...messages: (string | number | Error)[]) => void;
+}
+
+declare const LOG_LEVEL_VALUES: {
+    readonly debug: 0;
+    readonly info: 1;
+    readonly warn: 2;
+    readonly error: 3;
+    readonly critical: 4;
+};
+type LogLevels = typeof LOG_LEVEL_VALUES;
+type LogLevel = keyof LogLevels;
+declare class Logger implements LoggerInterface {
+    debug(...messages: (string | number)[]): void;
+    info(...messages: (string | number)[]): void;
+    warn(...messages: (string | number)[]): void;
+    error(...messages: (string | number | Error)[]): void;
+    critical(...messages: (string | number | Error)[]): void;
+    private log;
+    private getTimestamp;
 }
 
 declare abstract class BaseDataSource {
@@ -203,13 +668,28 @@ declare abstract class BaseDataSource {
     private get columnTypeMapping();
     abstract readonly options: OmitStrict<DataSourceOptions, 'entities'>;
     abstract readonly entities: Newable<BaseEntity>[];
+    readonly migrations: Newable<Migration>[];
     protected ds?: DataSource$1;
+    protected readonly logger: LoggerInterface;
+    constructor();
     init(): Promise<void>;
     protected getEntitySchemas(): EntitySchema[];
+    protected createSchemaForEntity(cls: Newable<BaseEntity>): EntitySchema;
     protected propertyToRelationOptions<T extends BaseEntity>(metadata: RelationMetadata<T>): EntitySchemaRelationOptions;
     protected propertyToColumnOptions(metadata: Exclude<PropertyMetadata, RelationMetadata<BaseEntity>>): EntitySchemaColumnOptions;
     getRepository<T extends BaseEntity>(cls: Newable<T>): Repository<T>;
     startTransaction(isolationLevel?: IsolationLevel): Promise<Transaction>;
+    createQueryRunner(): QueryRunner;
+    runMigrations(): Promise<void>;
+    protected createMigrationTableIfNotExists(): Promise<void>;
+    propertyToTableColumnOptions<T extends BaseEntity>(entity: Newable<T>, property: keyof T): TableColumnOptions;
+    normalizeColumnType(column: {
+        type: ColumnType | string & {} | undefined;
+        length: number | string | undefined;
+        precision: number | null | undefined;
+        scale: number | undefined;
+        isArray: boolean | undefined;
+    }): string;
 }
 
 type DiToken<T> = Newable<T> | string;
@@ -234,138 +714,31 @@ declare const ZIBRI_DI_TOKENS: {
     readonly ASSET_SERVICE: "zi.asset_service";
     readonly GLOBAL_ERROR_HANDLER: "zi.global_error_handler";
     readonly OPEN_API_SERVICE: "zi.open_api_service";
+    readonly AUTH_SERVICE: "zi.auth_service";
     readonly PARSER: "zi.parser_service";
     readonly VALIDATION_SERVICE: "zi.validation_service";
     readonly DATA_SOURCE_SERVICE: "zi.data_source_service";
+    readonly JWT_ACCESS_TOKEN_SECRET: "zi.jwt_access_token_secret";
+    readonly JWT_ACCESS_TOKEN_EXPIRES_IN_MS: "zi.jwt_access_token_expires_in_ms";
+    readonly JWT_REFRESH_TOKEN_SECRET: "zi.jwt_refresh_token_secret";
+    readonly JWT_REFRESH_TOKEN_EXPIRES_IN_MS: "zi.jwt_refresh_token_expires_in_ms";
+    readonly USER_SERVICE: "zi.user_service";
 };
 
 declare function inject<T>(token: DiToken<T>): T;
 
-declare enum HttpMethod {
-    GET = "get",
-    POST = "post",
-    PUT = "put",
-    PATCH = "patch",
-    DELETE = "delete"
-}
-
-declare enum HttpStatus {
-    INTERNAL_SERVER_ERROR = 500,
-    NOT_FOUND_ERROR = 404,
-    BAD_REQUEST = 400
-}
-
-declare enum MimeType {
-    JSON = "application/json",
-    HTML = "text/html"
-}
-declare function isMimeType(value: string): value is MimeType;
-
-type KnownHeader = 'Accept' | 'Accept-Encoding' | 'Authorization' | 'Cache-Control' | 'Content-Length' | 'Content-Type' | 'Cookie' | 'Host' | 'Origin' | 'Referer' | 'User-Agent' | 'X-Requested-With' | 'X-Forwarded-For' | 'X-Forwarded-Host' | 'X-Forwarded-Proto' | 'X-Real-IP' | 'X-Correlation-ID' | 'If-None-Match' | 'If-Modified-Since' | 'Connection' | 'DNT' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'TE';
-
-type Header = KnownHeader | (string & {});
-
 interface BodyParserInterface {
     readonly contentType: MimeType;
-    parse: (req: Request) => Promise<unknown>;
+    parse: (req: HttpRequest) => Promise<unknown>;
 }
 
 declare function BodyParser(): ClassDecorator;
 
-type Route = `/${string}`;
-type ControllerRouteConfiguration = {
-    httpMethod: HttpMethod;
-    route: Route;
-    controllerMethod: string;
-};
-
-type RouteConfiguration = {
-    httpMethod: HttpMethod;
-    route: Route;
-    handler: (req: Request, res: Response) => unknown | Promise<unknown>;
-};
-
-interface RouterInterface {
-    registerController: <T extends Object>(controllerClass: Newable<T>, ...params: any[]) => void;
-    register: (route: RouteConfiguration, ...params: any[]) => void;
-    attachTo: (app: ZibriApplication, ...params: any[]) => void;
-}
-
-declare class Router implements RouterInterface {
-    private readonly router;
-    private readonly logger;
-    private readonly parser;
-    private readonly validationService;
-    constructor();
-    attachTo(app: ZibriApplication): void;
-    register(route: RouteConfiguration): void;
-    registerController<T extends Object>(controllerClass: Newable<T>): void;
-    private routeToRequestHandler;
-    private controllerRouteToRequestHandler;
-    private resolveRouteParams;
-}
-
-declare function Controller(baseRoute: Route): ClassDecorator;
-
-declare function Get(path?: Route): MethodDecorator;
-
-declare function Post(path?: Route): MethodDecorator;
-
-declare function Delete(path?: Route): MethodDecorator;
-
-declare function Patch(path?: Route): MethodDecorator;
-
-type BaseParamMetadata = {
-    name: string;
-};
-
-type StringParamMetadata = BaseParamMetadata & OmitStrict<StringPropertyMetadata, 'primary'>;
-type StringParamMetadataInput = Partial<OmitStrict<StringParamMetadata, 'name'>>;
-
-type NumberParamMetadata = BaseParamMetadata & OmitStrict<NumberPropertyMetadata, 'primary'>;
-type NumberParamMetadataInput = Partial<OmitStrict<NumberParamMetadata, 'name'>>;
-
-type BooleanParamMetadata = BaseParamMetadata & BooleanPropertyMetadata;
-type BooleanParamMetadataInput = Partial<OmitStrict<BooleanParamMetadata, 'name'>>;
-
-type DateParamMetadata = BaseParamMetadata & DatePropertyMetadata;
-type DateParamMetadataInput = Partial<OmitStrict<DateParamMetadata, 'name'>>;
-
-type ObjectParamMetadata = BaseParamMetadata & ObjectPropertyMetadata;
-type ObjectParamMetadataInput = Partial<OmitStrict<ObjectParamMetadata, 'name'>> & Pick<ObjectParamMetadata, 'cls'>;
-
-type ArrayParamMetadata = BaseParamMetadata & ArrayPropertyMetadata;
-type ArrayParamMetadataInput = Partial<OmitStrict<ArrayParamMetadata, 'type' | 'items'>> & {
-    items: QueryParamMetadataInput & Pick<QueryParamMetadata, 'type'>;
-};
-
-type PathParamMetadata = StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata;
-type PathParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput;
-type QueryParamMetadata = StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata | ObjectParamMetadata | ArrayParamMetadata;
-type QueryParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput | ObjectParamMetadataInput | ArrayParamMetadataInput;
-type HeaderParamMetadata = (StringParamMetadata | NumberParamMetadata | BooleanParamMetadata | DateParamMetadata | ObjectParamMetadata | ArrayParamMetadata) & {
-    name: Header;
-};
-type HeaderParamMetadataInput = StringParamMetadataInput | NumberParamMetadataInput | BooleanParamMetadataInput | DateParamMetadataInput | ObjectParamMetadataInput | ArrayParamMetadataInput;
-declare namespace Param {
-    function path(name: string, options?: PathParamMetadataInput): ParameterDecorator;
-    function query(name: string, options?: QueryParamMetadataInput): ParameterDecorator;
-    function header(name: Header, options?: HeaderParamMetadataInput): ParameterDecorator;
-}
-
-type BodyMetadata = BasePropertyMetadata & {
-    modelClass: Newable<unknown>;
-    index: number;
-    name: string;
-};
-type BodyMetadataInput = Partial<OmitStrict<BodyMetadata, 'modelClass' | 'index' | 'name'>>;
-declare function Body(modelClass: Newable<unknown>, options?: BodyMetadataInput): ParameterDecorator;
-
 interface ParserInterface {
-    parseRequestBody: (req: Request) => Promise<unknown>;
-    parsePathParam: (req: Request, metadata: PathParamMetadata) => unknown;
-    parseQueryParam: (req: Request, metadata: QueryParamMetadata) => unknown;
-    parseHeaderParam: (req: Request, metadata: HeaderParamMetadata) => unknown;
+    parseRequestBody: (req: HttpRequest) => Promise<unknown>;
+    parsePathParam: (req: HttpRequest, metadata: PathParamMetadata) => unknown;
+    parseQueryParam: (req: HttpRequest, metadata: QueryParamMetadata) => unknown;
+    parseHeaderParam: (req: HttpRequest, metadata: HeaderParamMetadata) => unknown;
     attachTo: (app: ZibriApplication) => void;
 }
 
@@ -376,31 +749,33 @@ declare class Parser implements ParserInterface {
     private readonly queryParamParseFunctions;
     private readonly headerParamParseFunctions;
     constructor();
-    parseHeaderParam(req: Request, metadata: HeaderParamMetadata): unknown;
-    parseQueryParam(req: Request, metadata: QueryParamMetadata): unknown;
-    parsePathParam(req: Request, metadata: PathParamMetadata): unknown;
-    parseRequestBody(req: Request): Promise<unknown>;
+    parseHeaderParam(req: HttpRequest, metadata: HeaderParamMetadata): unknown;
+    parseQueryParam(req: HttpRequest, metadata: QueryParamMetadata): unknown;
+    parsePathParam(req: HttpRequest, metadata: PathParamMetadata): unknown;
+    parseRequestBody(req: HttpRequest): Promise<unknown>;
     attachTo(): void;
 }
 
 declare class JsonBodyParser implements BodyParserInterface {
     readonly contentType: MimeType;
-    parse(req: Request): Promise<unknown>;
+    parse(req: HttpRequest): Promise<unknown>;
 }
 
 type ZibriApplicationOptions = {
     name: string;
+    version: Version;
     controllers: Newable<unknown>[];
     dataSources?: Newable<BaseDataSource>[];
     providers?: DiProvider<unknown>[];
     bodyParsers?: Newable<BodyParserInterface>[];
+    authStrategies?: AuthStrategies;
 };
 
 /**
  * A zibri application.
  */
 declare class ZibriApplication {
-    private readonly options;
+    private readonly providedOptions;
     readonly express: Express;
     private _router;
     get router(): RouterInterface;
@@ -409,7 +784,9 @@ declare class ZibriApplication {
     private openApiService;
     private parser;
     private dataSourceService;
-    constructor(options: ZibriApplicationOptions);
+    private authService;
+    private readonly options;
+    constructor(providedOptions: ZibriApplicationOptions);
     init(): Promise<void>;
     /**
      * Starts on the given port.
@@ -419,7 +796,7 @@ declare class ZibriApplication {
     start(port: number): void;
 }
 
-type GlobalErrorHandler = (err: unknown, req: Request, res: Response, next: NextFunction) => void;
+type GlobalErrorHandler = (err: unknown, req: HttpRequest, res: HttpResponse, next: NextFunction) => void;
 
 declare const errorHandler: GlobalErrorHandler;
 
@@ -497,6 +874,10 @@ declare class ValidationError extends BadRequestError {
     constructor(type: ValidationErrorType, problems: ValidationProblem[], options?: ErrorOptions);
 }
 
+declare class UnauthorizedError extends HttpError {
+    constructor(message: string | string[], options?: ErrorOptions);
+}
+
 interface AssetServiceInterface {
     readonly assetsPath: string;
     readonly assetsRoute: Route;
@@ -523,6 +904,7 @@ declare enum AppState {
 type AppData = {
     state: AppState;
     name?: string;
+    version?: Version;
 };
 declare abstract class GlobalRegistry {
     private static readonly appData;
@@ -531,6 +913,7 @@ declare abstract class GlobalRegistry {
     static readonly dataSourceClasses: Newable<BaseDataSource>[];
     static readonly entityClasses: Newable<BaseEntity>[];
     static readonly bodyParsers: Newable<BodyParserInterface>[];
+    static readonly userRepositories: UserRepositories;
     private static readonly validateAppStateChange;
     static getAppData<K extends keyof AppData>(key: K): AppData[K];
     static setAppData(options: ZibriApplicationOptions): void;
@@ -543,58 +926,8 @@ declare abstract class GlobalRegistry {
     private static changeAppState;
 }
 
-interface LoggerInterface {
-    debug: (...messages: (string | number)[]) => void;
-    info: (...messages: (string | number)[]) => void;
-    warn: (...messages: (string | number)[]) => void;
-    error: (...messages: (string | number | Error)[]) => void;
-    critical: (...messages: (string | number | Error)[]) => void;
-}
-
-declare const LOG_LEVEL_VALUES: {
-    readonly debug: 0;
-    readonly info: 1;
-    readonly warn: 2;
-    readonly error: 3;
-    readonly critical: 4;
-};
-type LogLevels = typeof LOG_LEVEL_VALUES;
-type LogLevel = keyof LogLevels;
-declare class Logger implements LoggerInterface {
-    debug(...messages: (string | number)[]): void;
-    info(...messages: (string | number)[]): void;
-    warn(...messages: (string | number)[]): void;
-    error(...messages: (string | number | Error)[]): void;
-    critical(...messages: (string | number | Error)[]): void;
-    private log;
-    private getTimestamp;
-}
-
-type OpenApiDefinition = oas31.OpenAPIObject;
-type OpenApiPaths = oas31.PathsObject;
-type OpenApiOperation = oas31.OperationObject;
-type OpenApiParameter = (oas31.ParameterObject | oas31.ReferenceObject);
-type OpenApiRequestBodyObject = oas31.RequestBodyObject;
-type OpenApiSchemaObject = oas31.SchemaObject;
-
-interface OpenApiServiceInterface {
-    readonly openApiRoute: Route;
-    attachTo: (app: ZibriApplication) => void;
-    createOpenApiDefinition: (app: ZibriApplication) => OpenApiDefinition;
-}
+declare function compareVersion(v1: Version, v2: Version): 'bigger' | 'equal' | 'smaller';
 
-declare class OpenApiService implements OpenApiServiceInterface {
-    readonly openApiRoute: Route;
-    private readonly logger;
-    private readonly assetService;
-    constructor();
-    attachTo(app: ZibriApplication): void;
-    createOpenApiDefinition(): OpenApiDefinition;
-    private resolveOpenApiPaths;
-    private buildOpenApiBody;
-    private buildOpenApiSchemaForProperties;
-    private buildParameters;
-    private paramToSchema;
-}
+declare function isVersion(value: string): value is Version;
 
-export { type AppData, AppState, type ArrayParamMetadata, type ArrayParamMetadataInput, type ArrayPropertyItemMetadata, type ArrayPropertyMetadata, type ArrayPropertyMetadataInput, AssetService, type AssetServiceInterface, BadRequestError, BaseDataSource, type BaseEntity, Body, type BodyMetadata, type BodyMetadataInput, BodyParser, type BodyParserInterface, type BooleanParamMetadata, type BooleanParamMetadataInput, type BooleanPropertyMetadata, type BooleanPropertyMetadataInput, type ColumnType, Controller, type ControllerRouteConfiguration, type CreateAllOptions, type CreateOptions, DataSource, type DataSourceOptions, DataSourceService, type DataSourceServiceInterface, type DateParamMetadata, type DateParamMetadataInput, type DatePropertyMetadata, type DatePropertyMetadataInput, Delete, type DeleteAllOptions, type DeleteByIdOptions, type DiProvider, type DiToken, Entity, type EntityMetadata, type FindAllOptions, type FindByIdOptions, type FindOneOptions, Get, type GlobalErrorHandler, GlobalRegistry, type Header, type HeaderParamMetadata, type HeaderParamMetadataInput, HttpError, HttpMethod, HttpStatus, Inject, InjectRepository, Injectable, InternalServerError, IntersectionType, IsRequiredValidationProblem, JsonBodyParser, type KnownHeader, type LogLevel, type LogLevels, Logger, type LoggerInterface, type ManyToManyPropertyMetadata, type ManyToManyPropertyMetadataInput, type ManyToOnePropertyMetadata, type ManyToOnePropertyMetadataInput, MimeType, type Newable, NotFoundError, type NumberParamMetadata, type NumberParamMetadataInput, type NumberPropertyMetadata, type NumberPropertyMetadataInput, type ObjectParamMetadata, type ObjectParamMetadataInput, type ObjectPropertyMetadata, type ObjectPropertyMetadataInput, OmitType, type OneToManyPropertyMetadata, type OneToManyPropertyMetadataInput, type OneToOnePropertyMetadata, type OneToOnePropertyMetadataInput, type OpenApiDefinition, type OpenApiOperation, type OpenApiParameter, type OpenApiPaths, type OpenApiRequestBodyObject, type OpenApiSchemaObject, OpenApiService, type OpenApiServiceInterface, Param, Parser, type ParserInterface, PartialType, Patch, type PathParamMetadata, type PathParamMetadataInput, PickType, Post, Property, type PropertyMetadata, type PropertyMetadataInput, type QueryParamMetadata, type QueryParamMetadataInput, Relation, type RelationMetadata, type RelationMetadataInput, RelationsNotAllowedValidationProblem, Repository, type Route, type RouteConfiguration, Router, type RouterInterface, type StringFormat, type StringParamMetadata, type StringParamMetadataInput, type StringPropertyMetadata, type StringPropertyMetadataInput, type Transaction, TypeMismatchValidationProblem, UnmatchedRouteError, type UpdateAllOptions, type UpdateByIdOptions, ValidationError, type ValidationProblem, ValidationService, type ValidationServiceInterface, ZIBRI_DI_TOKENS, ZibriApplication, type ZibriApplicationOptions, errorHandler, inject, isHttpError, isMimeType, repositoryTokenFor };
+export { type AccessTokenPayload, type AppData, AppState, type ArrayParamMetadata, type ArrayParamMetadataInput, type ArrayPropertyItemMetadata, type ArrayPropertyMetadata, type ArrayPropertyMetadataInput, AssetService, type AssetServiceInterface, Auth, AuthService, type AuthServiceInterface, type AuthStrategies, type AuthStrategyInterface, BadRequestError, BaseDataSource, type BaseEntity, type BaseUser, Body, type BodyMetadata, type BodyMetadataInput, BodyParser, type BodyParserInterface, type BooleanParamMetadata, type BooleanParamMetadataInput, type BooleanPropertyMetadata, type BooleanPropertyMetadataInput, type ColumnType, Controller, type ControllerRouteConfiguration, type CreateAllOptions, type CreateOptions, CurrentUser, type CurrentUserMetadata, DataSource, type DataSourceOptions, DataSourceService, type DataSourceServiceInterface, type DateParamMetadata, type DateParamMetadataInput, type DatePropertyMetadata, type DatePropertyMetadataInput, Delete, type DeleteAllOptions, type DeleteByIdOptions, type DiProvider, type DiToken, type EncodedAccessToken, Entity, type EntityMetadata, type FindAllOptions, type FindByIdOptions, type FindOneOptions, Get, type GlobalErrorHandler, GlobalRegistry, type HasRoleMetadata, HashUtilities, type Header, type HeaderParamMetadata, type HeaderParamMetadataInput, HttpError, HttpMethod, type HttpRequest, type HttpResponse, HttpStatus, Inject, InjectRepository, Injectable, InternalServerError, IntersectionType, type IsLoggedInMetadata, type IsNotLoggedInMetadata, IsRequiredValidationProblem, JsonBodyParser, Jwt, JwtAuthData, JwtAuthStrategy, JwtCredentials, JwtCredentialsDto, JwtUtilities, type KnownHeader, type LogLevel, type LogLevels, Logger, type LoggerInterface, type ManyToManyPropertyMetadata, type ManyToManyPropertyMetadataInput, type ManyToOnePropertyMetadata, type ManyToOnePropertyMetadataInput, Migration, MigrationEntity, MimeType, NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE, type Newable, NotFoundError, type NumberParamMetadata, type NumberParamMetadataInput, type NumberPropertyMetadata, type NumberPropertyMetadataInput, type ObjectParamMetadata, type ObjectParamMetadataInput, type ObjectPropertyMetadata, type ObjectPropertyMetadataInput, OmitType, type OneToManyPropertyMetadata, type OneToManyPropertyMetadataInput, type OneToOnePropertyMetadata, type OneToOnePropertyMetadataInput, type OpenApiDefinition, type OpenApiOperation, type OpenApiParameter, type OpenApiPaths, type OpenApiRequestBodyObject, type OpenApiSchemaObject, type OpenApiSecurityRequirementObject, type OpenApiSecuritySchemeObject, OpenApiService, type OpenApiServiceInterface, Param, Parser, type ParserInterface, PartialType, Patch, type PathParamMetadata, type PathParamMetadataInput, PickType, Post, Property, type PropertyMetadata, type PropertyMetadataInput, type QueryParamMetadata, type QueryParamMetadataInput, RefreshToken, RefreshTokenCreateDto, type RefreshTokenPayload, Relation, type RelationMetadata, type RelationMetadataInput, RelationsNotAllowedValidationProblem, Repository, type Route, type RouteConfiguration, Router, type RouterInterface, type SkipHasRoleMetadata, type SkipIsLoggedInMetadata, type SkipIsNotLoggedInMetadata, type StringFormat, type StringParamMetadata, type StringParamMetadataInput, type StringPropertyMetadata, type StringPropertyMetadataInput, type Transaction, TypeMismatchValidationProblem, UnauthorizedError, UnmatchedRouteError, type UpdateAllOptions, type UpdateByIdOptions, UserRepo, type UserRepositories, type UserRepositoryInterface, UserService, type UserServiceInterface, ValidationError, type ValidationProblem, ValidationService, type ValidationServiceInterface, type Version, ZIBRI_DI_TOKENS, ZibriApplication, type ZibriApplicationOptions, compareVersion, errorHandler, inject, isHttpError, isMimeType, isVersion, repositoryTokenFor };