@dataform/core 3.0.45 → 3.0.47

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/bundle.d.ts CHANGED
@@ -9736,6 +9736,253 @@ namespace dataform {
9736
9736
  public static getTypeUrl(typeUrlPrefix?: string): string;
9737
9737
  }
9738
9738
 
9739
+ /** JitCompilationTargetType enum. */
9740
+ enum JitCompilationTargetType {
9741
+ JIT_COMPILATION_TARGET_TYPE_UNSPECIFIED = 0,
9742
+ JIT_COMPILATION_TARGET_TYPE_TABLE = 1,
9743
+ JIT_COMPILATION_TARGET_TYPE_OPERATION = 2,
9744
+ JIT_COMPILATION_TARGET_TYPE_INCREMENTAL_TABLE = 3
9745
+ }
9746
+
9747
+ /** Properties of a JitCompilationRequest. */
9748
+ interface IJitCompilationRequest {
9749
+
9750
+ /** JitCompilationRequest target */
9751
+ target?: (dataform.ITarget|null);
9752
+
9753
+ /** JitCompilationRequest dependencies */
9754
+ dependencies?: (dataform.ITarget[]|null);
9755
+
9756
+ /** JitCompilationRequest jitCode */
9757
+ jitCode?: (string|null);
9758
+
9759
+ /** JitCompilationRequest jitData */
9760
+ jitData?: (google.protobuf.IStruct|null);
9761
+
9762
+ /** JitCompilationRequest compilationTargetType */
9763
+ compilationTargetType?: (dataform.JitCompilationTargetType|null);
9764
+
9765
+ /** JitCompilationRequest filePaths */
9766
+ filePaths?: (string[]|null);
9767
+ }
9768
+
9769
+ /** Represents a JitCompilationRequest. */
9770
+ class JitCompilationRequest implements IJitCompilationRequest {
9771
+
9772
+ /**
9773
+ * Constructs a new JitCompilationRequest.
9774
+ * @param [properties] Properties to set
9775
+ */
9776
+ constructor(properties?: dataform.IJitCompilationRequest);
9777
+
9778
+ /** JitCompilationRequest target. */
9779
+ public target?: (dataform.ITarget|null);
9780
+
9781
+ /** JitCompilationRequest dependencies. */
9782
+ public dependencies: dataform.ITarget[];
9783
+
9784
+ /** JitCompilationRequest jitCode. */
9785
+ public jitCode: string;
9786
+
9787
+ /** JitCompilationRequest jitData. */
9788
+ public jitData?: (google.protobuf.IStruct|null);
9789
+
9790
+ /** JitCompilationRequest compilationTargetType. */
9791
+ public compilationTargetType: dataform.JitCompilationTargetType;
9792
+
9793
+ /** JitCompilationRequest filePaths. */
9794
+ public filePaths: string[];
9795
+
9796
+ /**
9797
+ * Creates a new JitCompilationRequest instance using the specified properties.
9798
+ * @param [properties] Properties to set
9799
+ * @returns JitCompilationRequest instance
9800
+ */
9801
+ public static create(properties?: dataform.IJitCompilationRequest): dataform.JitCompilationRequest;
9802
+
9803
+ /**
9804
+ * Encodes the specified JitCompilationRequest message. Does not implicitly {@link dataform.JitCompilationRequest.verify|verify} messages.
9805
+ * @param message JitCompilationRequest message or plain object to encode
9806
+ * @param [writer] Writer to encode to
9807
+ * @returns Writer
9808
+ */
9809
+ public static encode(message: dataform.IJitCompilationRequest, writer?: $protobuf.Writer): $protobuf.Writer;
9810
+
9811
+ /**
9812
+ * Encodes the specified JitCompilationRequest message, length delimited. Does not implicitly {@link dataform.JitCompilationRequest.verify|verify} messages.
9813
+ * @param message JitCompilationRequest message or plain object to encode
9814
+ * @param [writer] Writer to encode to
9815
+ * @returns Writer
9816
+ */
9817
+ public static encodeDelimited(message: dataform.IJitCompilationRequest, writer?: $protobuf.Writer): $protobuf.Writer;
9818
+
9819
+ /**
9820
+ * Decodes a JitCompilationRequest message from the specified reader or buffer.
9821
+ * @param reader Reader or buffer to decode from
9822
+ * @param [length] Message length if known beforehand
9823
+ * @returns JitCompilationRequest
9824
+ * @throws {Error} If the payload is not a reader or valid buffer
9825
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
9826
+ */
9827
+ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): dataform.JitCompilationRequest;
9828
+
9829
+ /**
9830
+ * Decodes a JitCompilationRequest message from the specified reader or buffer, length delimited.
9831
+ * @param reader Reader or buffer to decode from
9832
+ * @returns JitCompilationRequest
9833
+ * @throws {Error} If the payload is not a reader or valid buffer
9834
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
9835
+ */
9836
+ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): dataform.JitCompilationRequest;
9837
+
9838
+ /**
9839
+ * Verifies a JitCompilationRequest message.
9840
+ * @param message Plain object to verify
9841
+ * @returns `null` if valid, otherwise the reason why it is not
9842
+ */
9843
+ public static verify(message: { [k: string]: any }): (string|null);
9844
+
9845
+ /**
9846
+ * Creates a JitCompilationRequest message from a plain object. Also converts values to their respective internal types.
9847
+ * @param object Plain object
9848
+ * @returns JitCompilationRequest
9849
+ */
9850
+ public static fromObject(object: { [k: string]: any }): dataform.JitCompilationRequest;
9851
+
9852
+ /**
9853
+ * Creates a plain object from a JitCompilationRequest message. Also converts values to other types if specified.
9854
+ * @param message JitCompilationRequest
9855
+ * @param [options] Conversion options
9856
+ * @returns Plain object
9857
+ */
9858
+ public static toObject(message: dataform.JitCompilationRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
9859
+
9860
+ /**
9861
+ * Converts this JitCompilationRequest to JSON.
9862
+ * @returns JSON object
9863
+ */
9864
+ public toJSON(): { [k: string]: any };
9865
+
9866
+ /**
9867
+ * Gets the default type url for JitCompilationRequest
9868
+ * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
9869
+ * @returns The default type url
9870
+ */
9871
+ public static getTypeUrl(typeUrlPrefix?: string): string;
9872
+ }
9873
+
9874
+ /** Properties of a JitCompilationResponse. */
9875
+ interface IJitCompilationResponse {
9876
+
9877
+ /** JitCompilationResponse table */
9878
+ table?: (dataform.IJitTableResult|null);
9879
+
9880
+ /** JitCompilationResponse operation */
9881
+ operation?: (dataform.IJitOperationResult|null);
9882
+
9883
+ /** JitCompilationResponse incrementalTable */
9884
+ incrementalTable?: (dataform.IJitIncrementalTableResult|null);
9885
+ }
9886
+
9887
+ /** Represents a JitCompilationResponse. */
9888
+ class JitCompilationResponse implements IJitCompilationResponse {
9889
+
9890
+ /**
9891
+ * Constructs a new JitCompilationResponse.
9892
+ * @param [properties] Properties to set
9893
+ */
9894
+ constructor(properties?: dataform.IJitCompilationResponse);
9895
+
9896
+ /** JitCompilationResponse table. */
9897
+ public table?: (dataform.IJitTableResult|null);
9898
+
9899
+ /** JitCompilationResponse operation. */
9900
+ public operation?: (dataform.IJitOperationResult|null);
9901
+
9902
+ /** JitCompilationResponse incrementalTable. */
9903
+ public incrementalTable?: (dataform.IJitIncrementalTableResult|null);
9904
+
9905
+ /** JitCompilationResponse response. */
9906
+ public response?: ("table"|"operation"|"incrementalTable");
9907
+
9908
+ /**
9909
+ * Creates a new JitCompilationResponse instance using the specified properties.
9910
+ * @param [properties] Properties to set
9911
+ * @returns JitCompilationResponse instance
9912
+ */
9913
+ public static create(properties?: dataform.IJitCompilationResponse): dataform.JitCompilationResponse;
9914
+
9915
+ /**
9916
+ * Encodes the specified JitCompilationResponse message. Does not implicitly {@link dataform.JitCompilationResponse.verify|verify} messages.
9917
+ * @param message JitCompilationResponse message or plain object to encode
9918
+ * @param [writer] Writer to encode to
9919
+ * @returns Writer
9920
+ */
9921
+ public static encode(message: dataform.IJitCompilationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
9922
+
9923
+ /**
9924
+ * Encodes the specified JitCompilationResponse message, length delimited. Does not implicitly {@link dataform.JitCompilationResponse.verify|verify} messages.
9925
+ * @param message JitCompilationResponse message or plain object to encode
9926
+ * @param [writer] Writer to encode to
9927
+ * @returns Writer
9928
+ */
9929
+ public static encodeDelimited(message: dataform.IJitCompilationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
9930
+
9931
+ /**
9932
+ * Decodes a JitCompilationResponse message from the specified reader or buffer.
9933
+ * @param reader Reader or buffer to decode from
9934
+ * @param [length] Message length if known beforehand
9935
+ * @returns JitCompilationResponse
9936
+ * @throws {Error} If the payload is not a reader or valid buffer
9937
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
9938
+ */
9939
+ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): dataform.JitCompilationResponse;
9940
+
9941
+ /**
9942
+ * Decodes a JitCompilationResponse message from the specified reader or buffer, length delimited.
9943
+ * @param reader Reader or buffer to decode from
9944
+ * @returns JitCompilationResponse
9945
+ * @throws {Error} If the payload is not a reader or valid buffer
9946
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
9947
+ */
9948
+ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): dataform.JitCompilationResponse;
9949
+
9950
+ /**
9951
+ * Verifies a JitCompilationResponse message.
9952
+ * @param message Plain object to verify
9953
+ * @returns `null` if valid, otherwise the reason why it is not
9954
+ */
9955
+ public static verify(message: { [k: string]: any }): (string|null);
9956
+
9957
+ /**
9958
+ * Creates a JitCompilationResponse message from a plain object. Also converts values to their respective internal types.
9959
+ * @param object Plain object
9960
+ * @returns JitCompilationResponse
9961
+ */
9962
+ public static fromObject(object: { [k: string]: any }): dataform.JitCompilationResponse;
9963
+
9964
+ /**
9965
+ * Creates a plain object from a JitCompilationResponse message. Also converts values to other types if specified.
9966
+ * @param message JitCompilationResponse
9967
+ * @param [options] Conversion options
9968
+ * @returns Plain object
9969
+ */
9970
+ public static toObject(message: dataform.JitCompilationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
9971
+
9972
+ /**
9973
+ * Converts this JitCompilationResponse to JSON.
9974
+ * @returns JSON object
9975
+ */
9976
+ public toJSON(): { [k: string]: any };
9977
+
9978
+ /**
9979
+ * Gets the default type url for JitCompilationResponse
9980
+ * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
9981
+ * @returns The default type url
9982
+ */
9983
+ public static getTypeUrl(typeUrlPrefix?: string): string;
9984
+ }
9985
+
9739
9986
  /** Properties of a JitTableResult. */
9740
9987
  interface IJitTableResult {
9741
9988
 
@@ -10597,6 +10844,14 @@ interface ITableContext extends IActionContext {
10597
10844
  when: (cond: boolean, trueCase: string, falseCase?: string) => string;
10598
10845
  incremental: () => boolean;
10599
10846
  }
10847
+ declare type JitContext<T> = T & {
10848
+ adapter: dataform.DbAdapter;
10849
+ data?: {
10850
+ [k: string]: any;
10851
+ };
10852
+ request: dataform.IJitCompilationRequest;
10853
+ };
10854
+ declare type JitContextable<Context, T> = string | ((jctx: JitContext<Context>) => Promise<T>);
10600
10855
 
10601
10856
  declare type AContextable<T> = T | ((ctx: AssertionContext) => T);
10602
10857
  declare class Assertion extends ActionBuilder<dataform.Assertion> {
@@ -10688,11 +10943,75 @@ declare class Declaration extends ActionBuilder<dataform.Declaration> {
10688
10943
  private verifyConfig;
10689
10944
  }
10690
10945
 
10946
+ declare type JitTableResult = string | dataform.IJitTableResult;
10947
+ declare class Table extends ActionBuilder<dataform.Table> {
10948
+ session: Session;
10949
+ dependOnDependencyAssertions: boolean;
10950
+ contextableQuery: Contextable<ITableContext, string>;
10951
+ private contextableWhere;
10952
+ private contextableJitCode;
10953
+ private contextablePreOps;
10954
+ private contextablePostOps;
10955
+ private proto;
10956
+ private uniqueKeyAssertions;
10957
+ private rowConditionsAssertion;
10958
+ private unverifiedConfig;
10959
+ private configPath;
10960
+ constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
10961
+ type(type: TableType): this;
10962
+ query(query: Contextable<ITableContext, string>): this;
10963
+ where(where: Contextable<ITableContext, string>): this;
10964
+ jitCode(jitCode: JitContextable<ITableContext, JitTableResult>): this;
10965
+ preOps(pres: Contextable<ITableContext, string | string[]>): this;
10966
+ postOps(posts: Contextable<ITableContext, string | string[]>): this;
10967
+ disabled(disabled?: boolean): this;
10968
+ bigquery(bigquery: dataform.IBigQueryOptions): this;
10969
+ dependencies(value: Resolvable | Resolvable[]): this;
10970
+ hermetic(hermetic: boolean): void;
10971
+ tags(value: string | string[]): this;
10972
+ description(description: string): this;
10973
+ columns(columns: dataform.ActionConfig.ColumnDescriptor[]): this;
10974
+ database(database: string): this;
10975
+ schema(schema: string): this;
10976
+ assertions(tableAssertionsConfig: dataform.ActionConfig.TableAssertionsConfig): Table;
10977
+ setDependOnDependencyAssertions(dependOnDependencyAssertions: boolean): this;
10978
+ getFileName(): string;
10979
+ getTarget(): dataform.Target;
10980
+ compile(): dataform.Table;
10981
+ private compileJit;
10982
+ private compileAot;
10983
+ private contextifyOps;
10984
+ private verifyConfig;
10985
+ }
10986
+ declare class TableContext implements ITableContext {
10987
+ private table;
10988
+ private isIncremental;
10989
+ constructor(table: Table, isIncremental?: boolean);
10990
+ self(): string;
10991
+ name(): string;
10992
+ ref(ref: Resolvable | string[], ...rest: string[]): string;
10993
+ resolve(ref: Resolvable | string[], ...rest: string[]): string;
10994
+ schema(): string;
10995
+ database(): string;
10996
+ type(type: TableType): string;
10997
+ where(where: Contextable<ITableContext, string>): string;
10998
+ when(cond: boolean, trueCase: string, falseCase?: string): string;
10999
+ incremental(): boolean;
11000
+ preOps(statement: Contextable<ITableContext, string | string[]>): string;
11001
+ postOps(statement: Contextable<ITableContext, string | string[]>): string;
11002
+ disabled(): string;
11003
+ bigquery(bigquery: dataform.IBigQueryOptions): string;
11004
+ dependencies(res: Resolvable): string;
11005
+ apply<T>(value: Contextable<ITableContext, T>): T;
11006
+ tags(tags: string[]): string;
11007
+ }
11008
+
10691
11009
  declare class IncrementalTable extends ActionBuilder<dataform.Table> {
10692
11010
  session: Session;
10693
11011
  dependOnDependencyAssertions: boolean;
10694
11012
  contextableQuery: Contextable<ITableContext, string>;
10695
11013
  private contextableWhere;
11014
+ private contextableJitCode;
10696
11015
  private contextablePreOps;
10697
11016
  private contextablePostOps;
10698
11017
  private proto;
@@ -10704,6 +11023,7 @@ declare class IncrementalTable extends ActionBuilder<dataform.Table> {
10704
11023
  type(type: TableType): this;
10705
11024
  query(query: Contextable<ITableContext, string>): this;
10706
11025
  where(where: Contextable<ITableContext, string>): this;
11026
+ jitCode(jitCode: JitContextable<ITableContext, JitTableResult>): this;
10707
11027
  preOps(pres: Contextable<ITableContext, string | string[]>): this;
10708
11028
  postOps(posts: Contextable<ITableContext, string | string[]>): this;
10709
11029
  disabled(disabled?: boolean): this;
@@ -10722,6 +11042,8 @@ declare class IncrementalTable extends ActionBuilder<dataform.Table> {
10722
11042
  getFileName(): string;
10723
11043
  getTarget(): dataform.Target;
10724
11044
  compile(): dataform.Table;
11045
+ private compileJit;
11046
+ private compileAot;
10725
11047
  private contextifyOps;
10726
11048
  private verifyConfig;
10727
11049
  private mapOnSchemaChange;
@@ -10740,13 +11062,16 @@ declare class Notebook extends ActionBuilder<dataform.Notebook> {
10740
11062
  private verifyConfig;
10741
11063
  }
10742
11064
 
11065
+ declare type JitOperationResult = string | string[] | dataform.IJitOperationResult;
10743
11066
  declare class Operation extends ActionBuilder<dataform.Operation> {
10744
11067
  session: Session;
10745
11068
  dependOnDependencyAssertions: boolean;
10746
11069
  private proto;
10747
11070
  private contextableQueries;
11071
+ private contextableJitCode;
10748
11072
  constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
10749
11073
  queries(queries: Contextable<IActionContext, string | string[]>): this;
11074
+ jitCode(jitCode: JitContextable<IActionContext, JitOperationResult>): this;
10750
11075
  dependencies(value: Resolvable | Resolvable[]): this;
10751
11076
  hermetic(hermetic: boolean): void;
10752
11077
  disabled(disabled?: boolean): this;
@@ -10761,6 +11086,7 @@ declare class Operation extends ActionBuilder<dataform.Operation> {
10761
11086
  getTarget(): dataform.Target;
10762
11087
  getHasOutput(): boolean;
10763
11088
  compile(): dataform.Operation;
11089
+ private compileJit;
10764
11090
  private verifyConfig;
10765
11091
  }
10766
11092
  declare class OperationContext implements IActionContext {
@@ -10779,69 +11105,13 @@ declare class OperationContext implements IActionContext {
10779
11105
  apply<T>(value: Contextable<IActionContext, T>): T;
10780
11106
  }
10781
11107
 
10782
- declare class Table extends ActionBuilder<dataform.Table> {
10783
- session: Session;
10784
- dependOnDependencyAssertions: boolean;
10785
- contextableQuery: Contextable<ITableContext, string>;
10786
- private contextableWhere;
10787
- private contextablePreOps;
10788
- private contextablePostOps;
10789
- private proto;
10790
- private uniqueKeyAssertions;
10791
- private rowConditionsAssertion;
10792
- private unverifiedConfig;
10793
- private configPath;
10794
- constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
10795
- type(type: TableType): this;
10796
- query(query: Contextable<ITableContext, string>): this;
10797
- where(where: Contextable<ITableContext, string>): this;
10798
- preOps(pres: Contextable<ITableContext, string | string[]>): this;
10799
- postOps(posts: Contextable<ITableContext, string | string[]>): this;
10800
- disabled(disabled?: boolean): this;
10801
- bigquery(bigquery: dataform.IBigQueryOptions): this;
10802
- dependencies(value: Resolvable | Resolvable[]): this;
10803
- hermetic(hermetic: boolean): void;
10804
- tags(value: string | string[]): this;
10805
- description(description: string): this;
10806
- columns(columns: dataform.ActionConfig.ColumnDescriptor[]): this;
10807
- database(database: string): this;
10808
- schema(schema: string): this;
10809
- assertions(tableAssertionsConfig: dataform.ActionConfig.TableAssertionsConfig): Table;
10810
- setDependOnDependencyAssertions(dependOnDependencyAssertions: boolean): this;
10811
- getFileName(): string;
10812
- getTarget(): dataform.Target;
10813
- compile(): dataform.Table;
10814
- private contextifyOps;
10815
- private verifyConfig;
10816
- }
10817
- declare class TableContext implements ITableContext {
10818
- private table;
10819
- private isIncremental;
10820
- constructor(table: Table, isIncremental?: boolean);
10821
- self(): string;
10822
- name(): string;
10823
- ref(ref: Resolvable | string[], ...rest: string[]): string;
10824
- resolve(ref: Resolvable | string[], ...rest: string[]): string;
10825
- schema(): string;
10826
- database(): string;
10827
- type(type: TableType): string;
10828
- where(where: Contextable<ITableContext, string>): string;
10829
- when(cond: boolean, trueCase: string, falseCase?: string): string;
10830
- incremental(): boolean;
10831
- preOps(statement: Contextable<ITableContext, string | string[]>): string;
10832
- postOps(statement: Contextable<ITableContext, string | string[]>): string;
10833
- disabled(): string;
10834
- bigquery(bigquery: dataform.IBigQueryOptions): string;
10835
- dependencies(res: Resolvable): string;
10836
- apply<T>(value: Contextable<ITableContext, T>): T;
10837
- tags(tags: string[]): string;
10838
- }
10839
-
11108
+ declare type JitViewResult = string | dataform.IJitTableResult;
10840
11109
  declare class View extends ActionBuilder<dataform.Table> {
10841
11110
  session: Session;
10842
11111
  dependOnDependencyAssertions: boolean;
10843
11112
  contextableQuery: Contextable<ITableContext, string>;
10844
11113
  private contextableWhere;
11114
+ private contextableJitCode;
10845
11115
  private contextablePreOps;
10846
11116
  private contextablePostOps;
10847
11117
  private proto;
@@ -10867,9 +11137,12 @@ declare class View extends ActionBuilder<dataform.Table> {
10867
11137
  schema(schema: string): this;
10868
11138
  assertions(tableAssertionsConfig: dataform.ActionConfig.TableAssertionsConfig): View;
10869
11139
  setDependOnDependencyAssertions(dependOnDependencyAssertions: boolean): this;
11140
+ jitCode(jitCode: JitContextable<ITableContext, JitViewResult>): this;
10870
11141
  getFileName(): string;
10871
11142
  getTarget(): dataform.Target;
10872
11143
  compile(): dataform.Table;
11144
+ private compileJit;
11145
+ private compileAot;
10873
11146
  private contextifyOps;
10874
11147
  private verifyConfig;
10875
11148
  }
@@ -10996,16 +11269,31 @@ declare class CompilationSql {
10996
11269
  rowConditionsAssertion(dataset: string, rowConditions: string[]): string;
10997
11270
  }
10998
11271
 
11272
+ declare class ResolvableMap<T> {
11273
+ private byName;
11274
+ private bySchemaAndName;
11275
+ private byDatabaseAndName;
11276
+ private byDatabaseSchemaAndName;
11277
+ constructor(values?: Array<{
11278
+ actionTarget: dataform.ITarget;
11279
+ value: T;
11280
+ }>);
11281
+ set(actionTarget: dataform.ITarget, value: T): void;
11282
+ find(actionTarget: dataform.ITarget): T[];
11283
+ private setByNameLevel;
11284
+ private setBySchemaLevel;
11285
+ }
11286
+
10999
11287
  declare class Session {
11000
11288
  rootDir: string;
11001
11289
  projectConfig: dataform.ProjectConfig;
11002
11290
  canonicalProjectConfig: dataform.ProjectConfig;
11003
11291
  actions: Action[];
11004
- indexedActions: ActionMap;
11292
+ indexedActions: ResolvableMap<Action>;
11005
11293
  tests: {
11006
11294
  [name: string]: Test;
11007
11295
  };
11008
- actionAssertionMap: ActionMap;
11296
+ actionAssertionMap: ResolvableMap<Action>;
11009
11297
  graphErrors: dataform.IGraphErrors;
11010
11298
  jitContextData: google.protobuf.Struct | undefined;
11011
11299
  constructor(rootDir?: string, projectConfig?: dataform.ProjectConfig, originalProjectConfig?: dataform.ProjectConfig);
@@ -11047,28 +11335,23 @@ declare class Session {
11047
11335
  private checkCircularity;
11048
11336
  private removeNonUniqueActionsFromCompiledGraph;
11049
11337
  }
11050
- declare class ActionMap {
11051
- private byName;
11052
- private bySchemaAndName;
11053
- private byDatabaseAndName;
11054
- private byDatabaseSchemaAndName;
11055
- constructor(actions: Action[]);
11056
- set(actionTarget: dataform.ITarget, assertionTarget: Action): void;
11057
- find(target: dataform.ITarget): Action[];
11058
- private setByNameLevel;
11059
- private setBySchemaLevel;
11060
- }
11061
11338
 
11062
11339
  interface IDataformExtension {
11063
11340
  compile(request: dataform.ICompileExecutionRequest, session: Session): void;
11064
11341
  }
11065
11342
 
11343
+ interface IJitCompiler {
11344
+ compile: (request: Uint8Array) => Promise<Uint8Array>;
11345
+ }
11346
+ declare type RpcCallback = (method: string, request: Uint8Array, callback: (error: Error | null, response: Uint8Array) => void) => void;
11347
+ declare function jitCompiler(rpcCallback: RpcCallback): IJitCompiler;
11348
+
11066
11349
  declare function main(coreExecutionRequest: Uint8Array | string): Uint8Array | string;
11067
11350
 
11068
- declare const version = "3.0.45";
11351
+ declare const version = "3.0.47";
11069
11352
 
11070
11353
  declare const session: Session;
11071
11354
  declare const supportedFeatures: dataform.SupportedFeatures[];
11072
11355
  declare function indexFileGenerator(): void;
11073
11356
 
11074
- export { IDataformExtension, compile as compiler, indexFileGenerator, main, session, supportedFeatures, version };
11357
+ export { IDataformExtension, IJitCompiler, compile as compiler, indexFileGenerator, jitCompiler, main, session, supportedFeatures, version };