zibri 1.3.0 → 1.4.0

package/dist/index.d.mts

@@ -1,10 +1,17 @@
-import { Request, Response, Express, NextFunction } from 'express';
+import { Request, Response as Response$1, Express as Express$1, NextFunction } from 'express';
 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 { ScheduledTask } from 'node-cron';
+import { EntitySchemaRelationOptions, DataSourceOptions as DataSourceOptions$1, ColumnType as ColumnType$1, QueryRunner, FindManyOptions, FindOneOptions as FindOneOptions$1, Repository as Repository$1, 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';
+import { Readable } from 'stream';
+
+type BasePropertyMetadata = {
+    required: boolean;
+    description: string | undefined;
+};
 
 type Newable<T> = new (...args: any[]) => T;
 
@@ -12,91 +19,11 @@ type DeepPartial<T> = T | (T extends (infer U)[] ? DeepPartial<U>[] : T extends
     [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 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();
-    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;
+type ExcludeStrict<UnionType, ExcludedMembers extends UnionType> = Exclude<UnionType, ExcludedMembers>;
 
-declare function Get(path?: Route): MethodDecorator;
+type OmitStrict<T extends object, K extends keyof T> = Pick<T, ExcludeStrict<keyof T, K>>;
 
-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 Version = `${number}.${number}.${number}`;
 
 type StringFormat = 'uuid' | 'email';
 type StringPropertyMetadata = BasePropertyMetadata & {
@@ -104,6 +31,8 @@ type StringPropertyMetadata = BasePropertyMetadata & {
     primary: boolean;
     format: StringFormat | undefined;
     unique: boolean;
+    minLength: number | undefined;
+    maxLength: number | undefined;
 };
 type StringPropertyMetadataInput = Partial<OmitStrict<StringPropertyMetadata, 'type'>>;
 
@@ -116,7 +45,7 @@ type NumberPropertyMetadataInput = Partial<OmitStrict<NumberPropertyMetadata, 't
 
 type ObjectPropertyMetadata = BasePropertyMetadata & {
     type: 'object';
-    cls: Newable<unknown>;
+    cls: () => Newable<unknown>;
 };
 type ObjectPropertyMetadataInput = Partial<OmitStrict<ObjectPropertyMetadata, 'type'>> & Pick<ObjectPropertyMetadata, 'cls'>;
 
@@ -124,27 +53,103 @@ type BaseEntity = {
     id: string;
 };
 
-type ArrayPropertyMetadata = BasePropertyMetadata & {
-    type: 'array';
-    items: Exclude<PropertyMetadata, RelationMetadata<BaseEntity>>;
-};
-type ArrayItemPropertyType = Exclude<PropertyMetadata['type'], RelationMetadata<BaseEntity>['type']>;
-type ArrayPropertyItemMetadata = PropertyMetadataInput & {
-    type: ArrayItemPropertyType;
-};
-type ArrayPropertyMetadataInput = Partial<OmitStrict<ArrayPropertyMetadata, 'type' | 'items'>> & {
-    items: ArrayPropertyItemMetadata;
+type BooleanPropertyMetadata = BasePropertyMetadata & {
+    type: 'boolean';
 };
+type BooleanPropertyMetadataInput = Partial<OmitStrict<BooleanPropertyMetadata, 'type'>>;
 
 type DatePropertyMetadata = BasePropertyMetadata & {
     type: 'date';
 };
 type DatePropertyMetadataInput = Partial<OmitStrict<DatePropertyMetadata, 'type'>>;
 
-type BooleanPropertyMetadata = BasePropertyMetadata & {
+declare enum HttpMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete"
+}
+
+declare enum HttpStatus {
+    OK = 200,
+    CREATED = 201,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND_ERROR = 404,
+    INTERNAL_SERVER_ERROR = 500
+}
+
+declare enum MimeType {
+    JSON = "application/json",
+    HTML = "text/html",
+    FORM_DATA = "multipart/form-data",
+    OCTET_STREAM = "application/octet-stream",
+    PNG = "image/png",
+    JPEG = "image/jpeg",
+    ZIP = "application/zip",
+    SVG = "image/svg+xml",
+    CSS = "text/css",
+    TTF = "font/ttf",
+    PDF = "application/pdf",
+    CSV = "text/csv",
+    EML = "message/rfc822",
+    XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    TXT = "text/plain"
+}
+type LooseMimeType = MimeType | string & {};
+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$1;
+
+type FileSize = `${number}b` | `${number}kb` | `${number}mb` | `${number}gb`;
+declare function fileSizeToBytes(size: FileSize): number;
+type FilePropertyMetadata = BasePropertyMetadata & {
+    type: 'file';
+    allowedMimeTypes: MimeType[] | 'all';
+    maxSize: FileSize;
+};
+type FilePropertyMetadataInput = Partial<OmitStrict<FilePropertyMetadata, 'type'>>;
+
+type ArrayPropertyMetadata = BasePropertyMetadata & {
+    type: 'array';
+    items: ArrayPropertyItemMetadata;
+};
+type ArrayPropertyItemMetadata = ExcludeStrict<PropertyMetadata, RelationMetadata<BaseEntity>>;
+type ArrayPropertyItemMetadataInput = StringPropertyMetadataInput & {
+    type: 'string';
+} | NumberPropertyMetadataInput & {
+    type: 'number';
+} | ObjectPropertyMetadataInput & {
+    type: 'object';
+} | ArrayPropertyMetadataInput & {
+    type: 'array';
+} | DatePropertyMetadataInput & {
+    type: 'date';
+} | BooleanPropertyMetadataInput & {
     type: 'boolean';
+} | FilePropertyMetadataInput & {
+    type: 'file';
 };
-type BooleanPropertyMetadataInput = Partial<OmitStrict<BooleanPropertyMetadata, 'type'>>;
+type DefaultArrayPropertyMetadataInput = Partial<BasePropertyMetadata> & {
+    items: ExcludeStrict<ArrayPropertyItemMetadataInput, FileArrayPropertyMetadataInput['items']>;
+    totalFileSize?: never;
+};
+type FileArrayPropertyMetadataInput = Partial<BasePropertyMetadata> & {
+    items: FilePropertyMetadataInput & {
+        type: 'file';
+    };
+    totalFileSize?: FileSize;
+};
+type ArrayPropertyMetadataInput = DefaultArrayPropertyMetadataInput | FileArrayPropertyMetadataInput;
 
 type BaseRelationMetadata<T extends BaseEntity> = BasePropertyMetadata & Required<Pick<EntitySchemaRelationOptions, 'cascade' | 'persistence'>> & {
     /**
@@ -186,9 +191,9 @@ declare enum Relation {
     MANY_TO_MANY = "many-to-many"
 }
 
-type PropertyMetadata = StringPropertyMetadata | NumberPropertyMetadata | ObjectPropertyMetadata | ArrayPropertyMetadata | DatePropertyMetadata | BooleanPropertyMetadata | RelationMetadata<BaseEntity>;
+type PropertyMetadata = StringPropertyMetadata | NumberPropertyMetadata | ObjectPropertyMetadata | ArrayPropertyMetadata | DatePropertyMetadata | BooleanPropertyMetadata | FilePropertyMetadata | RelationMetadata<BaseEntity>;
 type RelationMetadata<T extends BaseEntity> = ManyToOnePropertyMetadata<T> | OneToManyPropertyMetadata<T> | OneToOnePropertyMetadata<T> | ManyToManyPropertyMetadata<T>;
-type PropertyMetadataInput = StringPropertyMetadataInput | NumberPropertyMetadataInput | ObjectPropertyMetadataInput | ArrayPropertyMetadataInput | DatePropertyMetadataInput | BooleanPropertyMetadataInput;
+type PropertyMetadataInput = StringPropertyMetadataInput | NumberPropertyMetadataInput | ObjectPropertyMetadataInput | ArrayPropertyMetadataInput | DatePropertyMetadataInput | FilePropertyMetadataInput | BooleanPropertyMetadataInput;
 type RelationMetadataInput<T extends BaseEntity> = ManyToOnePropertyMetadataInput<T> | OneToManyPropertyMetadataInput<T> | OneToOnePropertyMetadataInput<T> | ManyToManyPropertyMetadataInput<T>;
 declare namespace Property {
     function string(data?: StringPropertyMetadataInput): PropertyDecorator;
@@ -196,6 +201,7 @@ declare namespace Property {
     function boolean(data?: BooleanPropertyMetadataInput): PropertyDecorator;
     function date(data?: DatePropertyMetadataInput): PropertyDecorator;
     function object(data: ObjectPropertyMetadataInput): PropertyDecorator;
+    function file(data?: FilePropertyMetadataInput): PropertyDecorator;
     function array(data: ArrayPropertyMetadataInput): PropertyDecorator;
     function manyToOne<T extends BaseEntity>(metadata: ManyToOnePropertyMetadataInput<T>): PropertyDecorator;
     function oneToMany<T extends BaseEntity>(metadata: OneToManyPropertyMetadataInput<T>): PropertyDecorator;
@@ -218,6 +224,55 @@ 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 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();
+    attachTo(app: ZibriApplication): void;
+    register(route: RouteConfiguration): void;
+    registerController<T extends Object>(controllerClass: Newable<T>): void;
+    private routeToRequestHandler;
+    private controllerRouteToRequestHandler;
+    private returnResult;
+    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'>>;
 
@@ -252,12 +307,18 @@ declare namespace Param {
     function header(name: Header, options?: HeaderParamMetadataInput): ParameterDecorator;
 }
 
-type BodyMetadata = BasePropertyMetadata & {
+type BaseBodyMetadata = BasePropertyMetadata & {
     modelClass: Newable<unknown>;
     index: number;
-    name: string;
 };
-type BodyMetadataInput = Partial<OmitStrict<BodyMetadata, 'modelClass' | 'index' | 'name'>>;
+type JsonBodyMetadata = BaseBodyMetadata & {
+    type: MimeType.JSON;
+};
+type FormDataBodyMetadata = BaseBodyMetadata & {
+    type: MimeType.FORM_DATA;
+};
+type BodyMetadata = JsonBodyMetadata | FormDataBodyMetadata;
+type BodyMetadataInput = Partial<OmitStrict<BodyMetadata, 'modelClass' | 'index'>>;
 declare function Body(modelClass: Newable<unknown>, options?: BodyMetadataInput): ParameterDecorator;
 
 type OpenApiDefinition = oas31.OpenAPIObject;
@@ -268,6 +329,20 @@ type OpenApiRequestBodyObject = oas31.RequestBodyObject;
 type OpenApiSchemaObject = oas31.SchemaObject;
 type OpenApiSecuritySchemeObject = oas31.SecuritySchemeObject;
 type OpenApiSecurityRequirementObject = oas31.SecurityRequirementObject;
+type FileOpenApiResponse = {
+    type: 'file';
+    status?: HttpStatus;
+    description?: string;
+    mimeType?: 'all' | MimeType | MimeType[];
+};
+type DefaultOpenApiResponse = {
+    type: 'default';
+    status?: HttpStatus;
+    description?: string;
+    cls?: Newable<unknown>;
+    isArray?: boolean;
+};
+type OpenApiResponse = DefaultOpenApiResponse | FileOpenApiResponse;
 
 interface OpenApiServiceInterface {
     readonly openApiRoute: Route;
@@ -285,13 +360,31 @@ declare class OpenApiService implements OpenApiServiceInterface {
     createOpenApiDefinition(): OpenApiDefinition;
     private resolveSecuritySchemes;
     private resolveOpenApiPaths;
+    private buildResponses;
+    private buildResponseContent;
+    private buildResponsesContent;
     private resolveOperationSecurity;
     private buildOpenApiBody;
     private buildOpenApiSchemaForProperties;
+    private getTargetClassForRelation;
     private buildParameters;
     private paramToSchema;
 }
 
+declare namespace Response {
+    function object(entityClass: Newable<unknown>, data?: OmitStrict<DefaultOpenApiResponse, 'isArray' | 'type' | 'cls'>): MethodDecorator;
+    function array(entityClass: Newable<unknown>, data?: OmitStrict<DefaultOpenApiResponse, 'isArray' | 'type' | 'cls'>): MethodDecorator;
+    function paginated(entityClass: Newable<unknown>, data?: OmitStrict<DefaultOpenApiResponse, 'isArray' | 'type' | 'cls'>): MethodDecorator;
+    function empty(status?: HttpStatus, data?: OmitStrict<DefaultOpenApiResponse, 'isArray' | 'type' | 'status' | 'cls'>): MethodDecorator;
+    function file(data?: OmitStrict<FileOpenApiResponse, 'type'>): MethodDecorator;
+    function error(status: ExcludeStrict<HttpStatus, HttpStatus.OK | HttpStatus.CREATED>, data?: OmitStrict<DefaultOpenApiResponse, 'isArray' | 'type' | 'status' | 'cls'>): MethodDecorator;
+}
+
+type PaginationResult<T> = {
+    items: T[];
+    totalAmount: number;
+};
+
 type BaseUser<Role extends string> = BaseEntity & {
     email: string;
     roles: Role[];
@@ -303,6 +396,7 @@ interface AuthStrategyInterface<RoleType extends string, UserType extends BaseUs
     login: (credentials: CredentialType) => Promise<AuthDataType>;
     isLoggedIn: (request: HttpRequest) => Promise<boolean>;
     hasRole: (request: HttpRequest, allowedRoles: RoleType[]) => Promise<boolean>;
+    belongsTo: <TargetEntity extends Newable<BaseEntity>>(request: HttpRequest, targetEntity: TargetEntity, targetUserIdKey: keyof InstanceType<TargetEntity>, targetIdParamKey: string) => Promise<boolean>;
     securityScheme: OpenApiSecuritySchemeObject;
     name: string;
 }
@@ -333,6 +427,21 @@ type IsNotLoggedInMetadata = {
 };
 type SkipIsNotLoggedInMetadata = {};
 
+type BelongsToMetadata<TargetEntity extends Newable<BaseEntity>> = {
+    targetEntity: TargetEntity;
+    targetUserIdKey: keyof InstanceType<TargetEntity>;
+    targetIdParamKey: string;
+    allowedStrategies?: AuthStrategies;
+};
+type SkipBelongsToMetadata = {};
+
+type SkipAuthMetadata = {};
+
+interface BelongsToFn {
+    <T extends Newable<BaseEntity>>(targetEntity: T, targetIdParamKey?: string, targetUserIdKey?: keyof InstanceType<T>, allowedStrategies?: AuthStrategies): MethodDecorator & ClassDecorator;
+    skip: () => MethodDecorator & ClassDecorator;
+}
+
 interface HasRoleFn {
     (allowedRoles: string[], allowedStrategies?: AuthStrategies): MethodDecorator & ClassDecorator;
     skip: () => MethodDecorator & ClassDecorator;
@@ -352,6 +461,8 @@ declare namespace Auth {
     const isLoggedIn: IsLoggedInFn;
     const isNotLoggedIn: IsNotLoggedInFn;
     const hasRole: HasRoleFn;
+    const belongsTo: BelongsToFn;
+    function skip(): MethodDecorator;
 }
 
 /**
@@ -379,10 +490,10 @@ declare function UserRepo<T extends string, EntityType extends Newable<BaseUser<
 
 type CurrentUserMetadata = {
     index: number;
-    optional: boolean;
+    required: boolean;
     allowedStrategies?: AuthStrategies;
 };
-declare function CurrentUser(optional?: boolean, allowedStrategies?: AuthStrategies): ParameterDecorator;
+declare function CurrentUser(required?: boolean, allowedStrategies?: AuthStrategies): ParameterDecorator;
 
 interface AuthServiceInterface {
     readonly strategies: AuthStrategies;
@@ -390,11 +501,13 @@ interface AuthServiceInterface {
     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>;
+    belongsTo: <TargetEntity extends Newable<BaseEntity>>(request: HttpRequest, allowedStrategies: AuthStrategies, targetEntity: TargetEntity, targetUserIdKey: keyof InstanceType<TargetEntity>, targetIdParamKey: 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;
+    resolveBelongsToMetadata: (controllerClass: Newable<Object>, controllerMethod: string) => BelongsToMetadata<Newable<BaseEntity>> | 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>;
+    getCurrentUser: <Role extends string, UserType extends BaseUser<Role>, B extends boolean = true>(request: HttpRequest, strategies: AuthStrategies, required: B) => Promise<B extends false ? UserType | undefined : UserType>;
 }
 
 declare class AuthService implements AuthServiceInterface {
@@ -403,13 +516,15 @@ declare class AuthService implements AuthServiceInterface {
     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>;
+    getCurrentUser<Role extends string, UserType extends BaseUser<Role>, B extends boolean = false>(request: HttpRequest, allowedStrategies: AuthStrategies, required: B): Promise<B extends false ? 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>;
+    belongsTo<TargetEntity extends Newable<BaseEntity>>(request: HttpRequest, allowedStrategies: AuthStrategies, targetEntity: TargetEntity, targetUserIdKey: keyof InstanceType<TargetEntity>, targetIdParamKey: 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;
+    resolveBelongsToMetadata(controllerClass: Newable<Object>, controllerMethod: string): BelongsToMetadata<Newable<BaseEntity>> | undefined;
 }
 
 type AccessTokenPayload<Role extends string, T extends BaseUser<Role>> = {
@@ -460,6 +575,7 @@ declare class JwtAuthStrategy<RoleType extends string, UserType extends BaseUser
     private readonly refreshTokenSecret;
     private readonly refreshTokenExpiresInMs;
     private readonly userService;
+    private readonly logger;
     constructor();
     init(): void;
     private checkForEntities;
@@ -467,6 +583,7 @@ declare class JwtAuthStrategy<RoleType extends string, UserType extends BaseUser
     resolveUser(request: HttpRequest): Promise<UserType | undefined>;
     isLoggedIn(request: HttpRequest): Promise<boolean>;
     hasRole(request: HttpRequest, allowedRoles: RoleType[]): Promise<boolean>;
+    belongsTo<TargetEntity extends Newable<BaseEntity>>(request: HttpRequest, targetEntity: TargetEntity, targetUserIdKey: keyof InstanceType<TargetEntity>, targetIdParamKey: string): Promise<boolean>;
     private extractTokenFromRequest;
     private generateAccessToken;
     private generateRefreshToken;
@@ -548,6 +665,18 @@ declare abstract class HashUtilities {
     static equal(value: string, hash: string): Promise<boolean>;
 }
 
+declare class CronJobEntity implements BaseEntity {
+    id: string;
+    name: string;
+    cron: string;
+    active: boolean;
+    runOnInit: boolean;
+    stopOnError: boolean;
+    lastRun: Date | undefined;
+    errorMessage: string | undefined;
+}
+type CreateCronJobEntityData = OmitStrict<CronJobEntity, 'id'>;
+
 interface DataSourceServiceInterface {
     init: () => Promise<void>;
 }
@@ -580,35 +709,106 @@ type CreateOptions = BaseRepositoryOptions;
 
 type CreateAllOptions = BaseRepositoryOptions;
 
-type FindByIdOptions = BaseRepositoryOptions;
+type ArrayWhereFilter<ItemType> = null | {
+    equals: ItemType[];
+} | {
+    includes?: ItemType[];
+    isIncludedIn?: ItemType[];
+};
 
-type FindOneOptions<T extends BaseEntity> = BaseRepositoryOptions & FindOneOptions$1<T>;
+type BaseWhereFilter<T> = T | null;
 
-type FindAllOptions<T extends BaseEntity> = OmitStrict<FindManyOptions<T>, 'transaction'> & BaseRepositoryOptions;
+type BooleanWhereFilter = BaseWhereFilter<boolean>;
 
-type UpdateByIdOptions = BaseRepositoryOptions;
+type DateWhereFilter = BaseWhereFilter<Date> | {
+    not?: Date;
+    oneOf?: Date[];
+    notOneOf?: Date[];
+    after?: Date;
+    before?: Date;
+};
 
-type UpdateAllOptions = BaseRepositoryOptions;
+type NumberWhereFilter = BaseWhereFilter<number> | {
+    not?: number;
+    oneOf?: number[];
+    notOneOf?: number[];
+    greaterThan?: number;
+    greaterThanEquals?: number;
+    lesserThan?: number;
+    lesserThanEquals?: number;
+};
 
-type DeleteByIdOptions = BaseRepositoryOptions;
+type ObjectWhereFilter<T extends Object> = null | {
+    equals: T;
+    where?: never;
+    not?: never;
+    oneOf?: never;
+    notOneOf?: never;
+} | {
+    equals?: never;
+    where: Where<T>;
+    not?: never;
+    oneOf?: never;
+    notOneOf?: never;
+} | {
+    equals?: never;
+    where?: never;
+    not?: T;
+    oneOf?: T[];
+    notOneOf?: T[];
+};
+
+type StringWhereFilter = BaseWhereFilter<string> | {
+    not?: string;
+    oneOf?: string[];
+    notOneOf?: string[];
+    like?: string;
+    iLike?: string;
+};
+
+type Where<T extends Object> = WhereFilter<T> | WhereFilter<T>[];
+type WhereFilter<T extends Object> = {
+    [P in keyof T]?: WhereFilterProperty<T[P]> | WhereFilterProperty<T[P]>[];
+};
+type WhereFilterProperty<T> = T extends string ? StringWhereFilter : T extends number ? NumberWhereFilter : T extends boolean ? BooleanWhereFilter : T extends any[] ? ArrayWhereFilter<T[number]> : T extends Date ? DateWhereFilter : T extends object ? ObjectWhereFilter<T> : never;
+
+type FindAllOptions<T extends BaseEntity> = BaseRepositoryOptions & OmitStrict<FindManyOptions<T>, 'transaction' | 'where'> & {
+    where?: Where<T>;
+};
 
 type DeleteAllOptions<T extends BaseEntity> = FindAllOptions<T>;
 
+type DeleteByIdOptions = BaseRepositoryOptions;
+
+type FindAllPaginatedOptions<T extends BaseEntity> = OmitStrict<FindAllOptions<T>, 'skip' | 'take'>;
+
+type FindByIdOptions = BaseRepositoryOptions;
+
+type FindOneOptions<T extends BaseEntity> = BaseRepositoryOptions & OmitStrict<FindOneOptions$1<T>, 'where'> & {
+    where?: Where<T>;
+};
+
+type UpdateAllOptions = BaseRepositoryOptions;
+
+type UpdateByIdOptions = BaseRepositoryOptions;
+
 declare class Repository<T extends BaseEntity, CreateData extends DeepPartial<T> = DeepPartial<T>, UpdateData extends DeepPartial<T> = DeepPartial<T>> {
     private readonly entityClass;
     private readonly logger;
     private readonly typeOrmRepository;
     constructor(entityClass: Newable<T>, repo: Repository$1<T> | Repository<T>);
     private getManager;
+    private resolveFindOptionsWhere;
     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[]>;
+    findAllPaginated(page: number, limit: number, options?: FindAllPaginatedOptions<T>): Promise<PaginationResult<T>>;
     updateById(id: T['id'], data: UpdateData, options?: UpdateByIdOptions): Promise<T>;
-    updateAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], data: UpdateData, options?: UpdateAllOptions): Promise<T[]>;
+    updateAll(where: Where<T>, data: UpdateData, options?: UpdateAllOptions): Promise<T[]>;
     deleteById(id: T['id'], options?: DeleteByIdOptions): Promise<void>;
-    deleteAll(where: FindOptionsWhere<T> | FindOptionsWhere<T>[], options?: OmitStrict<DeleteAllOptions<T>, 'where'>): Promise<T[]>;
+    deleteAll(where: Where<T>, options?: OmitStrict<DeleteAllOptions<T>, 'where'>): Promise<T[]>;
 }
 
 declare class MigrationEntity implements BaseEntity {
@@ -630,7 +830,7 @@ declare abstract class Migration {
     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'];
+        type: ExcludeStrict<PropertyMetadata, RelationMetadata<BaseEntity> | FilePropertyMetadata>['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;
@@ -663,8 +863,9 @@ declare class Logger implements LoggerInterface {
     private getTimestamp;
 }
 
+type ToColumnMappableTypes = ExcludeStrict<PropertyMetadata, RelationMetadata<BaseEntity> | FilePropertyMetadata>['type'];
 declare abstract class BaseDataSource {
-    protected readonly columnTypeMappingOverride: Partial<Record<PropertyMetadata['type'], ColumnType>>;
+    protected readonly columnTypeMappingOverride: Partial<Record<ToColumnMappableTypes, ColumnType>>;
     private get columnTypeMapping();
     abstract readonly options: OmitStrict<DataSourceOptions, 'entities'>;
     abstract readonly entities: Newable<BaseEntity>[];
@@ -676,7 +877,7 @@ declare abstract class BaseDataSource {
     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;
+    protected propertyToColumnOptions(metadata: ExcludeStrict<PropertyMetadata, RelationMetadata<BaseEntity> | FilePropertyMetadata>, cls: Newable<BaseEntity>, key: string): EntitySchemaColumnOptions;
     getRepository<T extends BaseEntity>(cls: Newable<T>): Repository<T>;
     startTransaction(isolationLevel?: IsolationLevel): Promise<Transaction>;
     createQueryRunner(): QueryRunner;
@@ -692,6 +893,49 @@ declare abstract class BaseDataSource {
     }): string;
 }
 
+type CronConfig = OmitStrict<CronJobEntity, 'id' | 'lastRun' | 'errorMessage'> & {
+    syncToDb: boolean;
+};
+declare abstract class CronJob {
+    protected readonly overrideName?: string | undefined;
+    abstract readonly config: Partial<CronConfig> & Pick<CronConfig, 'name' | 'cron'>;
+    protected entity: CronJobEntity | undefined;
+    protected scheduledTask: ScheduledTask | undefined;
+    protected readonly cronJobRepository: Repository<CronJobEntity, CreateCronJobEntityData>;
+    protected readonly logger: LoggerInterface;
+    protected get fullConfig(): CronConfig;
+    get name(): string;
+    get task(): ScheduledTask | undefined;
+    get active(): boolean;
+    constructor(overrideName?: string | undefined);
+    init(): Promise<void>;
+    protected resolveEntity(): Promise<CronJobEntity>;
+    runOnTick(): Promise<boolean>;
+    runOnError(error: unknown): Promise<void>;
+    enable(): Promise<void>;
+    disable(): Promise<void>;
+    onError(error: unknown): void | Promise<void>;
+    abstract onTick(): void | Promise<void>;
+}
+
+interface CronServiceInterface {
+    readonly cronJobs: CronJob[];
+    init: (cronJobs: Newable<CronJob>[]) => Promise<void>;
+    schedule: (cronJob: CronJob) => Promise<void>;
+    enable: (name: string) => Promise<void>;
+    disable: (name: string) => Promise<void>;
+}
+
+declare class CronService implements CronServiceInterface {
+    protected logger: LoggerInterface;
+    readonly cronJobs: CronJob[];
+    constructor();
+    init(cronJobs: Newable<CronJob>[]): Promise<void>;
+    schedule(cronJob: CronJob): Promise<void>;
+    enable(name: string): Promise<void>;
+    disable(name: string): Promise<void>;
+}
+
 type DiToken<T> = Newable<T> | string;
 
 type DiProvider<T> = {
@@ -723,19 +967,20 @@ declare const ZIBRI_DI_TOKENS: {
     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";
+    readonly CRON_SERVICE: "zi.cron_service";
 };
 
 declare function inject<T>(token: DiToken<T>): T;
 
 interface BodyParserInterface {
     readonly contentType: MimeType;
-    parse: (req: HttpRequest) => Promise<unknown>;
+    parse: (req: HttpRequest, bodyMetadata: BodyMetadata) => Promise<unknown>;
 }
 
 declare function BodyParser(): ClassDecorator;
 
 interface ParserInterface {
-    parseRequestBody: (req: HttpRequest) => Promise<unknown>;
+    parseRequestBody: (req: HttpRequest, metadata: BodyMetadata) => Promise<unknown>;
     parsePathParam: (req: HttpRequest, metadata: PathParamMetadata) => unknown;
     parseQueryParam: (req: HttpRequest, metadata: QueryParamMetadata) => unknown;
     parseHeaderParam: (req: HttpRequest, metadata: HeaderParamMetadata) => unknown;
@@ -752,7 +997,7 @@ declare class Parser implements ParserInterface {
     parseHeaderParam(req: HttpRequest, metadata: HeaderParamMetadata): unknown;
     parseQueryParam(req: HttpRequest, metadata: QueryParamMetadata): unknown;
     parsePathParam(req: HttpRequest, metadata: PathParamMetadata): unknown;
-    parseRequestBody(req: HttpRequest): Promise<unknown>;
+    parseRequestBody(req: HttpRequest, metadata: BodyMetadata): Promise<unknown>;
     attachTo(): void;
 }
 
@@ -761,6 +1006,83 @@ declare class JsonBodyParser implements BodyParserInterface {
     parse(req: HttpRequest): Promise<unknown>;
 }
 
+/**
+ * A resolved file from a multipart/form-data request.
+ * Has the same properties as the File from multer but adds property metadata.
+ */
+declare class File implements Omit<Express.Multer.File, 'stream'> {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size: number;
+    destination: string;
+    filename: string;
+    path: string;
+    buffer: Buffer;
+}
+
+/**
+ * The raw value that a form-data property has.
+ */
+type FormDataValue = string | File | File[] | undefined;
+/**
+ * The name of the file that contains information about when a file was uploaded.
+ */
+declare const CREATED_AT_FILE_NAME: string;
+/**
+ * The result when parsing multipart/form-data request bodies.
+ * Has a resolved object with all the request bodies values on their respective keys.
+ */
+declare class FormData<FormDataType extends object> {
+    /**
+     * The resolved value as an object, containing all files and values correctly typed.
+     */
+    readonly value: FormDataType;
+    /**
+     * The temporary folder where all files are cached.
+     * Should be deleted after you handled the form data with the cleanup method.
+     */
+    readonly tempFolder: string;
+    private constructor();
+    static create<FormDataType extends object>(value: FormDataType, tempFolder: string): Promise<FormData<FormDataType>>;
+    /**
+     * Deletes all temporary files belonging to this form data.
+     */
+    cleanup(): Promise<void>;
+}
+
+declare class FormDataBodyParser implements BodyParserInterface {
+    readonly contentType: MimeType;
+    readonly tempPath: string;
+    parse(req: HttpRequest, metadata: BodyMetadata): Promise<FormData<object>>;
+    private removeTempFolder;
+    private requestToDataObject;
+    private addFilesToMap;
+    private addFileArrayToMap;
+    private addSingleFileToMap;
+    private addStringValuesToMap;
+}
+
+type BaseFileResponseData = {
+    mimeType?: LooseMimeType;
+    forceDownload?: boolean;
+};
+type FileResponseData = BaseFileResponseData & {
+    path: string;
+} | BaseFileResponseData & {
+    data: Buffer | Readable;
+    filename: `${string}.${string}`;
+};
+declare class FileResponse {
+    readonly data: Buffer | Readable | string;
+    readonly filename: `${string}.${string}`;
+    readonly mimeType: LooseMimeType;
+    readonly forceDownload: boolean;
+    constructor(data: FileResponseData);
+    private validate;
+}
+
 type ZibriApplicationOptions = {
     name: string;
     version: Version;
@@ -769,6 +1091,7 @@ type ZibriApplicationOptions = {
     providers?: DiProvider<unknown>[];
     bodyParsers?: Newable<BodyParserInterface>[];
     authStrategies?: AuthStrategies;
+    cronJobs?: Newable<CronJob>[];
 };
 
 /**
@@ -776,7 +1099,7 @@ type ZibriApplicationOptions = {
  */
 declare class ZibriApplication {
     private readonly providedOptions;
-    readonly express: Express;
+    readonly express: Express$1;
     private _router;
     get router(): RouterInterface;
     private logger;
@@ -785,6 +1108,7 @@ declare class ZibriApplication {
     private parser;
     private dataSourceService;
     private authService;
+    private cronService;
     private readonly options;
     constructor(providedOptions: ZibriApplicationOptions);
     init(): Promise<void>;
@@ -838,6 +1162,16 @@ declare class TypeMismatchValidationProblem implements ValidationProblem {
     readonly message: string;
     constructor(key: string, type: string);
 }
+declare class MaxFileSizeValidationProblem implements ValidationProblem {
+    readonly key: string;
+    readonly message: string;
+    constructor(key: string, maxSize: FileSize);
+}
+declare class MimeTypeMismatchValidationProblem implements ValidationProblem {
+    readonly key: string;
+    readonly message: string;
+    constructor(key: string, allowedMimeTypes: MimeType[]);
+}
 declare class RelationsNotAllowedValidationProblem implements ValidationProblem {
     readonly key: string;
     readonly message: string;
@@ -930,4 +1264,4 @@ declare function compareVersion(v1: Version, v2: Version): 'bigger' | 'equal' |
 
 declare function isVersion(value: string): value is Version;
 
-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 };
+export { type AccessTokenPayload, type AppData, AppState, type ArrayParamMetadata, type ArrayParamMetadataInput, type ArrayPropertyItemMetadata, type ArrayPropertyItemMetadataInput, type ArrayPropertyMetadata, type ArrayPropertyMetadataInput, type ArrayWhereFilter, AssetService, type AssetServiceInterface, Auth, AuthService, type AuthServiceInterface, type AuthStrategies, type AuthStrategyInterface, BadRequestError, BaseDataSource, type BaseEntity, type BaseRepositoryOptions, type BaseUser, type BelongsToMetadata, Body, type BodyMetadata, type BodyMetadataInput, BodyParser, type BodyParserInterface, type BooleanParamMetadata, type BooleanParamMetadataInput, type BooleanPropertyMetadata, type BooleanPropertyMetadataInput, type BooleanWhereFilter, CREATED_AT_FILE_NAME, type ColumnType, Controller, type ControllerRouteConfiguration, type CreateAllOptions, type CreateCronJobEntityData, type CreateOptions, type CronConfig, CronJob, CronJobEntity, CronService, type CronServiceInterface, CurrentUser, type CurrentUserMetadata, DataSource, type DataSourceOptions, DataSourceService, type DataSourceServiceInterface, type DateParamMetadata, type DateParamMetadataInput, type DatePropertyMetadata, type DatePropertyMetadataInput, type DateWhereFilter, type DefaultOpenApiResponse, Delete, type DeleteAllOptions, type DeleteByIdOptions, type DiProvider, type DiToken, type EncodedAccessToken, Entity, type EntityMetadata, File, type FileOpenApiResponse, type FilePropertyMetadata, type FilePropertyMetadataInput, FileResponse, type FileSize, type FindAllOptions, type FindAllPaginatedOptions, type FindByIdOptions, type FindOneOptions, FormData, type FormDataBodyMetadata, FormDataBodyParser, type FormDataValue, 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, type JsonBodyMetadata, JsonBodyParser, Jwt, JwtAuthData, JwtAuthStrategy, JwtCredentials, JwtCredentialsDto, JwtUtilities, type KnownHeader, type LogLevel, type LogLevels, Logger, type LoggerInterface, type LooseMimeType, type ManyToManyPropertyMetadata, type ManyToManyPropertyMetadataInput, type ManyToOnePropertyMetadata, type ManyToOnePropertyMetadataInput, MaxFileSizeValidationProblem, Migration, MigrationEntity, MimeType, MimeTypeMismatchValidationProblem, NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE, type Newable, NotFoundError, type NumberParamMetadata, type NumberParamMetadataInput, type NumberPropertyMetadata, type NumberPropertyMetadataInput, type NumberWhereFilter, type ObjectParamMetadata, type ObjectParamMetadataInput, type ObjectPropertyMetadata, type ObjectPropertyMetadataInput, type ObjectWhereFilter, OmitType, type OneToManyPropertyMetadata, type OneToManyPropertyMetadataInput, type OneToOnePropertyMetadata, type OneToOnePropertyMetadataInput, type OpenApiDefinition, type OpenApiOperation, type OpenApiParameter, type OpenApiPaths, type OpenApiRequestBodyObject, type OpenApiResponse, type OpenApiSchemaObject, type OpenApiSecurityRequirementObject, type OpenApiSecuritySchemeObject, OpenApiService, type OpenApiServiceInterface, type PaginationResult, 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, Response, type Route, type RouteConfiguration, Router, type RouterInterface, type SkipAuthMetadata, type SkipBelongsToMetadata, type SkipHasRoleMetadata, type SkipIsLoggedInMetadata, type SkipIsNotLoggedInMetadata, type StringFormat, type StringParamMetadata, type StringParamMetadataInput, type StringPropertyMetadata, type StringPropertyMetadataInput, type StringWhereFilter, 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, type Where, type WhereFilter, type WhereFilterProperty, ZIBRI_DI_TOKENS, ZibriApplication, type ZibriApplicationOptions, compareVersion, errorHandler, fileSizeToBytes, inject, isHttpError, isMimeType, isVersion, repositoryTokenFor };