import { scalar } from "./base.scalar";
import { entity } from "./base.entity";
import { ruleEntity } from "./ruleEntity";
import { equalityGroupEnum } from "./equalityGroupEnum";
import { equalityEnum } from "./equalityEnum";
import { pair } from "./base.pair";
import { sourceSecurityEnum } from "./sourceSecurityEnum";
import { dateRangeEnum } from "./dateRangeEnum";
import { columnSecurityEnum } from "./columnSecurityEnum";
import { i18nComponent } from "./i18nComponent";
import { reportFieldUsageEnum } from "./reportFieldUsageEnum";
import { reportFieldOptionEnum } from "./reportFieldOptionEnum";
import { primitiveTypeEnum } from "./primitiveTypeEnum";
export declare namespace reportSourceEntity {
    type Id = scalar.Uuid;
    interface Doc extends entity.Doc<Id> {
        name?: scalar.Title;
        _name?: scalar.Alpha;
        code?: scalar.Alpha;
        description?: scalar.Description;
        activated?: scalar.Boolean;
        schema?: ruleEntity.Id;
        table?: TableInfo;
        joins?: Array<JoinItem>;
        columns?: Array<ColumnItem>;
        security?: Array<SecurityItem>;
        defaultDate?: DefaultDate;
        defaultOrder?: DefaultOrder;
        _columnMap: Record<scalar.Alpha, ColumnIndex>;
        _securityMap: Record<scalar.Alpha, scalar.Integer>;
        _joinMap: Record<scalar.Alpha, scalar.Integer>;
    }
    interface Filter extends entity.Filter {
        activated?: scalar.Boolean;
    }
    interface Service extends entity.Service<Id, Doc, Pair, Filter> {
    }
    type Table = entity.Wrapper<Id, Doc>;
    interface Pair extends pair.Core<Id> {
    }
    type IdOrPair = Id | Pair;
    interface View extends entity.View<Id> {
        name?: scalar.Title;
        code?: scalar.Alpha;
        description?: scalar.Description;
        schema?: ruleEntity.View;
        table?: TableInfo;
        joins?: Array<JoinItem>;
        columns?: Array<ColumnItem>;
        source?: Backward;
    }
    interface ColumnPair {
        folder?: scalar.Folder;
        service?: scalar.Alpha;
    }
    interface ColumnItem {
        name: scalar.Alpha;
        in?: scalar.Alpha;
        cast?: scalar.Alpha;
        equationGroups?: Array<equalityGroupEnum.Id>;
        defEquation?: equalityEnum.Id;
        expression?: scalar.Title;
        expressionFilter?: scalar.Title;
        expressionNested?: scalar.Title;
        service?: scalar.Alpha;
        visible?: Array<columnSecurityEnum.Id>;
        title?: i18nComponent.StringPlain;
        nameTitle?: i18nComponent.StringPlain;
        format?: scalar.Title;
        opt?: Array<reportFieldOptionEnum.Id>;
        usages?: Record<string, reportFieldUsageEnum.Id>;
    }
    interface SecurityItem {
        mode: columnSecurityEnum.Id;
        column: scalar.Alpha;
        context: scalar.Alpha;
        behaves: sourceSecurityEnum.Id;
    }
    interface TableInfo {
        alias: scalar.Alpha;
        target: scalar.Alpha;
        schema: scalar.Alpha;
    }
    interface Backward {
        metrics?: Array<BackwardItem>;
        dimensions?: Array<BackwardItem>;
    }
    interface BackwardItem {
        name?: scalar.Alpha;
    }
    interface JoinCondition {
        left: scalar.Alpha;
        right: scalar.Alpha;
        op: scalar.Title;
    }
    interface JoinItem extends TableInfo {
        conditions: Array<JoinCondition>;
    }
    interface ColumnIndex {
        index: scalar.Integer;
        usage: reportFieldUsageEnum.Id;
    }
    interface FindColumn extends ColumnIndex {
        item: ColumnItem;
    }
    interface FindJoin {
        index?: scalar.Integer;
        item?: JoinItem;
    }
    interface FindSecurity {
        index?: scalar.Integer;
        item?: SecurityItem;
    }
    interface DefaultDate {
        range?: dateRangeEnum.Id;
        datetime?: scalar.Alpha;
        date?: scalar.Alpha;
        time?: scalar.Alpha;
    }
    interface DefaultOrder {
        name?: string;
        desc?: boolean;
    }
    interface Option {
        joinIndex?: number;
        conditionIndex?: number;
        columnIndex?: number;
        securityIndex?: number;
        defaultCast?: primitiveTypeEnum.Id;
        defaultEquation?: equalityEnum.Id;
    }
}