declare enum ColumnType {
    Time = "time",
    Number = "number",
    String = "string",
    Boolean = "boolean"
}
export declare enum MemberType {
    Measure = "measure",
    Dimension = "dimension",
    None = "none"
}
export type Dimension = {
    name: string;
    types: any[];
    title: string;
    isPrimaryKey?: boolean;
    type?: any;
};
export type TableName = string | [string, string];
export type JoinRelationship = 'hasOne' | 'hasMany' | 'belongsTo';
export type CubeDescriptorMember = {
    name: string;
    title: string;
    memberType: MemberType;
    type?: string;
    types: string[];
    isId?: boolean;
    included?: boolean;
    isPrimaryKey?: boolean;
};
export type Join = {
    thisTableColumn: string;
    thisTableColumnIncludedAsDimension?: boolean;
    tableName: TableName;
    cubeToJoin: string;
    columnToJoin: string;
    columnToJoinIncludedAsDimension?: boolean;
    relationship: JoinRelationship;
};
export type CubeDescriptor = {
    cube: string;
    tableName: TableName;
    table: string;
    schema: string;
    members: CubeDescriptorMember[];
    joins: Join[];
};
export type TableSchema = {
    cube: string;
    tableName: TableName;
    schema: any;
    table: any;
    measures: any[];
    dimensions: Dimension[];
    drillMembers?: Dimension[];
    joins: Join[];
};
type ForeignKey = {
    target_table: string;
    target_column: string;
};
type ColumnData = {
    name: string;
    type: string;
    attributes: string[];
    foreign_keys?: ForeignKey[];
};
export type DatabaseSchema = Record<string, {
    [key: string]: ColumnData[];
}>;
type ScaffoldingSchemaOptions = {
    includeNonDictionaryMeasures?: boolean;
    snakeCase?: boolean;
};
export declare class ScaffoldingSchema {
    private readonly dbSchema;
    private readonly options;
    private tableNamesToTables;
    constructor(dbSchema: DatabaseSchema, options?: ScaffoldingSchemaOptions);
    resolveTableName(tableName: TableName): TableName;
    cubeDescriptors(tableNames: TableName[]): CubeDescriptor[];
    generateForTables(tableNames: TableName[]): TableSchema[];
    protected prepareTableNamesToTables(tableNames: TableName[]): void;
    resolveTableDefinition(tableName: TableName): ColumnData[];
    protected tableSchema(tableName: TableName, includeJoins: boolean): TableSchema;
    protected parseTableName(tableName: TableName): [string, string];
    protected dimensions(tableDefinition: ColumnData[]): Dimension[];
    protected numberMeasures(tableDefinition: ColumnData[]): {
        included?: boolean | undefined;
        name: string;
        types: string[];
        title: string;
    }[];
    protected fromMeasureDictionary(column: any): boolean;
    protected dimensionColumns(tableDefinition: ColumnData[]): Array<ColumnData & {
        columnType?: string;
    }>;
    private fixCase;
    protected joins(tableName: TableName, tableDefinition: ColumnData[]): Join[];
    protected timeColumnIndex(column: any): number;
    protected columnType(column: any): ColumnType;
}
export {};
//# sourceMappingURL=ScaffoldingSchema.d.ts.map