import type * as ExcelJS from 'exceljs'; import type * as echarts from 'echarts'; import type cytoscape from 'cytoscape'; import type lunr from 'lunr'; import type hljs from 'highlight.js/lib/core'; declare class ZeroType {} type integer = number; type PrimitiveTypes = boolean|string|integer|number|Date|ZeroType; declare enum DatePart { year = 'year', month = 'month', day = 'day', dayofweek = 'dayofweek', dayofweekiso = 'dayofweekiso', dayofyear = 'dayoofyear', week = 'week', weekiso = 'weekiso', quarter = 'quarter', yearofweek = 'yearofweek', yearofweekiso = 'yearofweekiso' } declare enum TimePart { hour = 'hour', minute = 'minute', second = 'second', millisecond = 'millisecond', microsecond = 'microsecond', nanosecond = 'nanosecond', epoch_second = 'epoch_second', epoch_millisecond = 'epoch_millisecond', epoch_microsecond = 'epoch_microsecond', epoch_nanosecond = 'epoch_nanosecond', timezone_hour = 'timezone_hour', timezone_minute = 'timezone_minute' } declare class TimeInterval { readonly amount: number; readonly unit: DatePart | TimePart; } declare class TimeDuration extends TimeInterval { duration: number; // amount * unit (in milliseconds) } declare abstract class DataValueProvider { } declare class NamedDataValueProvider extends DataValueProvider { readonly aliasedName: string; readonly displayName: string; as(name: string): this; displayAs(name: string): this; groupedAs(group: string, memberName: string): this; orderBy(field: NameOrDataValueProvider): this; } declare class ConstDataValueProvider extends DataValueProvider { } declare class NameValue { name: string; value: T; } type LocalVariable = Calculation|AggregateDataField|CalculatedField; declare abstract class Calculation extends NamedDataValueProvider { memoize(memoize: boolean): this; local(...deps: LocalVariable[]): this; } declare class ScriptCalculation extends Calculation { readonly script: string; } type NameOrDataValueProvider = string | DataValueProvider; type NameOrNamedDataValueProvider = string | NamedDataValueProvider; type KeyRelation = NameOrNamedDataValueProvider | [NameOrNamedDataValueProvider,NameOrNamedDataValueProvider]; type JoinFields = KeyRelation[]; // BEGIN SQL clauses { type FilterOperandType = PrimitiveTypes | Array | DataValueProvider declare class DataFilter { } declare enum OrderDirection { ASC = 1, DESC = 2 } declare type OrderDirectionStrings = keyof typeof OrderDirection; declare enum NullsPosition { First = 1, Last = 2 } declare class OrderTerm { /** * @param vp field to sort on * @param dir asending or descending, *ASC * @param nulls first or last, *LAST */ constructor(vp: NameOrNamedDataValueProvider,dir?: OrderDirection,nulls?: NullsPosition); } type OrderTermType = NameOrNamedDataValueProvider | OrderTerm | [ name: NameOrNamedDataValueProvider, direction?: OrderDirection | OrderDirectionStrings, nulls?: NullsPosition | 'NULLS FIRST' | 'NULLS LAST' ]; /** * from | [to] | [from,to] */ type LimitType = number|[number]|[number,number] declare class PartitionTerm extends OrderTerm { } declare class BasePartitionTerm extends PartitionTerm { } declare class OrderBy { constructor(...terms: OrderTerm[]); } declare class PartitionBy { constructor(...terms: BasePartitionTerm[]); } type SimplePartitionTermType = NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[]; type PartitionTermType = SimplePartitionTermType|PartitionClause declare abstract class PartitionClause { } declare class Rollup extends PartitionClause { constructor(...terms: SimplePartitionTermType[]); } declare class DataHierarchy extends Rollup { as(alias: string): this; displayAs(name: string): this; } type HierarchyField = NamedDataValueProvider|DataHierarchy; type NameOrHierarchyField = string|HierarchyField; declare class Cube extends PartitionClause { constructor(...terms: SimplePartitionTermType[]); } declare class GroupingSets { constructor(...terms: PartitionTermType[]); } declare class GroupBy { } declare enum WindowPosition { UnboundedPreceding = -2, Preceding = -1, Current = 0, Following = 1, UnboundedFollowing = 2 } declare class AnalyticWindow { } // } END SQL clauses // BEGIN UI { declare class DOM { appendChild(v: unknown): this; render(container?: HTMLElement): HTMLElement; } declare type ResizeDir = 'b'|'h'|'v'|''; declare class Container extends DOM { resize(dir?: ResizeDir): this; // *b (both) } declare class HContainer extends Container { center(center?: boolean): this; // *true nowrap(nowrap?: boolean): this; // *true } declare class VContainer extends Container { } declare class Markup extends DOM { } type WidgetValueType = string|NameValue; type OptionType = WidgetValueType|OptionGroup; declare class OptionGroup { constructor(label: string, options: WidgetValueType[]); } declare class Configurable { value: T; readonly config: Record; } declare namespace reactive { type VariableMessage = { name: string, value?: unknown, oldValue?: unknown }; } declare namespace pubsub { class Message { payload: T } type Subscriber = (msg: Message) => void; } declare interface WidgetEventListener { (evt: Event,ctx: Record): void; } declare class Widget extends DOM { multiple(multiple: boolean): this; label(label: string): this; placeholder(placeholder: string): this; } declare class SmartSelect { placeholder: string; } declare class Widgets { // for setting and getting variables associated with this widgets instance readonly vars: Record; /** * Register a listener for any changes to the variables (via associated widget values) * @param f listener which is passed an object of all the variables * ``` * widgets.onchange(({country}) => { * fdf.where = eq('Country',country); * }) * ``` */ onchange(f: (ctx: Record,msg: pubsub.Message) => void): pubsub.Subscriber; removeSubscriber(f: pubsub.Subscriber): boolean; label(label: string): HTMLElement; string(variable: string,value?: string,minl?: number,maxl?: number,pattern?: string): Widget; textarea(variable: string,value?: string): Widget; hidden(variable: string,value?: string): Widget; password(variable: string,value?: string): Widget; checkbox(variable: string,value?: string,checked?: boolean): Widget; radio(variable: string,value?: string,checked?: boolean): Widget; radios(variable: string,options: string[]): Widget[]; select(variable: string,options: OptionType[],value?: string|string[],multiple?: boolean,optional?: boolean): Widget; smart(select: Widget): SmartSelect; file(variable: string,accept?: string): Widget; button(label: string,onclick: WidgetEventListener): Widget; email(variable: string,value?: string): Widget; tel(variable: string,value?: string): Widget; search(variable: string,value?: string): Widget; url(variable: string,value?: string): Widget; number(variable: string,value?: number,min?: number,max?: number,step?: number): Widget; slider(variable: string,value?: number,min?: number,max?: number,step?: number): Widget; /** * @param value , @param min , @param max should be of the form '20:20' or '20:20:20' */ time(variable: string,value?: string,min?: string,max?: string,step?: "any"|number): Widget; /** * @param value , @param min, @param max should be of the form 2020-12-25 */ date(variable: string,value?: string,min?: string,max?: string,step?: "any"|number): Widget; datetime(variable: string,value?: string,min?: string,max?: string,step?: "any"|number): Widget; month(variable: string,value?: string,min?: string,max?: string,step?: "any"|number): Widget; week(variable: string,value?: string,min?: string,max?: string,step?: "any"|number): Widget; color(variable: string,value?: string): Widget; nv(name: string,value: T): NameValue; /** horizontal container */ h(...components: unknown[]): HContainer; /** vertical container */ v(...components: unknown[]): VContainer; render(dom: DOM,container?: HTMLElement): HTMLElement; configurable(v: T,config: Record): Configurable; } // END UI } declare interface LOVValue { readonly value: unknown, readonly id?: unknown, readonly count?: unknown } declare class DataField extends NamedDataValueProvider { } declare class AggregateDataField extends DataField { } declare class CalculatedField extends DataField { readonly calculation: Calculation; } declare class FKField extends DataField { lookup(field: NameOrNamedDataValueProvider): this; } type Aggregates = AggregateDataField|CalculatedField|Calculation; declare class AnalyticDataField extends CalculatedField { // indicates whether analytic funtions should be computed within the Group By partitions // most of them are computed within the partitions by default with some exceptions (see docs) partitioned(partitioned: boolean): this; ignoreNulls(ignoreNulls: boolean): this; } declare class DataColumnField extends DataField { } declare class OpMatch extends DataFilter { against(query: string,options?: Record): OpMatch; } declare class DataRow { } declare class HierarchicalDataRow extends DataRow { readonly isRoot: boolean; readonly hasChildren: boolean; readonly isLeaf: boolean; readonly isBlank: boolean; // intermediate node with no associatd data row } declare class Where { static and(...terms: DataFilter[]): DataFilter; static or(...terms: DataFilter[]): DataFilter; static not(f: DataFilter): DataFilter; static isnull(field: NameOrNamedDataValueProvider): DataFilter; static notnull(field: NameOrNamedDataValueProvider): DataFilter; static isrollup(field: NameOrNamedDataValueProvider): DataFilter; static eq(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static feq(field: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider): DataFilter; static gt(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static gte(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static lt(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static lte(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static in(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static isin(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static contains(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static startsWith(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static endsWith(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static regexp(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static between(field: NameOrNamedDataValueProvider,low: FilterOperandType,hi: FilterOperandType): DataFilter; static noteq(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static notin(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static notbetween(field: NameOrNamedDataValueProvider,low: FilterOperandType,hi: FilterOperandType): DataFilter; static exists(join: JoinFrame,where: DataFilter): DataFilter; static notexists(join: JoinFrame,where: DataFilter): DataFilter; static subquery(field: NameOrNamedDataValueProvider,join: Join,where?: DataFilter): Calculation; static match(...fields: NameOrNamedDataValueProvider[]): OpMatch; static isbp(): DataFilter; static anynulls(...fields: NameOrNamedDataValueProvider[]): DataFilter; static nonulls(...fields: NameOrNamedDataValueProvider[]): DataFilter; static containsAll(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static containsAny(field: NameOrNamedDataValueProvider,vp: FilterOperandType): DataFilter; static toJSON(filter: DataFilter): Record; static fromJSON(json: Record): DataFilter; } declare class Agg { // Aggregate static agg(field: NameOrNamedDataValueProvider,...aggf: ((...args: unknown[]) => AggregateDataField)[]): AggregateDataField[]; static anyValue(field: NameOrNamedDataValueProvider): AggregateDataField; static count(field?: NameOrNamedDataValueProvider): AggregateDataField; static countd(field: NameOrNamedDataValueProvider): AggregateDataField; static countf(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static countl(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static sum(field: NameOrNamedDataValueProvider): AggregateDataField; static sumf(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static suml(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static prod(field: NameOrNamedDataValueProvider): AggregateDataField; static min(field: NameOrNamedDataValueProvider): AggregateDataField; static minf(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static minl(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static max(field: NameOrNamedDataValueProvider): AggregateDataField; static maxf(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static maxl(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static avg(field: NameOrNamedDataValueProvider): AggregateDataField; static avgf(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static avgl(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static wavg(field: NameOrNamedDataValueProvider,wfield: NameOrNamedDataValueProvider): AggregateDataField; static wmean(field: NameOrNamedDataValueProvider,wfield: NameOrNamedDataValueProvider): AggregateDataField; static mean(field: NameOrNamedDataValueProvider): AggregateDataField; static median(field: NameOrNamedDataValueProvider): AggregateDataField; static mode(field: NameOrNamedDataValueProvider): AggregateDataField; static percentile(field: NameOrNamedDataValueProvider,p: number): AggregateDataField; static percentileCont(p: number,oby: OrderBy): AggregateDataField; static percentileDisc(p: number,oby: OrderBy): AggregateDataField; static variance(field: NameOrNamedDataValueProvider): AggregateDataField; static var(field: NameOrNamedDataValueProvider): AggregateDataField; static varianceSample(field: NameOrNamedDataValueProvider): AggregateDataField; static varianceSamp(field: NameOrNamedDataValueProvider): AggregateDataField; static variancePopulation(field: NameOrNamedDataValueProvider): AggregateDataField; static variancePop(field: NameOrNamedDataValueProvider): AggregateDataField; static stddev(field: NameOrNamedDataValueProvider): AggregateDataField; static stddevSamp(field: NameOrNamedDataValueProvider): AggregateDataField; static stddevPop(field: NameOrNamedDataValueProvider): AggregateDataField; static rank(values: unknown|unknown[],oby: OrderBy): AggregateDataField; static denseRank(values: unknown|unknown[],oby: OrderBy): AggregateDataField; static cumeDist(values: unknown|unknown[],oby: OrderBy): AggregateDataField; static percentRank(values: unknown|unknown[],oby: OrderBy): AggregateDataField; static regr(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrCount(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrSlope(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrIntercept(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrR2(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrAvgx(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrAvgy(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrSxx(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrSyy(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static regrSxy(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider): AggregateDataField; static statsMode(field: NameOrNamedDataValueProvider): AggregateDataField; static collect(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static collectd(field: NameOrNamedDataValueProvider,oby: OrderBy): AggregateDataField; static listagg(field: NameOrNamedDataValueProvider,separator:string,oby: OrderBy): AggregateDataField; static listaggd(field: NameOrNamedDataValueProvider,separator:string,oby: OrderBy): AggregateDataField; // Multiarg Aggregate static covarPop(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider): AggregateDataField; static covarSamp(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider): AggregateDataField; static corr(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider): AggregateDataField; // Analytic // Ranking static ranko(pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static denseRanko(pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static rowNumber(pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static ntile(tiles: number,pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static cumeDisto(pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static percentRanko(pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static percentileConto(p: number,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static percentileDisco(p: number,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static ratioToReport(field: NameOrNamedDataValueProvider,pby?: PartitionBy): AnalyticDataField; /** @deprecated */ static percentToReport(field: NameOrNamedDataValueProvider,pby?: PartitionBy): AnalyticDataField; // Analytic Aggregate static counto(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static countdo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static countfo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static countlo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static sumo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static sumfo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static sumlo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static prodo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static mino(field: NameOrNamedDataValueProvider,pby: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static minfo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static minlo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static maxo(field: NameOrNamedDataValueProvider,pby: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static maxfo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static maxlo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?:PartitionBy): AnalyticDataField; static avgo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static avgfo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static avglo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static meano(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static wavgo(field: NameOrNamedDataValueProvider,wfield: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static wmeano(field: NameOrNamedDataValueProvider,wfield: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static mediano(field: NameOrNamedDataValueProvider,pby?: PartitionBy): AnalyticDataField; static varianceo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static varianceSampleo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static varianceSampo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static variancePopulationo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static variancePopo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static stddevo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static stddevSampo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static stddevPopo(field: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static covarPopo(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static covarSampo(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static corro(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static regro(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static regryo(field1: NameOrNamedDataValueProvider, field2: NameOrNamedDataValueProvider,pby?: PartitionBy,oby?: OrderBy,win?: AnalyticWindow): AnalyticDataField; static collecto(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static collectdo(field: NameOrNamedDataValueProvider,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static listaggo(field: NameOrNamedDataValueProvider,separator: string,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static listaggdo(field: NameOrNamedDataValueProvider,separator: string,oby: OrderBy,pby?: PartitionBy): AnalyticDataField; static firstValue(field: NameOrNamedDataValueProvider,pby: PartitionBy|null,oby: OrderBy,win?: AnalyticWindow): AnalyticDataField; static lastValue(field: NameOrNamedDataValueProvider,pby: PartitionBy|null,oby: OrderBy,win?: AnalyticWindow): AnalyticDataField; static nthValue(field: NameOrNamedDataValueProvider,n: number,first: boolean,pby: PartitionBy|null,oby: OrderBy,win?: AnalyticWindow): AnalyticDataField; static lag(field: NameOrNamedDataValueProvider,offset: number|NameOrNamedDataValueProvider,defaultValue: unknown,pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; static lead(field: NameOrNamedDataValueProvider,offset: number|NameOrNamedDataValueProvider,defaultValue: unknown,pby: PartitionBy|null,oby: OrderBy): AnalyticDataField; // calculated fields static groupingField(field: NameOrNamedDataValueProvider): DataField; static groupingIdField(...fields: NameOrNamedDataValueProvider[]): DataField; static groupIdField(): DataField; static rowsw(from?: number,to?: number): AnalyticWindow; static rangew(from?: number|TimeDuration, to?: number|TimeDuration): AnalyticWindow; static cwindow(): AnalyticWindow; } declare enum DatabaseType { SQLite3 = 'SQLite3', MySQL = 'MySQL', Oracle = 'Oracle', PostgreSQL = 'PostgreSQL', SQLServer = 'SQLServer', Snowflake = 'Snowflake', Default = 'default' } export declare class SQL { static readonly GroupingID: string; // partition identifier when using advanced group by static readonly RowSetID: string; // set identifier when using union/intersect/except static where: typeof Where; static agg: typeof Agg; static values(rows: Array>): DataFrame; static field(name: string): NamedDataValueProvider; static value(v: unknown): ConstDataValueProvider; /** * * @param expr - any value or a DataValueProvider * @param whenvalues - when is a value or a DataValueProvider and value can by any value or a DataValueProvider * same as `CASE expr WHEN a THEN v1 WHEN b THEN v2 ... ELSE c END` in SQL */ static casee(expr: DataValueProvider|unknown,...whenvalues: Array): Calculation; /** * * @param whenvalues - when is a DataFilter and value can by any value or value provider * same as `CASE WHEN cond1 THEN v1 WHEN cond2 v2 ... ELSE defaultvalue END` in SQL */ static case(...whenvalues: Array): Calculation; static coalesce(...values: Array): Calculation; static as(df: DataFrame,alias: string): AliasedDataFrame; static join(df: JoinFrame,alias?: string): Join; static with(name?: string,df?: DataFrame): With; static unionall(df: DataFrame,...dfs: DataFrame[]): UnionDataFrame; static union(df: DataFrame,...dfs: DataFrame[]): UnionDataFrame; static intersectall(df: DataFrame,...dfs: DataFrame[]): DataFrame; static intersect(df: DataFrame,...dfs: DataFrame[]): DataFrame; static exceptall(df: DataFrame,...dfs: DataFrame[]): DataFrame; static except(df: DataFrame,...dfs: DataFrame[]): DataFrame; static orderBy(...terms: OrderTermType[]): OrderBy; static partitionBy(...terms: SimplePartitionTermType[]): PartitionBy; static groupBy(...terms: PartitionTermType[]): GroupBy; static rollup(...terms: SimplePartitionTermType[]): Rollup; static cube(...terms: SimplePartitionTermType[]): Cube; static groupingSets(...terms: PartitionTermType[]): GroupingSets; static hierarchy(...terms: SimplePartitionTermType[]): DataHierarchy; static grouping(field: NameOrNamedDataValueProvider): Calculation; static groupingId(...fields: NameOrNamedDataValueProvider[]): Calculation; static groupId(): Calculation; // time interval static days(days: number): TimeDuration; static hours(hours: number): TimeDuration; static minutes(minutes: number): TimeDuration; static seconds(seconds: number): TimeDuration; // analytic window static rowsw(from?: number,to?: number): AnalyticWindow; static rangeW(from?: number|TimeDuration,to?: number|TimeDuration): AnalyticWindow; static cwindow(): AnalyticWindow; // json static json_object(...nvs: (string|DataValueProvider)[]): Calculation; static json_array(...vps: DataValueProvider[]): Calculation; // string functions static substring(vp: NameOrNamedDataValueProvider,start: number /* 1-indexed */,length?: number): Calculation; // numeric functions static abs(vp: NameOrNamedDataValueProvider): Calculation; static round(vp: NameOrDataValueProvider,decimals: integer): Calculation; static script(script: string): ScriptCalculation; static ShowSQL: boolean; static DatabaseType: typeof DatabaseType; static Databases: string[]; } // Begin Plugins { declare class DataFramePlugin { } declare type NumberOptions = { NaN: number // convert NaN to this value } declare class RecursiveData { } declare class DataWranglePlugin extends DataFramePlugin { get convert(): { tostring(field: NameOrNamedDataValueProvider): DataWranglePlugin; tofloat(field: NameOrNamedDataValueProvider,options?: NumberOptions): DataWranglePlugin; tointeger(field: NameOrNamedDataValueProvider,options?: NumberOptions): DataWranglePlugin; tobool(field: NameOrNamedDataValueProvider, ...truths: unknown[]): DataWranglePlugin; todate(field: NameOrNamedDataValueProvider, format: string): DataWranglePlugin; toyear(field: NameOrNamedDataValueProvider): DataWranglePlugin; tomonth(field: NameOrNamedDataValueProvider): DataWranglePlugin; toquarter(field: NameOrNamedDataValueProvider): DataWranglePlugin; tohtml(field: NameOrNamedDataValueProvider): DataWranglePlugin; tourl(field: NameOrNamedDataValueProvider): DataWranglePlugin; toarray(field: NameOrNamedDataValueProvider, separator?: string, elementConverter?: string): DataWranglePlugin; }; //Recursive Hierarchy flatten(name: string,idField: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[],parentField: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[],nameField?: NameOrNamedDataValueProvider): RecursiveData; } declare class SQLPlugin extends DataFramePlugin { } declare class TimePlugin extends DataFramePlugin { year(field: NameOrNamedDataValueProvider): DataField; quarter(field: NameOrNamedDataValueProvider): DataField; month(field: NameOrNamedDataValueProvider): DataField; date(field: NameOrNamedDataValueProvider): DataField; hour(field: NameOrNamedDataValueProvider): DataField; week(field: NameOrNamedDataValueProvider): DataField; quarterOfYear(field: NameOrNamedDataValueProvider): DataField; monthOfYear(field: NameOrNamedDataValueProvider): DataField; weekOfYear(field: NameOrNamedDataValueProvider): DataField; dayOfYear(field: NameOrNamedDataValueProvider): DataField; dayOfMonth(field: NameOrNamedDataValueProvider): DataField; dayOfWeek(field: NameOrNamedDataValueProvider): DataField; hourOfDay(field: NameOrNamedDataValueProvider): DataField; hierarchy(field: NameOrNamedDataValueProvider,...periods: ('y'|'q'|'m'|'w'|'d')[]): DataHierarchy; lastDay(field: NameOrNamedDataValueProvider,datePart?: string|DatePart): DataField; datediff(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider,datePart?: string|DatePart): DataField; datesub(field: NameOrDataValueProvider,interval: TimeInterval): DataField; } declare class DataStyler {} type Style = Record; declare class Template {} declare type SummaryDataField = AggregateDataField|AnalyticDataField|Calculation; declare interface DataFormatter { format(v: unknown): string; readonly reference?: unknown; // a reference value to use to format and decide default width readonly chars?: number; // to decide default width of these many characters } type FieldStyleType = { field: string, // name of the field that provides the value prop: string, // name of the css property the field value is mapped to } declare class DataFormattingPlugin extends DataFramePlugin { const(style: Style): DataStyler; stripe(...s: Record[]): DataStyler; bar(options?: Record): DataStyler; heatmap(options?: Record): DataStyler; cond(cond: DataFilter,ifStyler: Style,elseStyle?: Style): DataStyler; if(cond: DataStyler,thenStyler: Style,elseStyle?: Style): DataStyler; vmap(...fs: FieldStyleType[]): DataStyler; setFieldFormatter(fieldName: string,formatter: DataFormatter): this; addRowStyler(styler: DataStyler): this; addRowStylers(...stylers: DataStyler[]): this; addFieldStyler(fieldName: string,styler: DataStyler): this; addFieldStylers(fieldName: string,...stylers: DataStyler[]): this; addFieldHeaderStyler(fieldName: string,styler: DataStyler): this; addFieldHeaderStylers(fieldName: string,...stylers: DataStyler[]): this; addFieldHeaderContentStyler(fieldName: string,styler: DataStyler): this; addFieldHeaderContentStylers(fieldName: string,...styler: DataStyler[]): this; tt(strings: TemplateStringsArray,...args: string[]): Template; setFieldRenderer(fieldName: string,renderer: Template): this; setImageRenderer(fieldName: string): this; addSummaries(...fields: SummaryDataField[]): this; } type SliceInfo = NameOrNamedDataValueProvider | DataHierarchy; declare class DataFrameSlicers { sliceBy: SliceInfo[]; // list of slicers aggs: Aggregates[]; // aggregations used for building slicers showContent: boolean; // whether the sliced content (fdf) be shown or only the slicers content: unknown; // set up content based on the fdf and that will be rendered when showContent = true filteredCounts: boolean; // Whether to compute valid options and their counts dynamically based on other filters readonly fdf: FilteredDataFrame; } declare class DataFilterPlugin extends DataFramePlugin { slicers(...slicers: SliceInfo[]): DataFrameSlicers; } declare interface DataSet { readonly ds: DataFrame; member: NamedDataValueProvider[]; gmember?: NamedDataValueProvider[]; group?: NamedDataValueProvider[]; groupBy(...group: NameOrNamedDataValueProvider[]): this; } declare interface OrderedDataSet extends DataSet { measure: NamedDataValueProvider; ranker: AnalyticDataField; readonly df: DataFrame; /** @deprecated */ withOther(groupBy?: GroupBy,...aggs: Aggregates[]): OrderedDataSet; withOthers(groupBy?: GroupBy,...aggs: Aggregates[]): OrderedDataSet; } declare class DataSetsPlugin extends DataFramePlugin { topN(n: number,measure: NameOrNamedDataValueProvider,member?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[],within?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[]): OrderedDataSet; bottomN(n: number,measure: NameOrNamedDataValueProvider,member?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[],within?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[]): OrderedDataSet; extremeN(n: number,measure: NameOrNamedDataValueProvider,member?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[],within?: NameOrNamedDataValueProvider|NameOrNamedDataValueProvider[]): OrderedDataSet; setNother(ds: OrderedDataSet,groupBy?: GroupBy,...aggregates: Aggregates[]): OrderedDataSet; } declare class FilterBuilder { } declare class DataFrameExplorer { } type MenuItem = { id: string, name?: string, onclick?: (evt: Event) => void, content?: unknown, // render any content with it's own click handler hide?: boolean, disabled?: boolean, checked?: boolean, accept?: string, // for File input } | MenuSection; type MenuSection = { id?: string, name?: string, items: (MenuItem|MenuItem[])[], hide?: boolean, display?: 'inline'|'submenu', // *inline checked?: boolean, } type Menu = MenuSection; type Menubar = Menu[]; type FieldContextMenuData = { field: DataField, // column header fillColumn?: boolean, // indicates if this is a fill column created with fillWidth pivotColumn?: boolean, // indiciates if this is a pivot column pivotValues?: Map // pivot column values for pivot tables } type DataContextMenuData = { drow: DataRow, column?: DataColumnField, value?: unknown, dvalue?: unknown } declare type CalculatedFieldEditorOptions = { title?: string, onChange?: (field: CalculatedField) => void, picklist?: boolean, // *true, which allows switching between fields } declare type DownloadDialogOoptions = { } declare enum ViewType { Tabular = 't', Workspace = 'ws', } declare class DataFrameLayout { set viewAs(viewAs: ViewType|string); // *t , ws = Workspace get viewAs(); multiple: boolean; // show multiple records in Workspace view type } type FilterDisplayModeType = 'inline'|'dialog'; declare class UIPlugin extends DataFramePlugin { // these configurations can be specified globally using DataFrame.Config // Can be set to true/false or undefined. Global config is used when set to undefined. set showMenubarLeft(show: boolean); set showMenubarRight(show: boolean); set excelHeaders(headers: boolean); set fillWidth(fill: boolean); // *false set colorCoded(colorCoded: boolean); // *true readonly explorer: DataFrameExplorer; readonly menu: Menubar; set viewAs(viewAs: ViewType|string); // *t , ws = Workspace get viewAs(); filterDisplayMode: FilterDisplayModeType; getMenuItem(id: string): MenuItem; set fieldContextMenuProvider(provider: (data: FieldContextMenuData) => Menu|MenuItem[]); set dataContextMenuProvider(provider: (data: DataContextMenuData) => Menu|MenuItem[]); whereFb(): FilterBuilder; havingFb(): FilterBuilder; textsearch(keyword?: string): Widget; openCalculatedFieldDialog(field?: NameOrNamedDataValueProvider,options?: CalculatedFieldEditorOptions): void; openDownloadDialog(options?: DownloadDialogOoptions): void; renderFilter(container: HTMLElement): void; setFieldViews(field: string,views: NamedDataValueProvider[]): void; addLayout(name: string,template: Template|DataFrameLayout): DataFrameLayout; } type NamedMultiDataSeries = NameOrNamedDataValueProvider[]; type NamedSeriesTerm = NameOrNamedDataValueProvider|NamedMultiDataSeries; type NamedSeries = NameOrNamedDataValueProvider|NamedSeriesTerm[]; declare class DataSeries { name: string; // name of the series get valueBy(): NamedDataValueProvider; set valueBy(valueBy: NameOrNamedDataValueProvider); min: number|Date; // explicit min value for the axis max: number|Date; // explicit max value for the axis readonly fo: any; // fluent object (a proxy that makes getters/setters as fluent API) readonly of: this; // escape back from fluent object showAxis: boolean; showAxisLabel: boolean; showSeriesLabel: boolean; showSymbol: boolean; type?: string; // chart type height?: number; // explicit height for the subchart of this series width?: number; // explicit width for the subchart of this series // echart otpions smooth: boolean; // echarts smooth option for line charts lineType: string; // echarts lineStyle.type scale: string; // echarts axis type roseType: string; // echarts pie chart option innerRadius: string; // echarts pie chart option (percent as string) outerRadius: string; // echarts pie chart option (percent as string) shape: string; // echarts radar shape options: Record; // echarts series options that will be merged axisOptions: Record; // echarts axis options that will be merged xAxisIndex?: number; // 0 and 1 for dual axis yAxisIndex?: number; // 0 and 1 for dual axis zoom?: boolean; // *void 0 (automatic) showOutliers: boolean; // box plot option symbolBy: NameOrNamedDataValueProvider; // symbol shape is based on this field sizeBy: NameOrNamedDataValueProvider; // symbol sizes use values from this field colorBy: NameOrNamedDataValueProvider; // color is based on values in this field tooltipBy: NameOrNamedDataValueProvider[]; // additional tooltip fields splitBy(splitBy: NameOrNamedDataValueProvider[]): this; partitionBy(partitionBy: NameOrNamedDataValueProvider[]): this; } declare class MultiDataSeries extends DataSeries { get valuesBy(): NamedDataValueProvider[]; set valuesBy(valueBy: NameOrNamedDataValueProvider[]); } declare type ChartClickEventDetails = { chart: echarts.ECharts, params: Record, vp: any, // value provider. vp.xyz gives value of xyz field in the current row dvp: any // display value provider. dvp.xyz gives display value of xyz field in the current row } declare class DrillPath { orderBy(orderBy: OrderBy): this; start(): this; } declare class DataFrameChart { title: string; width: number; height: number; showLegend?: boolean; // true, false, *void 0 showSelector?: boolean; // true, false, *void 0 ssr: boolean; // true, *false readonly xseries: DataSeries[]; readonly yseries: DataSeries[]; readonly fo: any; // fluent object (a proxy that makes getters/setters as fluent API) readonly of: this; // escape back from fluent object readonly dpath?: DrillPath; legendOptions: Record; // echarts legend options that will be merged icustomize: (option: Record) => Record; onclick: (event: CustomEvent) => boolean|void; refresh(): void; // refresh the chart UI associated with this chart. resize(width: number,height: number): this; scsize(width: number,height: number): this; // subchart size for dynamic sized charts canvas(): this; // renderer is canvas svg(): this; // renderer is svg // explicitly control min/max values for the axis minx(minx: number|Date): this; maxx(maxx: number|Date): this; miny(miny: number|Date): this; maxy(maxy: number|Date): this; asRows(): this; // display y-series as separate rows yasRows(): this; // display y-series values as separate rows xasRows(): this; // display x-series values as separate rows asCols(): this; // display y-series as separate columns yasCols(): this; // display y-series as separate columns xasCols(): this; // display x-series as separate columns asGrid(): this; // display y-series as rows and x-series as columns colsBy(...colsBy: NameOrNamedDataValueProvider[]): this; // partition chart by col fields rowsBy(...rowsBy: NameOrNamedDataValueProvider[]): this; // partition chart by row fields symbolBy(symbolBy: NameOrNamedDataValueProvider): this; // symbol shape is based on this field sizeBy(sizeBy: NameOrNamedDataValueProvider): this; // symbol sizes use values from this field colorBy(colorBy: NameOrNamedDataValueProvider): this; // color is based on values in this field tooltipBy(...tooltipBy: NameOrNamedDataValueProvider[]): this; // additional tooltip fields limit(limit: number|[number,number?]): this; // limit the chart data to specified range drillpath(...fields: NameOrNamedDataValueProvider[]): this; } declare class ChartPlugin extends DataFramePlugin { bar(xf: NamedSeries,yf: NamedSeries): DataFrameChart; hbar(xf: NamedSeries,yf: NamedSeries): DataFrameChart; line(xf: NamedSeries,yf: NamedSeries): DataFrameChart; step(xf: NamedSeries,yf: NamedSeries): DataFrameChart; area(xf: NamedSeries,yf: NamedSeries): DataFrameChart; pie(xf: NamedSeries,yf: NamedSeries): DataFrameChart; donut(xf: NamedSeries,yf: NamedSeries): DataFrameChart; radar(xf: NamedSeries,yf: NamedSeries): DataFrameChart; scatter(xf: NamedSeries,yf: NamedSeries): DataFrameChart; candlestick(xf: NamedSeries,[open,close,high,low]: NameOrNamedDataValueProvider[]): DataFrameChart; boxplot(xf: NamedSeries,yf: NamedSeries): DataFrameChart; heatmap(xf: NamedSeries,yf: NamedSeries): DataFrameChart; themeRiver(date: NameOrNamedDataValueProvider,value: NameOrNamedDataValueProvider,name?: NameOrNamedDataValueProvider): DataFrameChart; parallel(xf: NamedSeries,yf: NamedMultiDataSeries): DataFrameChart; calendar(date: NamedSeries,value: NamedSeries): DataFrameChart; treemap(xf: NamedSeries,yf: NamedSeries): DataFrameChart; sunburst(xf: NamedSeries,yf: NamedSeries): DataFrameChart; map(xf: NamedSeries,yf: NamedSeries): DataFrameChart; band(xf: NamedSeries,[value,high,low]: NameOrNamedDataValueProvider[]): DataFrameChart; splom(...fields: NameOrNamedDataValueProvider[]): DataFrameChart; static setColorPalette(colors: string[]): void; static setMonoColorPalette(colors: string[]): void; static setMonoColor(color: string): void; static registerMap(name: string,url: string,areas: Record): void; } declare namespace DataFramePlugin { let Chart: typeof ChartPlugin; } declare class ExcelPlugin extends DataFramePlugin { pogt(field: NameOrNamedDataValueProvider): DataField; poprt(field: NameOrNamedDataValueProvider): DataField; popt(field: NameOrNamedDataValueProvider,...pfields: NameOrNamedDataValueProvider[]): DataField; pof(field: NameOrNamedDataValueProvider,fields: NameOrNamedDataValueProvider[],values: unknown[]): DataField port(field: NameOrNamedDataValueProvider): DataField; poct(field: NameOrNamedDataValueProvider): DataField; popct(field: NameOrNamedDataValueProvider): DataField; rti(field: NameOrNamedDataValueProvider,ofield: NameOrNamedDataValueProvider,order?:OrderDirection): DataField; porti(field: NameOrNamedDataValueProvider,ofield: NameOrNamedDataValueProvider,order?:OrderDirection): DataField; percentOfGrandTotal(field: NameOrNamedDataValueProvider): DataField; percentOfParentRowTotal(field: NameOrNamedDataValueProvider): DataField; percentOfParentTotal(field: NameOrNamedDataValueProvider,...pfields: NameOrNamedDataValueProvider[]): DataField; percentOf(field: NameOrNamedDataValueProvider,fields: NameOrNamedDataValueProvider[],values: unknown[]): DataField; percentOfRowTotal(field: NameOrNamedDataValueProvider): DataField; percentOfColTotal(field: NameOrNamedDataValueProvider): DataField; percentOfParentColTotal(field: NameOrNamedDataValueProvider): DataField; runningTotalIn(field: NameOrNamedDataValueProvider,ofield: NameOrNamedDataValueProvider,order?:OrderDirection): DataField; percentOfRunningTotalIn(field: NameOrNamedDataValueProvider,ofield: NameOrNamedDataValueProvider,order?:OrderDirection): DataField; index(field: NameOrNamedDataValueProvider): DataField; differenceFrom(field: NameOrNamedDataValueProvider,fields: NameOrNamedDataValueProvider[],values: unknown[]): DataField; percentDifferenceFrom(field: NameOrNamedDataValueProvider,fields: NameOrNamedDataValueProvider[],values: unknown[]): DataField; rank(field: NameOrNamedDataValueProvider,dir: OrderDirection.ASC): DataField; rankAsc(field: NameOrNamedDataValueProvider): DataField; rankDesc(field: NameOrNamedDataValueProvider): DataField; } // } END Plugins declare class DataSource { } declare class DataIndex { findByValue(value: unknown): unknown; } declare class DataFrameConfig { static MaxDecimals: number; static MenuItems: Record; static ShowMenubarLeft: boolean; static ShowMenubarRight: boolean; static ExcelHeaders: boolean; static SummaryName: string; // defaults to [All] } declare type JSONObject = Record; declare type DataFieldMetadataConfig = { name?: string, // specify to rename the input field to a different name displayName?: string, // the display name of the field datatype?: string, // *void 0 (automatic) separator?: string, // if separator is specified, this field is treated as a list deriveLOV?: boolean, //*void 0 (automatic) } declare type DataFrameOptions = { format?: 'csv'|'json', // input format if it can't be automatically derived init?: RequestInit, // the init object used with the fetch API // any input field data meeting this is converted to null. Useful to ignore incorrect data nulls?: string|RegExp, // convet response text (if it is not in json format, e.g., xml) to JSON parser?: (text: string) => JSONObject[], // convert the response JSON to an array of json objects toRows?: (json: JSONObject|JSONObject[]) => JSONObject[], // if header row is not the 1st row, specify the exact header row number (0-indexed). // Useful for spreadsheets where the header doesn't start from the first row headerRow?: number, sheetIndex?: number|number[], // Worksheet(s) index in Excel, defaults to the 1st one (0-indexed) header?: string[], // explicitly provide the data header if it is not present in the csv input trimData?: boolean, // whether input field data should be trimmed, cache?: boolean, // *void 0 (automatic), specifying false explicitly fetches the url fields?: Record, // config input fields explicitly namer?: (field: string) => string|{ name: string, alias: string, displayName: string }, compact?: boolean, // *true, a tradeoff flag that reduces memory at the expense of cpu rowid?: string|string[], // row identifier field, retain?: 'first'|'last'|'max' // when multiple rows with same rowid, which to use maxFields?: string|string[] // field that identifies the latest record /** @deprecated */ callback?: (response: Response) => void // deprecated, use onsuccess onsuccess?: (response?: Response) => void, // when data fetch request is successful onerror?: (ex: Error,response?:Response) => void, // when data fetch request is not successful } declare type DataFrameHeaderOptions = { formatted?: boolean, iso?: boolean, primitiveTypes?: boolean } declare type DataFrameDataOptions = { headers?: DataFrameHeaderOptions, columnar?: boolean, formatted?: boolean, iso?: boolean, primitiveTypes?: boolean, lowestLevel?: boolean } declare type DataFrameData = { headers?: unknown[][], data: unknown[][] } declare type BenchmarkOptions = { times: number, // times to execute the provided function (and compute if a df is returned) ignore?: number, // initial times to compute df but ignore, *0 title?: string, // title of the benchmark } declare class Benchmark { } type it = { vp: Record, dvp: Record }; declare class DataFrameIterator { forEach(f:(it:it, idx: number) => void): void; } export declare class DataFrame { schemaName: string; static fromURL(url: string|string[],options?: DataFrameOptions): DataSourceDataFrame; static fromFile(file: File,options?: DataFrameOptions): DataSourceDataFrame; static fromText(text: string,options?: DataFrameOptions): DataSourceDataFrame; static fromJSONArray(json: unknown[],options?: DataFrameOptions): DataSourceDataFrame; static fromDataSource(ds?: DataSource,options?: DataFrameOptions): DataSourceDataFrame; static fetch: typeof globalThis.fetch; // provide a custom fetch API to access remote data static cast(df: unknown): DataFrame; static mcast(...dfs: unknown[]): DataFrame[]; static benchmark(f: () => unknown,options?: BenchmarkOptions): Benchmark; static Plugin: typeof DataFramePlugin; addField(field: DataField|Calculation): this; addFields(...field: Array): this; dropField(field: NameOrNamedDataValueProvider): NamedDataValueProvider; /** * Create a script based calculation, any valid JavaScript with [xyz] to refer to a field called xyz * @param script - The code for the calculation * ``` * df.script('[xyz]*2').as('Twice XYZ'); * // a calulated field can refer to another calculated field * df.script('[Twice XYZ]*5).as('xyz 10 times'); * ``` */ script(script: string): Calculation; validateScript(script: string,compute?:boolean): Promise; addFK(fkField: FKField): this; createFK(...fks: KeyRelation[]): FKField; lookupField(fk: NameOrNamedDataValueProvider,lookupField: NameOrNamedDataValueProvider): DataField; // to also work with the fk id value after defining an FK with a lookup fkIdField(fk: NameOrNamedDataValueProvider): DataField; // creates and adds a canned search addSearch(title: string,where: DataFilter,orderBy?: OrderBy): this; regexp(field: NameOrNamedDataValueProvider,...regexp: RegExp[]): Calculation; // returns a subquery field subquery(field: NameOrNamedDataValueProvider,join: Join,where: DataFilter): DataField; // creates and adds the subquery field to the df subqueryField(field: NameOrNamedDataValueProvider,join: Join,where: DataFilter): DataField; readonly ctx: Record; readonly filter: DataFilterPlugin; readonly ui: UIPlugin; readonly sql: SQLPlugin; readonly time: TimePlugin; readonly sets: DataSetsPlugin; readonly chart: ChartPlugin; readonly fmt: DataFormattingPlugin; readonly excel: ExcelPlugin; readonly wrangle: DataWranglePlugin; /** * The fields that make the rows in the dataframe unique */ get idFields(): NamedDataValueProvider[]; set idFields(idFields: NameOrNamedDataValueProvider[]); /** * These fields serve as the fixed header columns of a row */ get headerFields(): NamedDataValueProvider[]; set headerFields(headerFields: NameOrNamedDataValueProvider[]); set propagateSelection(propagate: boolean); get propagateSelection(); /** * @param ...sorts(or orderBy), to specify the sort order * ``` * df.orderBy(['date','DESC'],'price'); * df.orderBy(SQL.orderBy(['date,'DESC'],'price')) * ``` */ orderBy(...sorts: OrderTermType[]): this; orderBy(orderBy: OrderBy): this; /** * The data is always sorted with the specified by orderBy Prefix * This is prepended to any orderBy clause or the end user sorting * * @param sorts -- see orderBy() */ orderByPrefix(...sorts: OrderTermType[]): this; /** * @param limit can be number, [number] or [number,number] * ``` * df.limit(10); // first 10 rows * df.limit([10]); // rows from 10 and above * df.limit([10,20]); // rows from 10 to 20 * ``` */ limit(limit: LimitType): this; // SQL operations /** * Projected DataFrame (SELECT clause) * @param fields list of fields to select */ pdf(...fields: NameOrNamedDataValueProvider[]): ProjectedDataFrame; /** * SELECT DISTINCT clause * @param fields list of fields to select */ dpdf(...fields: NameOrNamedDataValueProvider[]): DataFrame; /** * Filtered DataFrame (WHERE clause) * @param filter condition to filter the data */ fdf(filter?: DataFilter): FilteredDataFrame; /** * UNION ALL one or more DataFrames with the current DataFrame * @param dfs DataFrames to UNION ALL */ unionall(...dfs: DataFrame[]): UnionDataFrame; /** * UNION one or more DataFrame with the current DataFrame * @param dfs DataFrames to union */ union(...dfs: DataFrame[]): UnionDataFrame; /** * INTERSECT ALL one or more DataFrames with the current DataFrame * @param dfs DataFrames to INTERSECT ALL */ intersectall(...dfs: DataFrame[]): DataFrame; /** * INTERSECT one or more DataFrame with the current DataFrame * @param dfs DataFrames to INTERSECT */ intersect(...dfs: DataFrame[]): DataFrame; /** * EXCEPT ALL one or more DataFrames with the current DataFrame * @param dfs DataFrames to EXCEPT ALL */ exceptall(...dfs: DataFrame[]): DataFrame; /** * EXCEPT one or more DataFrame with the current DataFrame * @param dfs DataFrames to EXCEPT */ except(...dfs: DataFrame[]): DataFrame; /** * Group By DataFrame (GROUP BY clause) * @param groupBy spec for GROUP BY * @param fields a list of aggregations to compute for each grouping. These can be aggregate fields, * analytic fields or calculated fields. Calculated fields are based on the fields of * the resulting **Grouped DataFrame** and not the **DataFrame** being grouped. */ gdf(groupBy: GroupBy,...fields: Array): GroupedDataFrame; /** * Data Cube for slicing & dicing * @param groupBy spec for GROUP BY * @param fields a list of aggregations to compute for each grouping. These can be aggregate fields, * analytic fields or calculated fields. Calculated fields are based on the fields of * the resulting **Grouped DataFrame** and not the **DataFrame** being grouped. */ cdf(groupBy: GroupBy,...fields: Array): DataCube; /** * Pivot DataFrame (PIVOT clause) * @param rowFields fields along the rows * @param colFields fields along the columns * @param valFields fields in the cells, when omitted selects all available fields */ vdf(rowFields: NameOrHierarchyField[],colFields: NameOrHierarchyField[],valFields?: string[]): PivotedDataFrame; /** * UNPIVOT the DataFrame * @param fixedFields list of columns that are projected and not impacted by unpivoting * @param valField name assigned to the field resutling from the values being unpivoted * @param colField name assigned to the field resulting from the colun names being unpivoted * @param colVals optionally which columns should be unpivoted, otherwise all remaining columns are unpivoted */ uvdf(fixedFields: NameOrNamedDataValueProvider[],valField: NameOrNamedDataValueProvider,colField: NameOrNamedDataValueProvider,colVals?: string[]): DataFrame; /** * Hierarchical DataFrame * @param hierarchyFields fields to orgnaize data as a hierarchy */ hdf(...hierarchyFields: NameOrHierarchyField[]): HierarchicalDataFrame; /** * For compute the DataFrame */ compute(): Promise; /** * Computes the DataFrame if required and then returns the data * @param options - options to get the data from the DataFrame */ getData(options?: DataFrameDataOptions): Promise; /** * To iterate the dataframe rows and access values and display vaulues of fields */ newIterator(): DataFrameIterator; /** * * @param field - name of the field * @returns - list of unique values of the field in the dataframe */ getUniqueValues(field: string): Promise; // Drill down/up getDetails(): DataFrame; getDrillDowns(): DataFrame; getDrillUps(): DataFrame; /** * @param ...sorts(or orderBy), to specify the sort order * Similar to orderBy() but for details df of the aggregate df */ detailsOrderBy(...sorts: OrderTermType[]): this; detailsOrderBy(orderBy: OrderBy): this; // FK relations /** * * @param df : the related df that needs to be filtered based on the selected rows of the current df * @param relations : each relation is a single field that is same in both dfs or [current-df-field,related-df-field] pairs */ getRelated(df: DataFrame,...relations: KeyRelation[]): DataFrame; randomize(): Promise; // indexes createUniqueIndex(...fields: NameOrNamedDataValueProvider[]): Promise; createNonUniqueIndex(...fields: NameOrNamedDataValueProvider[]): Promise; createTextIndex(type?: string): DataIndex; static Config: typeof DataFrameConfig; static diff(df1: DataFrame,df2: DataFrame,...fields: JoinFields): DataFrame; } declare class SourceDataFrame extends DataFrame { } declare class DataSourceDataFrame extends SourceDataFrame { ds: DataSource; // merge data (same structure and format) into this ddataframe merge(ds: DataSource): Promise; // automatically add a time stamp field that tracks when a record is updated/inserted during merge trackMergedAt(): DataField; } declare abstract class DerivedDataFrame extends DataFrame { isStacked: boolean; isColumnGroupingsFirst: boolean; } declare abstract class ProjectedDataFrame extends DerivedDataFrame { /** * @param fields - blank list selects all fields */ set projectedFields(fields: NameOrNamedDataValueProvider[]); // reactive get projectedFields(): NamedDataValueProvider[]; } declare class FilteredDataFrame extends DerivedDataFrame { where: DataFilter; // reactive } declare abstract class AggregatedDataFrame extends DerivedDataFrame { } declare class GroupedDataFrame extends AggregatedDataFrame { having(havingClause: DataFilter): this; } declare class SetOpDataFrame extends SourceDataFrame { } declare class UnionDataFrame extends SetOpDataFrame { withRowSetId(): DataFrame; } declare class PivotedDataFrame extends AggregatedDataFrame { set pivotValueFields(fields: NameOrNamedDataValueProvider[]); rowTotalsFirst: boolean; // *true transposable: boolean; // *true expandColLevels: number; sortColumns(orderBy: OrderBy): Promise; /** * Hierarchical DataFrame * @param hierarchyFields fields to orgnaize data as a hierarchy */ hdf(...hierarchyFields: string[]): PivotedHierarchicalDataFrame; } declare class HierarchicalDataFrame extends DerivedDataFrame { /** * @param fields - hierarchy based on aggregate dataframes use GROUP BY fields to create the hierarchy */ set hierarchyFields(fields: NameOrHierarchyField[]); // reactive get hierarchyFields(): HierarchyField[]; hideRoot: boolean; // to hide displaying the root node expandLevels: number; // number of levels to expand by default singleHierarchyField: boolean; // indicates whether the hierarchy is displayed as a single (compact) field or separate fields asHierarchy(hdf: HierarchicalDataFrame): this; createCountField(name: string): DataField; } declare class PivotedHierarchicalDataFrame extends HierarchicalDataFrame { rowTotalsFirst: boolean; // *true } declare class JoinedDataFrame extends DataFrame { starFact?: DataFrame; // to trigger star join optimization } declare class AliasedDataFrame { df: DataFrame; alias: string; fdf(filter: DataFilter): FilteredDataFrame; pdf(...fields: NameOrNamedDataValueProvider[]): ProjectedDataFrame; } declare class DataCube extends DataFrame { dice(groupBy: GroupBy): DataFrame; } declare class Join { inner(df: JoinFrame,asias?: string): Join; leftouter(df: JoinFrame,alias?: string): Join; rightouter(df: JoinFrame,alias?: string): Join; fullouter(df: JoinFrame,alias?: string): Join; fdf(where?: DataFilter): JoinedDataFrame; using(...fields: JoinFields): Join; on(condition: DataFilter): Join; } type JoinFrame = DataFrame | AliasedDataFrame | Join; declare class With { cte(name: string,f: (ctes?: Record) => DataFrame): With; recursive(name: string,fields: string[],f: (ctes: Record) => DataFrame): With; select(f: (ctes: Record) => DataFrame|AliasedDataFrame): DataFrame; } declare namespace C { /** * For displaying HTML widgets into the cell output * @param id: optional id for the widgets * @returns a Widgets object that allows creating a bunch of related widgets */ function newWidgets(id?: string): Widgets; /** * This is a template literal for markdown * @returns html markup * ``` * C.md`**Hello World**`; * ``` */ function md(): Promise; /** * This is a template literal for katex * @returns html markup * ``` * C.katex`x^2`; * ``` */ function katex(): Promise; /** * special variable to indicate no output, otherwise undefined is assumed * ``` * return C.NONE; * ``` */ let NONE: string; /** * * @param by - time to delay in milliseconds * @param value - optional value to return (or a function that returns a vaue) after the delay * @returns a Promise with the optional return value * ``` * await C.delay(200,Math.random()); // random number generated before delay * await C.delay(200,() => new Date()); // date created after the delay * ``` */ function delay(by: number,value?: T|(()=>T)): Promise; } declare namespace N { /** * To load remote javascript and css files * @param urls a list of script or css files to load * @returns a generator that returns the urls as they are loaded */ function load(...urls: string[]): Generator; /** * This mimics requirejs's require API except the callback is changed to a Promise * @param urlPaths * @returns 1 or multiple values which would be same as those passed to the callback * function in the requirejs API. * ``` * N.require(['']); * ``` */ function require(...urlPaths: string[]): Promise; /** * This is same as requirejs's define API * @param args same as the requirejs define function */ function define(...args: unknown[]); } declare const W: Widgets; /** scratch pad to store and share data between notebook cells or cell executions */ declare const S: Record; declare class TimeCalculation extends Calculation { } declare class UnaryTimeCalculation extends Calculation { } export declare class Time { static year(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static quarter(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static month(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static date(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static hour(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static week(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static quarterOfYear(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static monthOfYear(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static weekOfYear(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static dayOfYear(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static dayOfMonth(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static dayOfWeek(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static hourOfDay(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static minuteOfHour(field: NameOrNamedDataValueProvider): UnaryTimeCalculation; static hierarchy(field: NameOrNamedDataValueProvider,...periods: ('y'|'q'|'m'|'w'|'d'|'h')[]): DataHierarchy; static currentDate(): TimeCalculation; static currentTimestamp(): TimeCalculation; static todate(date: Date): Date; static interval(amount: number,unit: DatePart|TimePart|string): TimeInterval; static datediff(field1: NameOrNamedDataValueProvider,field2: NameOrNamedDataValueProvider,datePart?: string|DatePart): TimeCalculation; static datesub(field: NameOrDataValueProvider,interval: TimeInterval): TimeCalculation; } declare class _DataFrame extends DataFrame {} declare class _SQL extends SQL {} declare class _Time extends Time {} // the following are not really available in global scope // they are declared to make them available in REPL interface for autosuggest declare global { export class DataFrame extends _DataFrame {} export class SQL extends _SQL {} export class Time extends _Time {} export const W: Widgets }