@narrative.io/data-collaboration-sdk-ts 0.0.107 → 0.0.109

package/build/nql/SubstraitParser.d.ts

@@ -10,13 +10,13 @@ http://www.apache.org/licenses/LICENSE-2.0
 NOTICE: THIS FILE HAS BEEN MODIFIED BY NARRATIVE I/O UNDER COMPLIANCE WITH THE APACHE 2.0 LICENCE FROM THE ORIGINAL WORK
 OF THE COMPANY Substrait (https://github.com/substrait-io/substrait-js).
 */
-type Nullability = 'NULLABILITY_UNSPECIFIED' | 'NULLABILITY_NULLABLE' | 'NULLABILITY_REQUIRED';
-type FailureBehavior = 'FAILURE_BEHAVIOR_UNSPECIFIED' | 'FAILURE_BEHAVIOR_RETURN_NULL' | 'THROW_EXCEPTION';
+type Nullability = "NULLABILITY_UNSPECIFIED" | "NULLABILITY_NULLABLE" | "NULLABILITY_REQUIRED";
+type FailureBehavior = "FAILURE_BEHAVIOR_UNSPECIFIED" | "FAILURE_BEHAVIOR_RETURN_NULL" | "THROW_EXCEPTION";
 interface AdvancedExtension {
     optimization: unknown;
     enhancement: unknown;
 }
-type LogicalOperator = 'and' | 'or' | 'not';
+type LogicalOperator = "and" | "or" | "not";
 interface Expression {
     selection?: FieldReference;
     scalarFunction?: ScalarFunction;
@@ -512,240 +512,240 @@ declare class SubstraitParser {
     filters: string[];
     logicalOperators: LogicalOperator[];
     /**
-       * Constructs a SubstraitParser
-       * @param {SubstraitPlan} plan the Substrait plan
-       */
+     * Constructs a SubstraitParser
+     * @param {SubstraitPlan} plan the Substrait plan
+     */
     constructor(plan: Plan);
     /**
-       * Creates a map from anchor to function name
-       * @param {SubstraitPlan} plan the Substrait plan
-       * @return {Map<number, string>} the created mapping
-       */
+     * Creates a map from anchor to function name
+     * @param {SubstraitPlan} plan the Substrait plan
+     * @return {Map<number, string>} the created mapping
+     */
     buildExtensionSet(plan: Plan): Map<number, string>;
     /**
-       * Geneate a unique id for the node
-       * @param {string} type The type of the node
-       * @return {string} A unique id
-       */
+     * Geneate a unique id for the node
+     * @param {string} type The type of the node
+     * @return {string} A unique id
+     */
     nextId(type: string): string;
     /**
-       * Create a schema field
-       *
-       * This is a special field with an empty name and an empty type string
-       * and uknown nullability
-       *
-       * @param {Field[]} fields the fields of the schema
-       * @return {Field} a schema field
-       */
+     * Create a schema field
+     *
+     * This is a special field with an empty name and an empty type string
+     * and uknown nullability
+     *
+     * @param {Field[]} fields the fields of the schema
+     * @return {Field} a schema field
+     */
     makeSchemaField(fields: Field[]): Field;
     /**
-       * Applies a Substrait emit to an output schema
-       * @param {Field} schema the original output schema
-       * @param {Object} emit a potential remapping of fields
-       * @return {Field} the remapped output schema
-       */
+     * Applies a Substrait emit to an output schema
+     * @param {Field} schema the original output schema
+     * @param {Object} emit a potential remapping of fields
+     * @return {Field} the remapped output schema
+     */
     applyEmit(schema: Field, emit?: Emit): Field;
     /**
-       * Create a print node, generating a new id
-       *
-       * @param {string} type the node type
-       * @param {PrintNode[]} inputs the inputs to the node
-       * @param {SimpleProperty[]} props properties describing the node
-       * @param {Field} schema the output schema of the node
-       * @param {Object} emit the Substrait emit for the node
-       * @return {PrintNode} a print node
-       */
+     * Create a print node, generating a new id
+     *
+     * @param {string} type the node type
+     * @param {PrintNode[]} inputs the inputs to the node
+     * @param {SimpleProperty[]} props properties describing the node
+     * @param {Field} schema the output schema of the node
+     * @param {Object} emit the Substrait emit for the node
+     * @return {PrintNode} a print node
+     */
     makePrintNode(type: string, inputs: PrintNode[], props: SimpleProperty[], schema: Field, emit?: Emit): PrintNode;
     /**
-       * Recursive helper for structFieldToStr
-       * @param {*} field the Substrait field to convert
-       * @param {*} currentName the current name
-       * @param {Field} currentField the current input field
-       * @return {Field} a stringified represenstation
-       */
+     * Recursive helper for structFieldToStr
+     * @param {*} field the Substrait field to convert
+     * @param {*} currentName the current name
+     * @param {Field} currentField the current input field
+     * @return {Field} a stringified represenstation
+     */
     structFieldHelper(field: StructItem, currentName: string, currentField: Field): Field;
     /**
-       * Convert a struct field to a stringified representation
-       *
-       * Struct fields are usually intuitively written with names.
-       * For example, a.b.c.   However, fields in Substrait plans
-       * are not typically named.  So instead we represent them as
-       * $0, $1, $2, ... where $N means the field at index N.
-       *
-       * If the field does happen to be named we will use that.
-       *
-       * @param {StructItem} field a Substrait struct field
-       * @param {Field} exprIn the input to the expression
-       * @return {Field} a stringified representation
-       */
+     * Convert a struct field to a stringified representation
+     *
+     * Struct fields are usually intuitively written with names.
+     * For example, a.b.c.   However, fields in Substrait plans
+     * are not typically named.  So instead we represent them as
+     * $0, $1, $2, ... where $N means the field at index N.
+     *
+     * If the field does happen to be named we will use that.
+     *
+     * @param {StructItem} field a Substrait struct field
+     * @param {Field} exprIn the input to the expression
+     * @return {Field} a stringified representation
+     */
     structFieldToField(field: StructItem, exprIn: Field): Field;
     /**
-       * Convert a direct reference to a stringified representation
-       * @param {Object} ref A Substrait direct reference
-       * @param {Object} exprIn the input to the expression
-       * @return {Field} a string representation
-       */
+     * Convert a direct reference to a stringified representation
+     * @param {Object} ref A Substrait direct reference
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
     directReferenceToField(ref: ReferenceSegment, exprIn: Field): Field;
     /**
-       * Convert a reference to a stringified representation
-       * @param {Object} ref A Substrait reference expression
-       * @param {Object} exprIn the input to the expression
-       * @return {Field} a string representation
-       */
+     * Convert a reference to a stringified representation
+     * @param {Object} ref A Substrait reference expression
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
     referenceToField(ref: FieldReference, exprIn: Field): Field;
     /**
-       * Convert a Substrait function argument to a string
-       * @param {Object} arg the argument to convert
-       * @param {Field} inp the input field
-       * @return {string} a string representation
-       */
+     * Convert a Substrait function argument to a string
+     * @param {Object} arg the argument to convert
+     * @param {Field} inp the input field
+     * @return {string} a string representation
+     */
     functionArgumentToStr(arg: FunctionArgument, inp: Field): string;
     /**
-       * Converts a Substrait function reference to a string
-       * @param {number} ref a Substrait function reference
-       * @return {string} a string version of the reference
-       */
+     * Converts a Substrait function reference to a string
+     * @param {number} ref a Substrait function reference
+     * @return {string} a string version of the reference
+     */
     functionRefToName(ref: number): string;
     /**
-       * Convert arguments to a joined string
-       * @param {FunctionTyp} func A Substrait function call
-       * @param {Field} schema The input type
-       * @return {string} A string representation
-       */
+     * Convert arguments to a joined string
+     * @param {FunctionTyp} func A Substrait function call
+     * @param {Field} schema The input type
+     * @return {string} A string representation
+     */
     argsToString(func: FunctionTyp, schema: Field): string;
     /**
-       * Convert a scalar function to a stringified representation
-       * @param {Object} func the function to convert
-       * @param {Field} schema the input type info
-       * @return {Field} a string version of the function
-       */
+     * Convert a scalar function to a stringified representation
+     * @param {Object} func the function to convert
+     * @param {Field} schema the input type info
+     * @return {Field} a string version of the function
+     */
     scalarFunctionToField(func: ScalarFunction, schema: Field): Field;
     /**
-       * Converts a Substrait literal to a field
-       * @param {Object} lit the Substrait literal
-       * @return {Field} a field representation
-       */
+     * Converts a Substrait literal to a field
+     * @param {Object} lit the Substrait literal
+     * @return {Field} a field representation
+     */
     literalToField(lit: Literal): Field;
     /**
-       * Convert a cast expression to a stringified representation
-       * @param {Object} cast A Substrait cast expression
-       * @param {Field} schema The input schema
-       * @return {Field} A field representation
-       */
+     * Convert a cast expression to a stringified representation
+     * @param {Object} cast A Substrait cast expression
+     * @param {Field} schema The input schema
+     * @return {Field} A field representation
+     */
     castToField(cast: CastExpression, schema: Field): Field;
     /**
-       * Convert an expression to a stringified representation
-       *
-       * The expression is returned as a field where the type
-       * of the field is the output type of the expression and the
-       * name of the field is a string representation of the expression
-       *
-       * @param {Object} expr A Substrait expression
-       * @param {Object} exprIn the input to the expression
-       * @return {Field} a string representation
-       */
+     * Convert an expression to a stringified representation
+     *
+     * The expression is returned as a field where the type
+     * of the field is the output type of the expression and the
+     * name of the field is a string representation of the expression
+     *
+     * @param {Object} expr A Substrait expression
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
     expressionToStr(expr: Expression, exprIn: Field): Field;
     /**
-       * Convert a project relation to a print node
-       * @param {Object} project A Substrait ProjectRel
-       * @return {PrintNode} a print node
-       */
+     * Convert a project relation to a print node
+     * @param {Object} project A Substrait ProjectRel
+     * @return {PrintNode} a print node
+     */
     projectToNode(project: ProjectRelation): PrintNode;
     /**
-       * Convert a Substrait data type to an unnamed Field
-       *
-       * The field's name will be an empty string
-       *
-       * @param {Object} type a Substrait data type
-       * @return {Field} an unnamed field
-       */
+     * Convert a Substrait data type to an unnamed Field
+     *
+     * The field's name will be an empty string
+     *
+     * @param {Object} type a Substrait data type
+     * @return {Field} an unnamed field
+     */
     typeToField(type: LiteralType): Field;
     /**
-       * Convert a named struct to an array of Field
-       * @param {NamedStruct} struct a Substrait named struct
-       * @return {Field[]} named fields
-       */
+     * Convert a named struct to an array of Field
+     * @param {NamedStruct} struct a Substrait named struct
+     * @return {Field[]} named fields
+     */
     namedStructToSchema(struct: NamedStruct): Field;
     /**
-       * Extract the properties from a read relation
-       * @param {Object} read a Substrait read relation
-       * @return {SimpleProperty[]} properties for the relation
-       */
+     * Extract the properties from a read relation
+     * @param {Object} read a Substrait read relation
+     * @return {SimpleProperty[]} properties for the relation
+     */
     readTypeToProps(read: ReadRelation): SimpleProperty[];
     /**
-       * Convert a Substrait read relation to a print node
-       * @param {Object} read a Substrait read relation
-       * @return {PrintNode} a print node
-       */
+     * Convert a Substrait read relation to a print node
+     * @param {Object} read a Substrait read relation
+     * @return {PrintNode} a print node
+     */
     readToNode(read: ReadRelation): PrintNode;
     /**
-       * True if the object has a field with the given name
-       * @param {Object} obj the object to test
-       * @param {string} fieldName the field name to look for
-       * @return {boolean} the result of the test
-       */
+     * True if the object has a field with the given name
+     * @param {Object} obj the object to test
+     * @param {string} fieldName the field name to look for
+     * @return {boolean} the result of the test
+     */
     hasValue(obj: object, fieldName: string): boolean;
     /**
-       * Convert a Substrait fetch relation to a print node
-       * @param {Object} fetch a Substrait fetch relation
-       * @return {PrintNode} a print node
-       */
+     * Convert a Substrait fetch relation to a print node
+     * @param {Object} fetch a Substrait fetch relation
+     * @return {PrintNode} a print node
+     */
     fetchToNode(fetch: FetchRelation): PrintNode;
     /**
-       * Convert a Substrait sort field to a property
-       * @param {Object} sortField a Substrait sort field
-       * @param {Field} schema the schema of the sort input
-       * @return {SimpleProperty} a property describing the sort
-       */
+     * Convert a Substrait sort field to a property
+     * @param {Object} sortField a Substrait sort field
+     * @param {Field} schema the schema of the sort input
+     * @return {SimpleProperty} a property describing the sort
+     */
     sortFieldToStr(sortField: SortField, schema: Field): string | undefined;
     /**
-       * Convert a Substrait sort relation to a print node
-       * @param {Object} sort a Substrait sort relation
-       * @return {PrintNode} a print node
-       */
+     * Convert a Substrait sort relation to a print node
+     * @param {Object} sort a Substrait sort relation
+     * @return {PrintNode} a print node
+     */
     sortToNode(sort: SortRelation): PrintNode;
     /**
-       * Convert a Substrait aggregate function to a field
-       * @param {Object} func the Substrait aggregate function
-       * @param {Field} inp the input field
-       * @return {Field} a field representation of the function
-       */
+     * Convert a Substrait aggregate function to a field
+     * @param {Object} func the Substrait aggregate function
+     * @param {Field} inp the input field
+     * @return {Field} a field representation of the function
+     */
     aggregateFunctionToField(func: AggregateFunction, inp: Field): Field;
     /**
-       * Convert a Substrait aggregate relation to a print node
-       * @param {Object} agg a Substrait aggregate relation
-       * @return {PrintNode} a print node
-       */
+     * Convert a Substrait aggregate relation to a print node
+     * @param {Object} agg a Substrait aggregate relation
+     * @return {PrintNode} a print node
+     */
     aggToNode(agg: AggregateRelation): PrintNode;
     /**
-       * Convert a Substrait filter relation to a print node
-       * @param {Object} filt a Substrait filter relation
-       * @return {PrintNode} a print node
-       */
+     * Convert a Substrait filter relation to a print node
+     * @param {Object} filt a Substrait filter relation
+     * @return {PrintNode} a print node
+     */
     filterToNode(filt: FilterRelation): PrintNode;
     /**
-       * Converts a Substrait join relation to a print node
-       * @param {Object} join a Substrait join relation
-       * @return {PrintNode} a print node
-       */
+     * Converts a Substrait join relation to a print node
+     * @param {Object} join a Substrait join relation
+     * @return {PrintNode} a print node
+     */
     joinToNode(join: JoinRelation): PrintNode;
     /**
-       * Converts a Substrait relation to a print node
-       * @param {Object} rel the Substrait relation to convert
-       * @return {PrintNode} a print node
-       */
+     * Converts a Substrait relation to a print node
+     * @param {Object} rel the Substrait relation to convert
+     * @return {PrintNode} a print node
+     */
     relToNode(rel: Rel): PrintNode;
     /**
-       * Converts a Substrait root relation to a print node
-       * @param {Object} rel the Substrait relation to convert
-       * @return {PrintNode} a print node
-       */
+     * Converts a Substrait root relation to a print node
+     * @param {Object} rel the Substrait relation to convert
+     * @return {PrintNode} a print node
+     */
     rootRelToNode(rel: RelationRoot): PrintNode;
     /**
-       * Converts a Substrait plan to a print node
-       * @param {Object} plan the Substrait plan to convert
-       * @return {PrintNode} a print node
-       */
+     * Converts a Substrait plan to a print node
+     * @param {Object} plan the Substrait plan to convert
+     * @return {PrintNode} a print node
+     */
     planToNode(plan: Plan): PrintNode;
     parse(plan: Plan): {
         selection: string[];