take 2

frontend/src/metabase-query/lib/MetricsAndSegements.js

+class Metric {
+    displayName: string;
+    description: string;
+    // etc
+
+    // a way to start a query from a metric -- returns a Question
+    startQuery(){}
+}
+
+class Segment {
+    displayName: string;
+    description: string;
+    // etc
+	
+	// a way to start a query from a segment -- returns a Question
+    startQuery(){}
+}
\ No newline at end of file

frontend/src/metabase-query/lib/metadata.js

+// This is meant to be the primary way people interact with databases/tables/etc
+
+class Database {
+    newQuery(): Query {}
+    newNativeQuery(): NativeQuery {}
+
+    // how does this sound for any collection?
+    // return list of schema or tables?
+    list(){}
+    // or
+    getSchema(){}
+    getTables(){}
+
+}
+
+class Schema {
+	// Does it make sense to *always* structure the frontend's copy of the database's tables to have a schema?
+	// if a database doesn't have namespaces it's just referred to as "public"
+	list(){}
+    // or
+    getTables(){}
+}
+
+class Table {
+    newQuery(): Query {}
+ 	
+ 	// Do we actually need this?
+    newNativeQuery(): NativeQuery {}
+
+    list(){}
+    // or
+    getFields(){}
+
+}
+
+class Field {
+	getColumnDrills(){}
+}
\ No newline at end of file

frontend/src/metabase-query/lib/query.js

+// This is meant to be an encapsulation layer around MBQL query dictionaries
+// This can be fairly complicated internally, but the consumer of this api
+// shouldn't know anything about our metadata formats
+
+
+class Query {
+    constructor(metadata: Metadata, datasetQuery: DatasetQuery) {}
+
+    setDatabase(database: Database) {}
+    setTable(table: Table) {}
+
+    aggregations(): Aggregation[] {}
+    aggregationOptions(): AggregationOption[] {}
+    canAddAggregation(): bool {}
+
+    breakouts(): Breakout[] {}
+    breakoutOptions(unused: boolean = false): BreakoutOption[] {}
+    canAddBreakout(): bool {}
+
+    filters(): Filter[] {}
+    filterOptions(): FilterOption[] {}
+    canAddFilter(): bool {}
+
+    sorts(): Sort[] {}
+    sortOptions(): SortOption[] {}
+    canAddSort(): bool {}
+
+    addLimit(int: limit){}
+
+    // SQL 
+    getSQL(){}
+    convertToSQL(){}
+
+
+    // top-level actions
+    actions(): Action[] {}
+    // drill-through etc actions
+    actionsForClick(clicked: ClickObject): Action[] {}
+
+
+    // Run stuff
+    run(someReduxAction){}
+
+}
+
+class QueryResult{
+
+}
+
+// AGGREGATIONS
+
+class Aggregation {
+    displayName: string;
+    icon: string;
+
+    remove() {}
+    options(): AggregationOption[] {}
+}
+
+class AggregationOption {
+    displayName: string;
+    icon: string;
+    section: string;
+    isSelected: ?boolean;
+
+    add() {}
+}
+
+// TODO: similar for breakout, etc
+
+// ACTIONS / DRILL THROUGHS
+
+class Action {
+    perform() {}
+}

frontend/src/metabase-query/lib/question.js

+// This is a wrapper around the idea of a Question/Card
+// The expectation is that in the near future this will be
+// extended to include multiple series and queries based on other queries
+
+
+class Question {
+
+    // a question has one or more queries
+    // it currently only has one
+    queries[] 
+    // helper method for single query centric cards
+    query(){return queries[0]} 
+
+
+    // multiple series can be pivoted
+    breakouts(): Breakout[] {}
+    breakoutOptions(unused: boolean = false): BreakoutOption[] {}
+    canAddBreakout(): bool {}
+    
+    // multiple series can be filtered by shared dimensions
+    filters(): Filter[] {}
+    filterOptions(): FilterOption[] {}
+    canAddFilter(): bool {}
+    
+    // multiple series 
+    // really only makes sense for metrics (for now)
+    addMetric(metric, dimensionMapping){
+        // a metric here is either a Metric or a custom metric aka a query
+    }
+    getMetrics(){
+        return queries
+    }
+    removeMetric(metricID){
+
+    }
+    remapMetricDimension(metricID, newDimensionMapping){
+
+    }
+
+
+    // top-level actions 
+    actions(): Action[] {
+        // if this is a single query question, the top level actions are
+        // the querys actions
+        if(queries.length==0){
+            return query.actions()
+        } else{
+            // do something smart
+        }
+    }
+    
+    // drill-through etc actions
+    actionsForClick(clicked: ClickObject): Action[] {}
+
+    // Information
+    getUrl(){}
+    getLinear(){}
+    getVersionHistory(){}
+    revertToVersion(versionIDofSomeKind){}
+    getDownloadURL(format){}
+    
+
+
+    // Crud helpers
+    save(updatingAction){}
+
+    // Sharing
+    enablePublicSharing(){}
+    disablePublicSharing(){}
+    getPublicUrl(){}
+    publishAsEmbeddable(){}
+
+    // Run stuff
+    run(someReduxAction){}
+
+    // Parameters
+    // Not the this does NOT include any field based filter clauses. 
+    getAvailableParameters()    
+    setParameter()
+
+    // Parameter maintance
+    createParameter(options)
+    deleteParameter(parameterID)
+}
+
+// Should this be a class method ?
+// This is intended to be used to load up a question from the rest API
+function getQuestion(questionID){
+    return Question(...)
+}
+
+
+class ResultDrill {
+    run(x,y){}
+}
+