@clairejs/server 3.11.8 → 3.11.9

package/dist/http/auth/rbac.d.ts

@@ -1,34 +1,34 @@
-export interface RbacRolePolicy {
-    roleId: number;
-    policyId: number;
-}
-export interface RbacRole {
-    roleId: number;
-    isSuperRole: boolean;
-    isAnonymousRole: boolean;
-}
-export interface RbacPolicyPermissionCondition {
-    policyPermissionId: number;
-    conditionName: string;
-    conditionValue: string;
-}
-export interface RbacPolicyPermission {
-    id: number;
-    policyId: number;
-    permission: string;
-}
-export interface RbacPolicy {
-    policyId: number;
-    isUserDefined: boolean;
-}
-export interface PrincipalRole {
-    principalId: number;
-    roleIds: number[];
-}
-export interface RbacCache {
-    roles?: RbacRole[];
-    policies?: RbacPolicy[];
-    rolePolicies?: RbacRolePolicy[];
-    policyPermissions?: RbacPolicyPermission[];
-    policyPermissionConditions?: RbacPolicyPermissionCondition[];
-}
+export interface RbacRolePolicy {
+    roleId: number;
+    policyId: number;
+}
+export interface RbacRole {
+    roleId: number;
+    isSuperRole: boolean;
+    isAnonymousRole: boolean;
+}
+export interface RbacPolicyPermissionCondition {
+    policyPermissionId: number;
+    conditionName: string;
+    conditionValue: string;
+}
+export interface RbacPolicyPermission {
+    id: number;
+    policyId: number;
+    permission: string;
+}
+export interface RbacPolicy {
+    policyId: number;
+    isUserDefined: boolean;
+}
+export interface PrincipalRole {
+    principalId: number;
+    roleIds: number[];
+}
+export interface RbacCache {
+    roles?: RbacRole[];
+    policies?: RbacPolicy[];
+    rolePolicies?: RbacRolePolicy[];
+    policyPermissions?: RbacPolicyPermission[];
+    policyPermissionConditions?: RbacPolicyPermissionCondition[];
+}

package/dist/http/common/HttpRequest.d.ts

@@ -1,40 +1,40 @@
-import { HttpMethod, SocketMethod } from "@clairejs/core";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-import { IServerSocket } from "../../socket/IServerSocket";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-export declare class HttpRequest {
-    private valueHolder;
-    private method;
-    private pathName;
-    private headers;
-    private cookies;
-    private params;
-    private query;
-    private body;
-    private hash;
-    private authInfo?;
-    constructor(options: {
-        method: HttpMethod | SocketMethod;
-        pathName: string;
-        headers?: object;
-        hash?: string;
-        query?: object;
-        params?: object;
-        cookies?: object;
-        body?: any;
-        socket?: IServerSocket;
-    }, endpointMetadata?: EndpointMetadata);
-    private jsonParsing;
-    getAuthInfo(): IPrincipal | undefined;
-    setAuthInfo(authInfo?: IPrincipal): void;
-    getHeaders(): any;
-    getMethod(): HttpMethod | SocketMethod;
-    getHash(): string;
-    getPathName(): string;
-    getValue<T extends any>(key: string): T;
-    setValue<T extends any>(key: string, value: T): void;
-    getParams<T extends any>(): T;
-    getQuery<T extends any>(): T;
-    getCookies<T extends any>(): T;
-    getBody<T extends any>(): T;
-}
+import { HttpMethod, SocketMethod } from "@clairejs/core";
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { IServerSocket } from "../../socket/IServerSocket";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+export declare class HttpRequest {
+    private valueHolder;
+    private method;
+    private pathName;
+    private headers;
+    private cookies;
+    private params;
+    private query;
+    private body;
+    private hash;
+    private authInfo?;
+    constructor(options: {
+        method: HttpMethod | SocketMethod;
+        pathName: string;
+        headers?: object;
+        hash?: string;
+        query?: object;
+        params?: object;
+        cookies?: object;
+        body?: any;
+        socket?: IServerSocket;
+    }, endpointMetadata?: EndpointMetadata);
+    private jsonParsing;
+    getAuthInfo(): IPrincipal | undefined;
+    setAuthInfo(authInfo?: IPrincipal): void;
+    getHeaders(): any;
+    getMethod(): HttpMethod | SocketMethod;
+    getHash(): string;
+    getPathName(): string;
+    getValue<T extends any>(key: string): T;
+    setValue<T extends any>(key: string, value: T): void;
+    getParams<T extends any>(): T;
+    getQuery<T extends any>(): T;
+    getCookies<T extends any>(): T;
+    getBody<T extends any>(): T;
+}

package/dist/http/common/HttpResponse.d.ts

@@ -1,34 +1,34 @@
-/// <reference types="node" />
-export interface CookieOptions {
-    maxAge?: number | undefined;
-    expires?: Date | undefined;
-    httpOnly?: boolean | undefined;
-    path?: string | undefined;
-    domain?: string | undefined;
-    secure?: boolean | undefined;
-    sameSite?: boolean | "lax" | "strict" | "none" | undefined;
-}
-export interface CookieValue {
-    value: string;
-    options?: CookieOptions;
-}
-export declare class HttpResponse<T> {
-    value?: T;
-    code?: number;
-    headers: Record<string, string>;
-    cookies: Record<string, CookieValue>;
-}
-export declare class ResponseBuilder<T> {
-    response: HttpResponse<T>;
-    protected constructor();
-    status(code: number): this;
-    header(name: string, value: string): this;
-    cookie(name: string, value: string, options?: CookieOptions): this;
-    get(): HttpResponse<T>;
-    static json<T>(jsonValue?: T): ResponseBuilder<T>;
-    static html(htmlValue?: string): ResponseBuilder<unknown>;
-    static binary(buffer?: Buffer): ResponseBuilder<unknown>;
-    static success(): HttpResponse<unknown>;
-    static notFound(data?: any): HttpResponse<unknown>;
-    static accessDenied(data?: any): HttpResponse<unknown>;
-}
+/// <reference types="node" />
+export interface CookieOptions {
+    maxAge?: number | undefined;
+    expires?: Date | undefined;
+    httpOnly?: boolean | undefined;
+    path?: string | undefined;
+    domain?: string | undefined;
+    secure?: boolean | undefined;
+    sameSite?: boolean | "lax" | "strict" | "none" | undefined;
+}
+export interface CookieValue {
+    value: string;
+    options?: CookieOptions;
+}
+export declare class HttpResponse<T> {
+    value?: T;
+    code?: number;
+    headers: Record<string, string>;
+    cookies: Record<string, CookieValue>;
+}
+export declare class ResponseBuilder<T> {
+    response: HttpResponse<T>;
+    protected constructor();
+    status(code: number): this;
+    header(name: string, value: string): this;
+    cookie(name: string, value: string, options?: CookieOptions): this;
+    get(): HttpResponse<T>;
+    static json<T>(jsonValue?: T): ResponseBuilder<T>;
+    static html(htmlValue?: string): ResponseBuilder<unknown>;
+    static binary(buffer?: Buffer): ResponseBuilder<unknown>;
+    static success(): HttpResponse<unknown>;
+    static notFound(data?: any): HttpResponse<unknown>;
+    static accessDenied(data?: any): HttpResponse<unknown>;
+}

package/dist/http/controller/AbstractHttpController.d.ts

@@ -1,9 +1,9 @@
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-import { ITransactionFactory, ITransactionProvider } from "@clairejs/orm";
-export declare abstract class AbstractHttpController implements ITransactionProvider, ITransactionFactory {
-    protected readonly databaseAdapter: ITransactionFactory;
-    constructor(databaseAdapter: ITransactionFactory);
-    createTransaction(): Promise<import("@clairejs/orm").ITransaction>;
-    getCurrentTransaction(): Promise<import("@clairejs/orm").ITransaction>;
-    getEndpointMetadata(): Readonly<EndpointMetadata>[];
-}
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { ITransactionFactory, ITransactionProvider } from "@clairejs/orm";
+export declare abstract class AbstractHttpController implements ITransactionProvider, ITransactionFactory {
+    protected readonly databaseAdapter: ITransactionFactory;
+    constructor(databaseAdapter: ITransactionFactory);
+    createTransaction(): Promise<import("@clairejs/orm").ITransaction>;
+    getCurrentTransaction(): Promise<import("@clairejs/orm").ITransaction>;
+    getEndpointMetadata(): Readonly<EndpointMetadata>[];
+}

package/dist/http/controller/AbstractHttpMiddleware.d.ts

@@ -1,10 +1,10 @@
-import { HttpRequest } from "../common/HttpRequest";
-import { HttpResponse } from "../common/HttpResponse";
-export declare abstract class AbstractHttpMiddleware {
-    /**
-     * Return true to proceed to next middleware and controller, return false to immediately break and returning current response
-     * @param request the http request
-     * @param response the http response
-     */
-    abstract intercept(request: HttpRequest, response: HttpResponse<any>): Promise<boolean>;
-}
+import { HttpRequest } from "../common/HttpRequest";
+import { HttpResponse } from "../common/HttpResponse";
+export declare abstract class AbstractHttpMiddleware {
+    /**
+     * Return true to proceed to next middleware and controller, return false to immediately break and returning current response
+     * @param request the http request
+     * @param response the http response
+     */
+    abstract intercept(request: HttpRequest, response: HttpResponse<any>): Promise<boolean>;
+}

package/dist/http/controller/AbstractHttpRequestHandler.d.ts

@@ -1,18 +1,18 @@
-import { AbstractLogger } from "@clairejs/core";
-import { HttpData } from "../../common/request/HttpData";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { HttpResponse } from "../common/HttpResponse";
-import { CorsConfig } from "../security/cors";
-import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
-import { ControllerMetadata } from "./ControllerMetadata";
-export declare abstract class AbstractHttpRequestHandler {
-    readonly mountPoint: string;
-    readonly logger: AbstractLogger;
-    private mountedEndpointInfo?;
-    corsConfig?: CorsConfig;
-    constructor(mountPoint: string, logger: AbstractLogger);
-    protected resolverMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
-    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
-    abstract getMiddleware(): Promise<AbstractHttpMiddleware[]>;
-    abstract handle(httpData: HttpData): Promise<HttpResponse<any>>;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { HttpData } from "../../common/request/HttpData";
+import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { HttpResponse } from "../common/HttpResponse";
+import { CorsConfig } from "../security/cors";
+import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
+import { ControllerMetadata } from "./ControllerMetadata";
+export declare abstract class AbstractHttpRequestHandler {
+    readonly mountPoint: string;
+    readonly logger: AbstractLogger;
+    private mountedEndpointInfo?;
+    corsConfig?: CorsConfig;
+    constructor(mountPoint: string, logger: AbstractLogger);
+    protected resolverMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
+    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+    abstract getMiddleware(): Promise<AbstractHttpMiddleware[]>;
+    abstract handle(httpData: HttpData): Promise<HttpResponse<any>>;
+}

package/dist/http/controller/ControllerMetadata.d.ts

@@ -1,6 +1,6 @@
-import { ObjectMetadata } from "@clairejs/core";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-export interface ControllerMetadata extends ObjectMetadata {
-    fields: EndpointMetadata[];
-    permissionGroup?: string;
-}
+import { ObjectMetadata } from "@clairejs/core";
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+export interface ControllerMetadata extends ObjectMetadata {
+    fields: EndpointMetadata[];
+    permissionGroup?: string;
+}

package/dist/http/controller/CrudHttpController.d.ts

@@ -1,41 +1,41 @@
-import { DtoMetadata, CreateManyResponseBody, GetManyResponseBody, UpdateManyResponse, Identifiable, Constructor } from "@clairejs/core";
-import { IQueryProvider, ITransactionFactory } from "@clairejs/orm";
-import { HttpRequest } from "../common/HttpRequest";
-import { AbstractHttpController } from "./AbstractHttpController";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-import { HttpResponse } from "../common/HttpResponse";
-import { ICrudRepository } from "../repository/ICrudRepository";
-export declare class CrudHttpController<T extends Identifiable> extends AbstractHttpController {
-    protected readonly model: Constructor<T>;
-    protected readonly crudRepository: ICrudRepository<T>;
-    protected readonly databaseAdapter: ITransactionFactory & IQueryProvider;
-    protected readonly modelMetadata: DtoMetadata;
-    private authProvider?;
-    constructor(model: Constructor<T>, crudRepository: ICrudRepository<T>, databaseAdapter: ITransactionFactory & IQueryProvider);
-    protected getMountedUrl(): string;
-    private getAuthProvider;
-    /**
-     * This provides endpoint metadata for mounting /POST request.
-     */
-    private createManyEndpoinMetadata;
-    /**
-     * This provides endpoint metadata for mounting /GET request.
-     */
-    private getManyEndpointMetadata;
-    /**
-     * This provides endpoint metadata for mounting /PUT request.
-     */
-    private updateManyEndpoinMetadata;
-    /**
-     * This provides endpoint metadata for mounting /DELETE request.
-     */
-    private deleteManyEndpoinMetadata;
-    /**
-     * Handler functions
-     */
-    getEndpointMetadata(): Readonly<EndpointMetadata>[];
-    protected createMany(req: HttpRequest): Promise<HttpResponse<CreateManyResponseBody<T>>>;
-    protected getMany(req: HttpRequest): Promise<HttpResponse<GetManyResponseBody<T>>>;
-    protected updateMany(req: HttpRequest): Promise<HttpResponse<UpdateManyResponse<T>>>;
-    protected deleteMany(req: HttpRequest): Promise<HttpResponse<UpdateManyResponse<T>>>;
-}
+import { DtoMetadata, CreateManyResponseBody, GetManyResponseBody, UpdateManyResponse, Identifiable, Constructor } from "@clairejs/core";
+import { IQueryProvider, ITransactionFactory } from "@clairejs/orm";
+import { HttpRequest } from "../common/HttpRequest";
+import { AbstractHttpController } from "./AbstractHttpController";
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { HttpResponse } from "../common/HttpResponse";
+import { ICrudRepository } from "../repository/ICrudRepository";
+export declare class CrudHttpController<T extends Identifiable> extends AbstractHttpController {
+    protected readonly model: Constructor<T>;
+    protected readonly crudRepository: ICrudRepository<T>;
+    protected readonly databaseAdapter: ITransactionFactory & IQueryProvider;
+    protected readonly modelMetadata: DtoMetadata;
+    private authProvider?;
+    constructor(model: Constructor<T>, crudRepository: ICrudRepository<T>, databaseAdapter: ITransactionFactory & IQueryProvider);
+    protected getMountedUrl(): string;
+    private getAuthProvider;
+    /**
+     * This provides endpoint metadata for mounting /POST request.
+     */
+    private createManyEndpoinMetadata;
+    /**
+     * This provides endpoint metadata for mounting /GET request.
+     */
+    private getManyEndpointMetadata;
+    /**
+     * This provides endpoint metadata for mounting /PUT request.
+     */
+    private updateManyEndpoinMetadata;
+    /**
+     * This provides endpoint metadata for mounting /DELETE request.
+     */
+    private deleteManyEndpoinMetadata;
+    /**
+     * Handler functions
+     */
+    getEndpointMetadata(): Readonly<EndpointMetadata>[];
+    protected createMany(req: HttpRequest): Promise<HttpResponse<CreateManyResponseBody<T>>>;
+    protected getMany(req: HttpRequest): Promise<HttpResponse<GetManyResponseBody<T>>>;
+    protected updateMany(req: HttpRequest): Promise<HttpResponse<UpdateManyResponse<T>>>;
+    protected deleteMany(req: HttpRequest): Promise<HttpResponse<UpdateManyResponse<T>>>;
+}

package/dist/http/controller/DefaultHttpRequestHandler.d.ts

@@ -1,21 +1,21 @@
-import { AbstractLogger } from "@clairejs/core";
-import { HttpResponse } from "../common/HttpResponse";
-import { HttpRequest } from "../common/HttpRequest";
-import { AbstractHttpAuthorizationProvider } from "../auth/AbstractHttpAuthorizationProvider";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { AbstractHttpRequestHandler } from "./AbstractHttpRequestHandler";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-import { HttpData } from "../../common/request/HttpData";
-import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
-export declare class DefaultHttpRequestHandler extends AbstractHttpRequestHandler {
-    readonly logger: AbstractLogger;
-    readonly authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>;
-    private _middleware;
-    constructor(logger: AbstractLogger, authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>);
-    protected accessControl(endpoint: MountedEndpointInfo, req: HttpRequest): Promise<void>;
-    protected handleRequest(endpoint: MountedEndpointInfo, req: HttpRequest): Promise<HttpResponse<any>>;
-    exit(): void;
-    private getResponse;
-    handle(httpData: HttpData): Promise<HttpResponse<any>>;
-    getMiddleware(): Promise<AbstractHttpMiddleware[]>;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { HttpResponse } from "../common/HttpResponse";
+import { HttpRequest } from "../common/HttpRequest";
+import { AbstractHttpAuthorizationProvider } from "../auth/AbstractHttpAuthorizationProvider";
+import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { AbstractHttpRequestHandler } from "./AbstractHttpRequestHandler";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+import { HttpData } from "../../common/request/HttpData";
+import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
+export declare class DefaultHttpRequestHandler extends AbstractHttpRequestHandler {
+    readonly logger: AbstractLogger;
+    readonly authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>;
+    private _middleware;
+    constructor(logger: AbstractLogger, authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>);
+    protected accessControl(endpoint: MountedEndpointInfo, req: HttpRequest): Promise<void>;
+    protected handleRequest(endpoint: MountedEndpointInfo, req: HttpRequest): Promise<HttpResponse<any>>;
+    exit(): void;
+    private getResponse;
+    handle(httpData: HttpData): Promise<HttpResponse<any>>;
+    getMiddleware(): Promise<AbstractHttpMiddleware[]>;
+}

package/dist/http/decorators.d.ts

@@ -1,35 +1,35 @@
-import { HttpMethod, Constructor, AbstractModel } from "@clairejs/core";
-import { AbstractHttpController } from "./controller/AbstractHttpController";
-import { AbstractAccessCondition } from "./security/AbstractAccessCondition";
-import { HttpResponse } from "./common/HttpResponse";
-import { UriMapperHandler } from "./file-upload/types";
-import { IPrincipal } from "../common/auth/IPrincipal";
-declare type HttpFunctionMethod<T> = (...args: any[]) => Promise<HttpResponse<T>>;
-export declare const Controller: (config?: {
-    permissionGroup?: string | undefined;
-} | undefined) => <T extends AbstractHttpController>(constructor: Constructor<T>) => void;
-export declare const ApiDescription: (description: string) => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const Endpoint: (config: {
-    method: HttpMethod;
-    url: string;
-}) => (prototype: any, propertyKey: string) => void;
-export declare const Post: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
-export declare const Put: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
-export declare const Del: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
-export declare const Get: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
-export declare const ApiResponse: <T>(responseClass: Constructor<T>) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<T>>) => void;
-export declare const OpenAccess: () => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const TfaRequired: () => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const AccessCondition: (conditions: Constructor<AbstractAccessCondition>[]) => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const Body: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const Params: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const Queries: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const Headers: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const Socket: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const Raw: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const UriMapper: <T extends AbstractModel>(mapper: UriMapperHandler<T>) => (prototype: T, propertyKey: keyof T) => void;
-/**
- * Current User decorator only has effect when being used with ICrudRepository.
- *  */
-export declare const CurrentUser: <T extends IPrincipal>(resolver: (principal: T) => any) => (prototype: any, propertyKey: string) => void;
-export {};
+import { HttpMethod, Constructor, AbstractModel } from "@clairejs/core";
+import { AbstractHttpController } from "./controller/AbstractHttpController";
+import { AbstractAccessCondition } from "./security/AbstractAccessCondition";
+import { HttpResponse } from "./common/HttpResponse";
+import { UriMapperHandler } from "./file-upload/types";
+import { IPrincipal } from "../common/auth/IPrincipal";
+declare type HttpFunctionMethod<T> = (...args: any[]) => Promise<HttpResponse<T>>;
+export declare const Controller: (config?: {
+    permissionGroup?: string | undefined;
+} | undefined) => <T extends AbstractHttpController>(constructor: Constructor<T>) => void;
+export declare const ApiDescription: (description: string) => (prototype: AbstractHttpController, propertyKey: string) => void;
+export declare const Endpoint: (config: {
+    method: HttpMethod;
+    url: string;
+}) => (prototype: any, propertyKey: string) => void;
+export declare const Post: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
+export declare const Put: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
+export declare const Del: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
+export declare const Get: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
+export declare const ApiResponse: <T>(responseClass: Constructor<T>) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<T>>) => void;
+export declare const OpenAccess: () => (prototype: AbstractHttpController, propertyKey: string) => void;
+export declare const TfaRequired: () => (prototype: AbstractHttpController, propertyKey: string) => void;
+export declare const AccessCondition: (conditions: Constructor<AbstractAccessCondition>[]) => (prototype: AbstractHttpController, propertyKey: string) => void;
+export declare const Body: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const Params: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const Queries: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const Headers: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const Socket: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const Raw: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
+export declare const UriMapper: <T extends AbstractModel>(mapper: UriMapperHandler<T>) => (prototype: T, propertyKey: keyof T) => void;
+/**
+ * Current User decorator only has effect when being used with ICrudRepository.
+ *  */
+export declare const CurrentUser: <T extends IPrincipal>(resolver: (principal: T) => any) => (prototype: any, propertyKey: string) => void;
+export {};

package/dist/http/file-upload/AbstractFileUploadHandler.d.ts

@@ -1,6 +1,6 @@
-export declare abstract class AbstractFileUploadHandler {
-    abstract moveFile(fromUri: string, toUri: string): Promise<void>;
-    abstract removeFile(uri: string): Promise<void>;
-    abstract resolvePublicUrl(uri: string): Promise<string>;
-    abstract resolvePrivateUrl(uri: string): Promise<string>;
-}
+export declare abstract class AbstractFileUploadHandler {
+    abstract moveFile(fromUri: string, toUri: string): Promise<void>;
+    abstract removeFile(uri: string): Promise<void>;
+    abstract resolvePublicUrl(uri: string): Promise<string>;
+    abstract resolvePrivateUrl(uri: string): Promise<string>;
+}

package/dist/http/file-upload/FileUploadHandler.d.ts

@@ -1,10 +1,10 @@
-import { AbstractFileService } from "../../services/AbstractFileService";
-import { AbstractFileUploadHandler } from "./AbstractFileUploadHandler";
-export declare class FileUploadHandler extends AbstractFileUploadHandler {
-    readonly fileService: AbstractFileService;
-    constructor(fileService: AbstractFileService);
-    moveFile(fromURI: string, toURI: string): Promise<void>;
-    removeFile(uri: string): Promise<void>;
-    resolvePublicUrl(uri: string): Promise<string>;
-    resolvePrivateUrl(uri: string): Promise<string>;
-}
+import { AbstractFileService } from "../../services/AbstractFileService";
+import { AbstractFileUploadHandler } from "./AbstractFileUploadHandler";
+export declare class FileUploadHandler extends AbstractFileUploadHandler {
+    readonly fileService: AbstractFileService;
+    constructor(fileService: AbstractFileService);
+    moveFile(fromURI: string, toURI: string): Promise<void>;
+    removeFile(uri: string): Promise<void>;
+    resolvePublicUrl(uri: string): Promise<string>;
+    resolvePrivateUrl(uri: string): Promise<string>;
+}

package/dist/http/file-upload/types.d.ts

@@ -1,3 +1,3 @@
-import { AbstractModel } from "@clairejs/core";
-import { IQueryProvider } from "@clairejs/orm";
-export declare type UriMapperHandler<T extends AbstractModel> = (queryProvider: IQueryProvider, record: T, tmpUri: string) => Promise<string>;
+import { AbstractModel } from "@clairejs/core";
+import { IQueryProvider } from "@clairejs/orm";
+export declare type UriMapperHandler<T extends AbstractModel> = (queryProvider: IQueryProvider, record: T, tmpUri: string) => Promise<string>;

package/dist/http/repository/AbstractRepository.d.ts

@@ -1,10 +1,10 @@
-import { Constructor, DeepPartial, Identifiable } from "@clairejs/core";
-import { ServerModelMetadata } from "../../common/ServerModelMetadata";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-export declare abstract class AbstractRepository<T extends Identifiable> {
-    readonly model: Constructor<T>;
-    protected readonly modelMetadata: ServerModelMetadata;
-    constructor(model: Constructor<T>);
-    protected beforeCreating(principal: IPrincipal | undefined, records: DeepPartial<T>[]): Promise<void>;
-    protected project(records: Partial<T>[], projection?: (keyof T)[]): any[];
-}
+import { Constructor, DeepPartial, Identifiable } from "@clairejs/core";
+import { ServerModelMetadata } from "../../common/ServerModelMetadata";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+export declare abstract class AbstractRepository<T extends Identifiable> {
+    readonly model: Constructor<T>;
+    protected readonly modelMetadata: ServerModelMetadata;
+    constructor(model: Constructor<T>);
+    protected beforeCreating(principal: IPrincipal | undefined, records: DeepPartial<T>[]): Promise<void>;
+    protected project(records: Partial<T>[], projection?: (keyof T)[]): any[];
+}