import { CommonQueryParamsDto, CommonQueryParamsSingleDto, ORDER_DIRECTION, PermittedQueryParams } from '..';
import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
/**
 * Remove duplicates from array of objects { key, value }
 * @param array
 * @returns
 */
export declare function removeDuplicates(array: {
    key: string;
    value: string;
}[]): {
    key: string;
    value: string;
}[];
/**
 * Turns a comma seperated string into an array; defaults to empty array
 * @param input
 * @returns
 */
export declare function arrayFromCommaSeperatedString(input: string): string[];
/**
 * Turns a comma and tilde seperated string into an array of objects
 * @param input
 * @param type
 * @returns
 */
export declare function arrayFromCommaAndTildeSeperatedString(input: string, type?: 'filters' | 'sorting' | 'timestamps' | 'dtstart'): QueryParamsFilter[];
export declare function arrayFromCommaAndTildeSeperatedStringWithForwardSlashes(input: any): QueryParamsFilter[];
export declare class DefaultQueryParamsDto {
    limit: number;
    groups: any[];
    relations: any[];
    fields: string[];
    skipResults: number;
    filters: QueryParamsFilterValidated[];
    filtersLike: QueryParamsFilterValidated[];
    filtersList: QueryParamsFilterValidated[];
    exclude: QueryParamsFilterValidated[];
    excludeLike: QueryParamsFilterValidated[];
    orderByUpdatedAt: ORDER_DIRECTION;
    validationErrors: any[];
    timestamps: any[];
    dtstart: any[];
    sorting: QueryParamsBase[];
    constructor(overwrite?: DefaultQueryParamsInterface);
}
export interface DefaultQueryParamsInterface {
    relations?: any[];
    fields?: any[];
    filters?: any[];
    filtersLike?: any[];
    filtersList?: any[];
    exclude?: any[];
    excludeLike?: any[];
    groups?: any[];
    limit?: number;
    skipResults?: number;
    orderByUpdatedAt?: ORDER_DIRECTION;
    timestamps?: any[];
    dtstart?: any[];
    sorting?: any[];
}
export declare class DefaultRequestParamsDto {
    relations?: any[];
    constructor();
}
export interface QueryParamsBase {
    key: string;
    value: any;
}
export interface QueryParamsFilter extends QueryParamsBase {
    key: string;
    value: any;
    operator: string;
}
export interface QueryParamsFilterValidated extends QueryParamsFilter {
    transform?: string;
}
export declare enum QUERY_PARAMS_ORIGIN {
    CONTROLLER = "controller",
    SERVICE = "service"
}
/**
 * REWORK
 * QUERY
 *
 * WIP
 * WIP
 * WIP
 */
/**
 * WIP
 */
export declare class QueryParams {
    entityColumns: ColumnMetadata[];
    entityRelationColumns: RelationMetadata[];
    /** Legacy defaults */
    permitted: PermittedQueryParams;
    constructor(entityColumns: any, entityRelationColumns: any, permitted: PermittedQueryParams);
    private assembly;
    /** Extract controller input */
    fromController(controllerInput: CommonQueryParamsDto): {
        serviceParams: DefaultQueryParamsDto;
        errors: any[];
    };
    /** Extract service input */
    fromService(serviceInput: DefaultQueryParamsInterface): {
        serviceParams: DefaultQueryParamsDto;
        errors: any[];
    };
    fromDefault(): {
        errors: any;
        serviceParams: DefaultQueryParamsDto;
    };
    /**
     * Shortcut to request either
     * - type: controller
     * - type: service
     *
     * @param input
     * @param type: 'controller' or 'service'
     */
    get(input: DefaultQueryParamsDto | CommonQueryParamsDto | CommonQueryParamsSingleDto, type: QUERY_PARAMS_ORIGIN): {
        errors: any;
        serviceParams: DefaultQueryParamsDto;
    };
}
/**
 * Ensure that the array of relations is valid and contains no duplicates
 * @param relations
 * @param validRelations
 * @returns
 */
export declare function validateRelationsParams(relations: string[], validRelations: RelationMetadata[]): {
    relations: any[];
    errors: any[];
};