@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/model/malloy_types.d.ts

@@ -34,23 +34,23 @@ interface DocumentReferenceBase {
     definition: HasLocation;
 }
 export interface DocumentExploreReference extends DocumentReferenceBase {
-    type: "exploreReference";
+    type: 'exploreReference';
     definition: StructDef;
 }
 export interface DocumentJoinReference extends DocumentReferenceBase {
-    type: "joinReference";
+    type: 'joinReference';
     definition: FieldDef;
 }
 export interface DocumentSQLBlockReference extends DocumentReferenceBase {
-    type: "sqlBlockReference";
+    type: 'sqlBlockReference';
     definition: SQLBlockStructDef;
 }
 export interface DocumentQueryReference extends DocumentReferenceBase {
-    type: "queryReference";
+    type: 'queryReference';
     definition: Query;
 }
 export interface DocumentFieldReference extends DocumentReferenceBase {
-    type: "fieldReference";
+    type: 'fieldReference';
     definition: FieldDef;
 }
 export declare type DocumentReference = DocumentExploreReference | DocumentQueryReference | DocumentSQLBlockReference | DocumentFieldReference | DocumentJoinReference;
@@ -79,7 +79,7 @@ export interface ResultMetadataDef {
     sourceExpression?: string;
     sourceClasses: string[];
     filterList?: FilterExpression[];
-    fieldKind: "measure" | "dimension" | "struct";
+    fieldKind: 'measure' | 'dimension' | 'struct';
 }
 export interface ResultStructMetadataDef extends ResultMetadataDef {
     limit?: number;
@@ -91,14 +91,14 @@ export interface ResultStructMetadata {
     resultMetadata?: ResultStructMetadataDef;
 }
 export interface FilterFragment {
-    type: "filterExpression";
+    type: 'filterExpression';
     filterList: FilterExpression[];
     e: Expr;
 }
 export declare function isFilterFragment(f: Fragment): f is FilterFragment;
 export declare function isDialectFragment(f: Fragment): f is DialectFragment;
 export interface AggregateFragment {
-    type: "aggregate";
+    type: 'aggregate';
     function: string;
     e: Expr;
     structPath?: string;
@@ -106,100 +106,100 @@ export interface AggregateFragment {
 export declare function isAggregateFragment(f: Fragment): f is AggregateFragment;
 export declare function isAsymmetricFragment(f: Fragment): f is AggregateFragment;
 export interface UngroupFragment {
-    type: "all" | "exclude";
+    type: 'all' | 'exclude';
     e: Expr;
     fields?: string[];
 }
 export declare function isUngroupFragment(f: Fragment): f is UngroupFragment;
-export declare type MalloyFunctionParam = AtomicFieldType | "any" | "nconst" | "regexp";
+export declare type MalloyFunctionParam = AtomicFieldType | 'any' | 'nconst' | 'regexp';
 export interface MalloyFunctionInfo {
     returnType: AtomicFieldType;
-    parameters: "any" | "none" | MalloyFunctionParam[];
-    expressionType?: "aggregate" | "analytic";
+    parameters: 'any' | 'none' | MalloyFunctionParam[];
+    expressionType?: 'aggregate' | 'analytic';
     sqlName?: string;
 }
 export declare const malloyFunctions: Record<string, MalloyFunctionInfo>;
 export interface AnalyticFragment {
-    type: "analytic";
+    type: 'analytic';
     function: string;
     parameters?: (string | number | Expr)[];
 }
 export declare function isAnalyticFragment(f: Fragment): f is AnalyticFragment;
 export interface FieldFragment {
-    type: "field";
+    type: 'field';
     path: string;
 }
 export declare function isFieldFragment(f: Fragment): f is FieldFragment;
 export interface ParameterFragment {
-    type: "parameter";
+    type: 'parameter';
     path: string;
 }
 export declare function isParameterFragment(f: Fragment): f is ParameterFragment;
 export interface ApplyValueFragment {
-    type: "applyVal";
+    type: 'applyVal';
 }
 export declare function isApplyValue(f: Fragment): f is ApplyValueFragment;
 export interface ApplyFragment {
-    type: "apply";
+    type: 'apply';
     value: Expr;
     to: Expr;
 }
 export declare function isApplyFragment(f: Fragment): f is ApplyFragment;
 interface DialectFragmentBase {
-    type: "dialect";
+    type: 'dialect';
     function: string;
 }
 export interface NowFragment extends DialectFragmentBase {
-    function: "now";
+    function: 'now';
 }
 export interface TimeDiffFragment extends DialectFragmentBase {
-    function: "timeDiff";
+    function: 'timeDiff';
     units: TimestampUnit;
     left: TimeValue;
     right: TimeValue;
 }
 export interface TimeDeltaFragment extends DialectFragmentBase {
-    function: "delta";
+    function: 'delta';
     base: TimeValue;
-    op: "+" | "-";
+    op: '+' | '-';
     delta: Expr;
     units: TimestampUnit;
 }
 export interface TimeTruncFragment extends DialectFragmentBase {
-    function: "trunc";
+    function: 'trunc';
     expr: TimeValue;
     units: TimestampUnit;
 }
 export interface TimeExtractFragment extends DialectFragmentBase {
-    function: "extract";
+    function: 'extract';
     expr: TimeValue;
     units: ExtractUnit;
 }
 export interface TypecastFragment extends DialectFragmentBase {
-    function: "cast";
+    function: 'cast';
     safe: boolean;
     expr: Expr;
     dstType: AtomicFieldType;
     srcType?: AtomicFieldType;
 }
 export interface RegexpMatchFragment extends DialectFragmentBase {
-    function: "regexpMatch";
+    function: 'regexpMatch';
     expr: Expr;
     regexp: string;
 }
 export interface DivFragment extends DialectFragmentBase {
-    function: "div";
+    function: 'div';
     numerator: Expr;
     denominator: Expr;
 }
 export interface TimeLiteralFragment extends DialectFragmentBase {
-    function: "timeLiteral";
+    function: 'timeLiteral';
     literal: string;
     literalType: TimeFieldType;
     timezone: string;
 }
 export interface StringLiteralFragment extends DialectFragmentBase {
-    function: "stringLiteral";
+    function: 'stringLiteral';
     literal: string;
 }
 export declare type DialectFragment = DivFragment | TimeLiteralFragment | NowFragment | TimeDeltaFragment | TimeDiffFragment | TimeTruncFragment | TypecastFragment | TimeExtractFragment | StringLiteralFragment | RegexpMatchFragment;
@@ -224,7 +224,7 @@ declare type TagElement = Expr | string;
  * ```
  */
 export declare function mkExpr(src: TemplateStringsArray, ...exprs: TagElement[]): Expr;
-export declare type ExpressionType = "scalar" | "aggregate" | "analytic";
+export declare type ExpressionType = 'scalar' | 'aggregate' | 'analytic';
 export interface Expression {
     e?: Expr;
     expressionType?: ExpressionType;
@@ -239,9 +239,9 @@ interface JustExpression {
 declare type HasExpression = FieldDef & JustExpression;
 /**  Grants access to the expression property of a FielfDef */
 export declare function hasExpression(f: FieldDef): f is HasExpression;
-export declare type TimeFieldType = "date" | "timestamp";
+export declare type TimeFieldType = 'date' | 'timestamp';
 export declare function isTimeFieldType(s: string): s is TimeFieldType;
-export declare type AtomicFieldType = "string" | "number" | TimeFieldType | "boolean" | "unsupported" | "json";
+export declare type AtomicFieldType = 'string' | 'number' | TimeFieldType | 'boolean' | 'unsupported' | 'json';
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 /** All scalars can have an optional expression */
 export interface FieldAtomicDef extends NamedObject, Expression, ResultMetadata {
@@ -250,33 +250,33 @@ export interface FieldAtomicDef extends NamedObject, Expression, ResultMetadata
 export declare function FieldIsIntrinsic(f: FieldDef): boolean;
 /** Scalar String Field */
 export interface FieldStringDef extends FieldAtomicDef {
-    type: "string";
+    type: 'string';
     bucketFilter?: string;
     bucketOther?: string;
 }
 /** Scalar Numeric String Field */
 export interface FieldNumberDef extends FieldAtomicDef {
-    type: "number";
-    numberType?: "integer" | "float";
+    type: 'number';
+    numberType?: 'integer' | 'float';
 }
 /** Scalar Boolean Field */
 export interface FieldBooleanDef extends FieldAtomicDef {
-    type: "boolean";
+    type: 'boolean';
 }
 /** Scalar JSON Field */
 export interface FieldJSONDef extends FieldAtomicDef {
-    type: "json";
+    type: 'json';
 }
 /** Scalar unsupported Field */
 export interface FieldUnsupportedDef extends FieldAtomicDef {
-    type: "unsupported";
+    type: 'unsupported';
     rawType?: string;
 }
-export declare type DateUnit = "day" | "week" | "month" | "quarter" | "year";
+export declare type DateUnit = 'day' | 'week' | 'month' | 'quarter' | 'year';
 export declare function isDateUnit(str: string): str is DateUnit;
-export declare type TimestampUnit = DateUnit | "hour" | "minute" | "second";
+export declare type TimestampUnit = DateUnit | 'hour' | 'minute' | 'second';
 export declare function isTimestampUnit(s: string): s is TimestampUnit;
-export declare type ExtractUnit = TimestampUnit | "day_of_week" | "day_of_year";
+export declare type ExtractUnit = TimestampUnit | 'day_of_week' | 'day_of_year';
 export declare function isExtractUnit(s: string): s is ExtractUnit;
 /** Value types distinguished by their usage in generated SQL, particularly with respect to filters. */
 export declare enum ValueType {
@@ -288,25 +288,25 @@ export declare enum ValueType {
 export declare type TimeValueType = ValueType.Date | ValueType.Timestamp;
 /** Scalar Date Field. */
 export interface FieldDateDef extends FieldAtomicDef {
-    type: "date";
+    type: 'date';
     timeframe?: DateUnit;
 }
 /** Scalar Timestamp Field */
 export interface FieldTimestampDef extends FieldAtomicDef {
-    type: "timestamp";
+    type: 'timestamp';
     timeframe?: TimestampUnit;
 }
 /** parameter to order a query */
 export interface OrderBy {
     field: string | number;
-    dir?: "asc" | "desc";
+    dir?: 'asc' | 'desc';
 }
 export interface ByName {
-    by: "name";
+    by: 'name';
     name: string;
 }
 export interface ByExpression {
-    by: "expression";
+    by: 'expression';
     e: Expr;
 }
 export declare type By = ByName | ByExpression;
@@ -335,17 +335,17 @@ export interface Pipeline {
     pipeline: PipeSegment[];
 }
 export interface Query extends Pipeline, Filtered, HasLocation {
-    type?: "query";
+    type?: 'query';
     structRef: StructRef;
 }
 export declare type NamedQuery = Query & NamedObject;
 export declare type PipeSegment = QuerySegment | IndexSegment;
 export interface ReduceSegment extends QuerySegment {
-    type: "reduce";
+    type: 'reduce';
 }
 export declare function isReduceSegment(pe: PipeSegment): pe is ReduceSegment;
 export interface ProjectSegment extends QuerySegment {
-    type: "project";
+    type: 'project';
 }
 export declare function isProjectSegment(pe: PipeSegment): pe is ProjectSegment;
 export declare function isQuerySegment(pe: PipeSegment): pe is QuerySegment;
@@ -363,7 +363,7 @@ interface SamplingEnable {
 }
 export declare function isSamplingEnable(s: Sampling): s is SamplingEnable;
 export interface IndexSegment extends Filtered {
-    type: "index";
+    type: 'index';
     fields: string[];
     limit?: number;
     weightMeasure?: string;
@@ -371,7 +371,7 @@ export interface IndexSegment extends Filtered {
 }
 export declare function isIndexSegment(pe: PipeSegment): pe is IndexSegment;
 export interface QuerySegment extends Filtered {
-    type: "reduce" | "project";
+    type: 'reduce' | 'project';
     fields: QueryFieldDef[];
     extendSource?: FieldDef[];
     limit?: number;
@@ -379,22 +379,22 @@ export interface QuerySegment extends Filtered {
     orderBy?: OrderBy[];
 }
 export interface TurtleDef extends NamedObject, Pipeline {
-    type: "turtle";
+    type: 'turtle';
 }
-export declare type JoinRelationship = "one_to_one" | "one_to_many" | "many_to_one" | "many_to_many";
+export declare type JoinRelationship = 'one_to_one' | 'one_to_many' | 'many_to_one' | 'many_to_many';
 export interface JoinOn {
-    type: "one" | "many" | "cross";
+    type: 'one' | 'many' | 'cross';
     onExpression?: Expr;
 }
 export declare function isJoinOn(sr: StructRelationship): sr is JoinOn;
 /** types of joins. */
 export declare type StructRelationship = {
-    type: "basetable";
+    type: 'basetable';
     connectionName: string;
 } | JoinOn | {
-    type: "inline";
+    type: 'inline';
 } | {
-    type: "nested";
+    type: 'nested';
     field: FieldRef;
     isArray: boolean;
 };
@@ -414,35 +414,35 @@ export interface SQLBlockSource {
     select: SQLPhrase[];
 }
 export interface SQLBlock extends NamedObject {
-    type: "sqlBlock";
+    type: 'sqlBlock';
     connection?: string;
     selectStr: string;
 }
 interface SubquerySource {
-    type: "sql";
-    method: "subquery";
+    type: 'sql';
+    method: 'subquery';
     sqlBlock: SQLBlock;
 }
 /** where does the struct come from? */
 export declare type StructSource = {
-    type: "table";
+    type: 'table';
     tablePath: string;
 } | {
-    type: "nested";
+    type: 'nested';
 } | {
-    type: "inline";
+    type: 'inline';
 } | {
-    type: "query";
+    type: 'query';
     query: Query;
 } | {
-    type: "sql";
-    method: "nested" | "lastStage";
+    type: 'sql';
+    method: 'nested' | 'lastStage';
 } | {
-    type: "query_result";
+    type: 'query_result';
 } | SubquerySource;
 /** struct that is intrinsic to the table */
 export interface StructDef extends NamedObject, ResultStructMetadata, Filtered {
-    type: "struct";
+    type: 'struct';
     structSource: StructSource;
     structRelationship: StructRelationship;
     fields: FieldDef[];