axe-api 1.0.0-rc8 → 1.0.0

package/build/src/Services/ElasticService.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const elasticsearch_1 = require("@elastic/elasticsearch");
+const LogService_1 = __importDefault(require("./LogService"));
+class ElasticService {
+    constructor(config, options) {
+        this.config = config;
+        this.client = new elasticsearch_1.Client(options);
+        LogService_1.default.debug("Elasticsearch connection has been completed.");
+    }
+    createIndex(modelName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.toIndex(modelName);
+            const result = yield this.client.indices.exists({ index });
+            if (result === false) {
+                yield this.client.indices.create({ index });
+                LogService_1.default.debug(`ES.create({ index: ${index} })`);
+            }
+        });
+    }
+    insert(modelName, id, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.toIndex(modelName);
+            const result = yield this.client.index({ index, id: id.toString(), body });
+            LogService_1.default.debug(`\t🔄 ES.insert(${index}) => ${id}`);
+            return result;
+        });
+    }
+    update(modelName, id, doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.toIndex(modelName);
+            const result = yield this.client.update({ index, id: id.toString(), doc });
+            LogService_1.default.debug(`\t🔄 ES.update(${index}) => ${id}`);
+            return result;
+        });
+    }
+    delete(modelName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.toIndex(modelName);
+            const result = yield this.client.delete({ index, id: id.toString() });
+            LogService_1.default.debug(`\t🔄 ES.delete(${index}) => ${id}`);
+            return result;
+        });
+    }
+    search(modelName, page, size, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.toIndex(modelName);
+            LogService_1.default.debug(`\t🔄 ES.search(${index}) => ${JSON.stringify(body)}`);
+            return yield this.client.search({
+                index,
+                body,
+                from: (page - 1) * size,
+                size,
+            });
+        });
+    }
+    toIndex(modelName) {
+        const prefix = this.config.indexPrefix ? `${this.config.indexPrefix}-` : "";
+        return `${prefix}${modelName.toLowerCase()}`.trim();
+    }
+}
+exports.default = ElasticService;

package/build/src/Services/IoCService.d.ts

@@ -1,9 +1,36 @@
 declare class IoCService {
     private static items;
+    /**
+     * Adding a dependency creator function.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * IoCService.bind("MailService", () => new MyMailService())
+     */
     static bind(name: string, callback: any): void;
+    /**
+     * Adding a singleton dependency creator function.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * IoCService.singleton("MySingleton", () => new MySingleton())
+     */
     static singleton(name: string, callback: any): void;
-    static use(name: string): Promise<any>;
-    static useByType<T>(name: string): Promise<T>;
+    /**
+     * Getting the service by the name.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * await IoCService.use<MySingleton>("MySingleton")
+     */
+    static use<T>(name: string): Promise<T>;
+    private static getByName;
     private static _add;
 }
 export default IoCService;

package/build/src/Services/IoCService.js

@@ -11,13 +11,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const Enums_1 = require("../Enums");
 class IoCService {
+    /**
+     * Adding a dependency creator function.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * IoCService.bind("MailService", () => new MyMailService())
+     */
     static bind(name, callback) {
         this._add(Enums_1.DependencyTypes.BIND, name, callback);
     }
+    /**
+     * Adding a singleton dependency creator function.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * IoCService.singleton("MySingleton", () => new MySingleton())
+     */
     static singleton(name, callback) {
         this._add(Enums_1.DependencyTypes.SINGLETON, name, callback);
     }
+    /**
+     * Getting the service by the name.
+     *
+     * @param name
+     * @param callback
+     * @example
+     *
+     * await IoCService.use<MySingleton>("MySingleton")
+     */
     static use(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield IoCService.getByName(name);
+            return result;
+        });
+    }
+    static getByName(name) {
         return __awaiter(this, void 0, void 0, function* () {
             const item = IoCService.items[name];
             if (!item) {
@@ -33,12 +66,6 @@ class IoCService {
             return item.instance;
         });
     }
-    static useByType(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield IoCService.use(name);
-            return result;
-        });
-    }
     static _add(type, name, callback) {
         IoCService.items[name] = {
             type,

package/build/src/Services/LimitService.d.ts

@@ -1,5 +1,23 @@
 import { QueryFeature } from "../Enums";
 import { IModelService, IQueryLimitConfig } from "../Interfaces";
+/**
+ * Allow a query feature.
+ *
+ * @param feature
+ * @param keys
+ * @returns
+ * @example
+ *  allow(QueryFeature.WhereLike)
+ */
 export declare const allow: (feature: QueryFeature, keys?: string[]) => IQueryLimitConfig[];
+/**
+ * Deny a query feature.
+ *
+ * @param feature
+ * @param keys
+ * @returns
+ * @example
+ *  deny(QueryFeature.WhereLike)
+ */
 export declare const deny: (feature: QueryFeature, keys?: string[]) => IQueryLimitConfig[];
 export declare const valideteQueryFeature: (model: IModelService, feature: QueryFeature, key?: string | null, errorDescription?: string) => void;

package/build/src/Services/LimitService.js

@@ -84,10 +84,28 @@ const generatePermission = (type, feature, keys = []) => {
     })
         .flat();
 };
+/**
+ * Allow a query feature.
+ *
+ * @param feature
+ * @param keys
+ * @returns
+ * @example
+ *  allow(QueryFeature.WhereLike)
+ */
 const allow = (feature, keys = []) => {
     return generatePermission(Enums_1.QueryFeatureType.Allow, feature, keys);
 };
 exports.allow = allow;
+/**
+ * Deny a query feature.
+ *
+ * @param feature
+ * @param keys
+ * @returns
+ * @example
+ *  deny(QueryFeature.WhereLike)
+ */
 const deny = (feature, keys = []) => {
     return generatePermission(Enums_1.QueryFeatureType.Deny, feature, keys);
 };

package/build/src/Services/ModelService.d.ts

@@ -1,24 +1,28 @@
-import { HookFunctionTypes, Extensions } from "../Enums";
-import { IColumn, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
+import { HookFunctionTypes, Extensions, HandlerTypes } from "../Enums";
+import { ICacheConfiguration, IColumn, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
 import Model from "./../Model";
-import { HookFunctions, PhaseFunction, SerializationFunction } from "../Types";
+import { ModelHooks, PhaseFunction, SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: HookFunctions;
-    events: HookFunctions;
+    hooks: ModelHooks;
+    events: ModelHooks;
     children: IModelService[];
     isRecursive: boolean;
     queryLimits: IQueryLimitConfig[];
     serialize: SerializationFunction | null;
+    cacheConfiguration: Record<string, ICacheConfiguration>;
     constructor(name: string, instance: Model);
     setColumns(columns: IColumn[]): void;
+    setCacheConfiguration(handler: string, cache: ICacheConfiguration): void;
+    getCacheConfiguration(handler: HandlerTypes): ICacheConfiguration;
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: PhaseFunction): void;
     setQueryLimits(limits: IQueryLimitConfig[]): void;
     setSerialization(callback: SerializationFunction): void;
+    setAsRecursive(): void;
     private setHooks;
     private setEvents;
 }

package/build/src/Services/ModelService.js

@@ -14,11 +14,18 @@ class ModelService {
         this.isRecursive = false;
         this.queryLimits = [];
         this.serialize = null;
+        this.cacheConfiguration = {};
     }
     setColumns(columns) {
         this.columns = columns;
         this.columnNames = this.columns.map((i) => i.name);
     }
+    setCacheConfiguration(handler, cache) {
+        this.cacheConfiguration[handler] = cache;
+    }
+    getCacheConfiguration(handler) {
+        return this.cacheConfiguration[handler];
+    }
     setExtensions(type, hookFunctionType, data) {
         if (type == Enums_1.Extensions.Hooks) {
             this.setHooks(hookFunctionType, data);
@@ -36,6 +43,10 @@ class ModelService {
     setSerialization(callback) {
         this.serialize = callback;
     }
+    setAsRecursive() {
+        this.isRecursive = true;
+        this.children = [];
+    }
     setHooks(hookFunctionType, data) {
         this.hooks[hookFunctionType] = data;
     }

package/build/src/Services/QueryService.d.ts

@@ -1,4 +1,4 @@
-import { IQuery, ISortField, NestedWhere, IWhere, IModelService, IVersionConfig } from "../Interfaces";
+import { IQuery, ISortField, NestedWhere, IWhere, IModelService, AxeVersionConfig } from "../Interfaces";
 import { Knex } from "knex";
 declare class QueryService {
     model: IModelService;
@@ -6,8 +6,8 @@ declare class QueryService {
     usedConditionColumns: string[];
     relationColumns: string[];
     createdJoins: string[];
-    config: IVersionConfig;
-    constructor(model: IModelService, models: IModelService[], config: IVersionConfig);
+    config: AxeVersionConfig;
+    constructor(model: IModelService, models: IModelService[], config: AxeVersionConfig);
     applyFields(query: Knex.QueryBuilder, fields: string[]): void;
     applySorting(query: Knex.QueryBuilder, sort: ISortField[]): void;
     applyWheresInsideGroup(sub: Knex.QueryBuilder, ruleSet: NestedWhere | IWhere): void;

package/build/src/Services/QueryService.js

@@ -184,6 +184,7 @@ class QueryService {
             sort: this.parseSortingOptions(sections.get("sort")),
             q: this.parseCondition(q),
             with: withQueryResolver.resolve(sections.get("with") || ""),
+            text: sections.get("text") || null,
             trashed: sections.get("trashed")
                 ? (0, Helpers_1.isBoolean)(sections.get("trashed"))
                 : false,
@@ -331,6 +332,11 @@ class QueryService {
         }
         if (where.condition === Enums_1.ConditionTypes.LIKE ||
             where.condition === Enums_1.ConditionTypes["NOT LIKE"]) {
+            const queryColumn = where.model.columns.find((column) => column.name === where.field);
+            if (queryColumn &&
+                !constants_1.STRING_COLUMN_TYPES.includes(queryColumn.data_type.toLowerCase())) {
+                throw new ApiError_1.default(`Query field need to be string. Unacceptable query field: ${where.field}`);
+            }
             where.value = where.value.replace(/\*/g, "%");
         }
         // This means that the condition is related with another table

package/build/src/Services/SchemaValidatorService.d.ts

@@ -10,6 +10,7 @@ declare class SchemaValidatorService {
     private getQueryLimitColumns;
     private getQueryLimitKeyByFilter;
     private getModelFillableColumns;
+    private getSearchColumns;
     private getModelFormValidationColumns;
     private getModelHiddenColumns;
     private getTimestampsColumns;

package/build/src/Services/SchemaValidatorService.js

@@ -73,6 +73,9 @@ class SchemaValidatorService {
                 ...(config.PATCH || []),
             ];
         };
+        this.getSearchColumns = (model) => {
+            return model.instance.search || [];
+        };
         this.getModelFormValidationColumns = (model) => {
             const validations = model.instance.validations;
             if (!validations) {
@@ -122,6 +125,7 @@ class SchemaValidatorService {
             this.version.modelList.get().forEach((model) => {
                 this.checkModelReservedKeywordsOrFail(model);
                 this.checkModelColumnsOrFail(model, this.getModelFillableColumns(model));
+                this.checkModelColumnsOrFail(model, this.getSearchColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelFormValidationColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelHiddenColumns(model));
                 this.checkModelColumnsOrFail(model, this.getTimestampsColumns(model));

package/build/src/Services/URLService.d.ts

@@ -1,19 +1,10 @@
-import { HandlerFunction, MiddlewareFunction, StepTypes } from "../Types";
-import { IPhaseDefinition, IRouteData } from "../Interfaces";
+import { HandlerFunction, AxeFunction, GeneralFunction } from "../Types";
+import { IPhaseDefinition, IRouteData, IURLPair, IRouteParentPair } from "../Interfaces";
 import AxeRequest from "./AxeRequest";
-interface Pair {
-    method: string;
-    pattern: string;
-    data: IRouteData;
-    phases: IPhaseDefinition[];
-    hasTransaction: boolean;
-    params?: any;
-    customHandler?: HandlerFunction;
-}
 declare class URLService {
     private static urls;
-    static add(method: string, pattern: string, data: IRouteData, middlewares: StepTypes[]): Promise<void>;
-    static addHandler(method: string, pattern: string, customHandler: HandlerFunction, middlewares: (MiddlewareFunction | HandlerFunction)[]): Promise<void>;
+    static add(method: string, pattern: string, data: IRouteData, middlewares: AxeFunction[], parentPairs: IRouteParentPair[]): Promise<void>;
+    static addHandler(method: string, pattern: string, customHandler: HandlerFunction, middlewares: GeneralFunction[]): Promise<void>;
     static match(request: AxeRequest): {
         params: any;
         method: string;
@@ -21,9 +12,10 @@ declare class URLService {
         data: IRouteData;
         phases: IPhaseDefinition[];
         hasTransaction: boolean;
+        parentPairs: IRouteParentPair[];
         customHandler?: HandlerFunction | undefined;
     } | undefined;
-    static getAllURLs(): Pair[];
+    static getAllURLs(): IURLPair[];
     private static getDefaultPhases;
 }
 export default URLService;

package/build/src/Services/URLService.js

@@ -36,7 +36,7 @@ const check = (url, pattern) => {
     return null; // URL does not match the pattern
 };
 class URLService {
-    static add(method, pattern, data, middlewares) {
+    static add(method, pattern, data, middlewares, parentPairs) {
         return __awaiter(this, void 0, void 0, function* () {
             const phases = this.getDefaultPhases(middlewares);
             if (data.handlerType && data.model) {
@@ -62,6 +62,7 @@ class URLService {
                 data,
                 phases,
                 hasTransaction,
+                parentPairs,
             });
         });
     }
@@ -72,15 +73,15 @@ class URLService {
                 return {
                     isAsync: false,
                     name: `middleware:test`,
-                    callback: (pack) => __awaiter(this, void 0, void 0, function* () {
+                    callback: (context) => __awaiter(this, void 0, void 0, function* () {
                         if ((0, ConverterService_1.isMiddlewareFunction)(middleware)) {
                             // It should be wrapped
-                            const caller = (0, util_1.promisify)((pack, next) => middleware(pack.req.original, pack.res.original, next));
-                            yield caller(pack);
+                            const caller = (0, util_1.promisify)((context, next) => middleware(context.req.original, context.res.original, next));
+                            yield caller(context);
                         }
                         else {
                             // We call it directly.
-                            yield middleware(pack.req, pack.res);
+                            yield middleware(context.req, context.res);
                         }
                     }),
                 };
@@ -89,8 +90,8 @@ class URLService {
             phases.push({
                 isAsync: false,
                 name: "customHandler",
-                callback: (pack) => __awaiter(this, void 0, void 0, function* () {
-                    customHandler(pack.req, pack.res);
+                callback: (context) => __awaiter(this, void 0, void 0, function* () {
+                    customHandler(context.req, context.res);
                 }),
             });
             this.urls.push({
@@ -106,6 +107,7 @@ class URLService {
                     parentModel: null,
                     relation: null,
                 },
+                parentPairs: [],
             });
         });
     }
@@ -125,7 +127,7 @@ class URLService {
         return this.urls;
     }
     static getDefaultPhases(middlewares) {
-        // We should convert to all StepTypes functions to PhaseFunctions
+        // We should convert to all AxeFunction functions to PhaseFunctions
         const callbacks = middlewares.map(ConverterService_1.toPhaseFunction);
         const phases = [
             // Internal middlewares

package/build/src/Steps/Event.d.ts

@@ -0,0 +1,11 @@
+import { HookFunctionTypes } from "src/Enums";
+import { IModelService, IStepDefinition } from "src/Interfaces";
+import { PhaseFunction } from "src/Types";
+declare class Event implements IStepDefinition {
+    private hookFunctionType;
+    constructor(hookFunctionType: HookFunctionTypes);
+    get(model: IModelService): PhaseFunction;
+    get name(): string;
+    isAsync(): boolean;
+}
+export default Event;

package/build/src/Steps/Event.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Event {
+    constructor(hookFunctionType) {
+        this.hookFunctionType = hookFunctionType;
+    }
+    get(model) {
+        return model.events[this.hookFunctionType];
+    }
+    get name() {
+        return `event:${this.hookFunctionType}`;
+    }
+    isAsync() {
+        return false;
+    }
+}
+exports.default = Event;

package/build/src/Steps/Hook.d.ts

@@ -0,0 +1,11 @@
+import { HookFunctionTypes } from "src/Enums";
+import { IModelService, IStepDefinition } from "src/Interfaces";
+import { PhaseFunction } from "src/Types";
+declare class Hook implements IStepDefinition {
+    private hookFunctionType;
+    constructor(hookFunctionType: HookFunctionTypes);
+    get(model: IModelService): PhaseFunction;
+    get name(): string;
+    isAsync(): boolean;
+}
+export default Hook;

package/build/src/Steps/Hook.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Hook {
+    constructor(hookFunctionType) {
+        this.hookFunctionType = hookFunctionType;
+    }
+    get(model) {
+        return model.hooks[this.hookFunctionType];
+    }
+    get name() {
+        return `hook:${this.hookFunctionType}`;
+    }
+    isAsync() {
+        return true;
+    }
+}
+exports.default = Hook;

package/build/src/Steps/Phase.d.ts

@@ -0,0 +1,11 @@
+import { IStepDefinition } from "src/Interfaces";
+import { PhaseFunction } from "src/Types";
+declare class Phase implements IStepDefinition {
+    private callback;
+    private phaseName;
+    constructor(name: string, callback: PhaseFunction);
+    get(): PhaseFunction;
+    get name(): string;
+    isAsync(): boolean;
+}
+export default Phase;

package/build/src/Steps/Phase.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Phase {
+    constructor(name, callback) {
+        this.phaseName = name;
+        this.callback = callback;
+    }
+    get() {
+        return this.callback;
+    }
+    get name() {
+        return this.phaseName;
+    }
+    isAsync() {
+        return true;
+    }
+}
+exports.default = Phase;

package/build/src/Types.d.ts

@@ -1,20 +1,22 @@
 /// <reference types="node" />
 /// <reference types="express" />
 import { IncomingMessage, ServerResponse } from "http";
-import { IHandlerBaseMiddleware, IRequestPack } from "./Interfaces";
+import { IHandlerBaseMiddleware, IContext } from "./Interfaces";
 import AxeRequest from "./Services/AxeRequest";
 import AxeResponse from "./Services/AxeResponse";
 import { HookFunctionTypes } from "./Enums";
+import { Knex } from "knex";
+import { SchemaInspector } from "knex-schema-inspector/lib/types/schema-inspector";
 export type ModelValidation = Record<string, string>;
-export type FieldList = string[];
+export type ModelHooks = Record<HookFunctionTypes, PhaseFunction>;
+export type ModelMiddleware = Array<AxeFunction | IHandlerBaseMiddleware>;
+export type AdaptorType = "redis" | "memory";
 export type DefaultResponse = Promise<void> | void | undefined;
-export type AdaptorTypes = "redis" | "memory";
+export type NextFunction = (error?: any) => void;
+export type SchemaInspectorFuction = (database: Knex) => SchemaInspector;
+export type SerializationFunction = (item: any, request: AxeRequest) => any;
 export type MiddlewareFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => DefaultResponse;
 export type HandlerFunction = (request: AxeRequest, response: AxeResponse) => DefaultResponse;
-export type PhaseFunction = (pack: IRequestPack) => DefaultResponse;
-export type SerializationFunction = (item: any, request: AxeRequest) => any;
-export type HookFunctions = Record<HookFunctionTypes, PhaseFunction>;
-export type NextFunction = (error: any) => void;
-export type DynamicFunctionType = (MiddlewareFunction | HandlerFunction)[];
-export type StepTypes = MiddlewareFunction | HandlerFunction | PhaseFunction;
-export type ModelMiddlewareDefinition = Array<StepTypes | IHandlerBaseMiddleware>;
+export type PhaseFunction = (context: IContext) => DefaultResponse;
+export type GeneralFunction = MiddlewareFunction | HandlerFunction;
+export type AxeFunction = GeneralFunction | PhaseFunction;

package/build/src/constants.d.ts

@@ -1,6 +1,5 @@
 import { ConditionTypes, HandlerTypes, HttpMethods, QueryFeature, Relationships } from "./Enums";
-import { IModelService, IVersionConfig } from "./Interfaces";
-import { PhaseFunction } from "./Types";
+import { AxeConfig, AxeVersionConfig, ICacheConfiguration, IStepDefinition } from "./Interfaces";
 export declare const RESERVED_KEYWORDS: string[];
 export declare const DEFAULT_HANDLERS: HandlerTypes[];
 export declare const DEFAULT_METHODS_OF_MODELS: string[];
@@ -8,6 +7,7 @@ export declare const API_ROUTE_TEMPLATES: {
     store: (prefix: string, parentUrl: string, resource: string) => string;
     paginate: (prefix: string, parentUrl: string, resource: string) => string;
     all: (prefix: string, parentUrl: string, resource: string) => string;
+    search: (prefix: string, parentUrl: string, resource: string) => string;
     show: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
     update: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
     patch: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
@@ -16,12 +16,11 @@ export declare const API_ROUTE_TEMPLATES: {
 };
 export declare const ConditionQueryFeatureMap: Record<ConditionTypes, QueryFeature>;
 export declare const RelationQueryFeatureMap: Record<Relationships, QueryFeature>;
-export declare const DEFAULT_VERSION_CONFIG: IVersionConfig;
 export declare const NUMERIC_PRIMARY_KEY_TYPES: string[];
+export declare const STRING_COLUMN_TYPES: string[];
 export declare const HANDLER_METHOD_MAP: Record<HandlerTypes, HttpMethods>;
-export interface ICycleDefinition {
-    name: string;
-    get(model: IModelService): PhaseFunction;
-    isAsync(): boolean;
-}
-export declare const HANDLER_CYLES: Record<HandlerTypes, ICycleDefinition[]>;
+export declare const HANDLER_CYLES: Record<HandlerTypes, IStepDefinition[]>;
+export declare const DEFAULT_CACHE_CONFIGURATION: ICacheConfiguration;
+export declare const DEFAULT_APP_CONFIG: AxeConfig;
+export declare const DEFAULT_VERSION_CONFIG: AxeVersionConfig;
+export declare const ALL_HANDLERS: HandlerTypes[];