@hpcc-js/marshaller 2.28.11 → 3.1.1

package/src/ddl2/activities/limit.ts

@@ -1,14 +1,9 @@
-import { publish } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { hashSum } from "@hpcc-js/util";
-import { Activity } from "./activity";
+import { Activity } from "./activity.ts";
 
 export class Limit extends Activity {
 
-    @publish(undefined, "number", "Limit output")
-    rows: publish<this, number | undefined>;
-    rows_exists: () => boolean;
-
     constructor() {
         super();
     }
@@ -47,3 +42,10 @@ export class Limit extends Activity {
     }
 }
 Limit.prototype._class += " Limit";
+
+export interface Limit {
+    rows(): number | undefined;
+    rows(_: number | undefined): this;
+    rows_exists(): boolean;
+}
+Limit.prototype.publish("rows", undefined, "number", "Limit output");

package/src/ddl2/activities/logicalfile.ts

@@ -1,18 +1,10 @@
-import { publish } from "@hpcc-js/common";
 import { Result } from "@hpcc-js/comms";
 import { DDL2 } from "@hpcc-js/ddl-shim";
-import { ElementContainer } from "../model/element";
-import { ESPResult } from "./wuresult";
+import { ElementContainer } from "../model/element.ts";
+import { ESPResult } from "./wuresult.ts";
 
 export class LogicalFile extends ESPResult {
 
-    @publish("", "string", "ESP Url (http://x.x.x.x:8010)")
-    url: publish<this, string>;
-    @publish("", "string", "Node Group")
-    nodeGroup: publish<this, string>;
-    @publish("", "string", "Logical File Name")
-    logicalFile: publish<this, string>;
-
     constructor(_ec: ElementContainer) {
         super(_ec);
     }
@@ -60,3 +52,15 @@ export class LogicalFile extends ESPResult {
     }
 }
 LogicalFile.prototype._class += " LogicalFile";
+
+export interface LogicalFile {
+    url(): string;
+    url(_: string): this;
+    nodeGroup(): string;
+    nodeGroup(_: string): this;
+    logicalFile(): string;
+    logicalFile(_: string): this;
+}
+LogicalFile.prototype.publish("url", "", "string", "ESP Url (http://x.x.x.x:8010)");
+LogicalFile.prototype.publish("nodeGroup", "", "string", "Node Group");
+LogicalFile.prototype.publish("logicalFile", "", "string", "Logical File Name");

package/src/ddl2/activities/nullview.ts

@@ -1,4 +1,4 @@
-import { HipiePipeline } from "./hipiepipeline";
+import { HipiePipeline } from "./hipiepipeline.ts";
 
 export class NullView extends HipiePipeline {
     hash(): string {

package/src/ddl2/activities/project.ts

@@ -1,22 +1,11 @@
-import { PropertyExt, publish, Utility } from "@hpcc-js/common";
+import { PropertyExt, Utility } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { hashSum, isArray } from "@hpcc-js/util";
-import { Activity, IActivityError, ReferencedFields } from "./activity";
+import { Activity, IActivityError, ReferencedFields } from "./activity.ts";
 
 export class ComputedMapping extends PropertyExt {
     protected _owner: ComputedField;
 
-    @publish(null, "any", "Compare Value", undefined, {
-        validate: (w: ComputedMapping): boolean => (!w.value() && !w.newValue()) || (!!w.value() && !!w.newValue())
-    })
-    value: publish<this, any>;
-    value_valid: () => boolean;
-    @publish(null, "any", "New Value", undefined, {
-        validate: (w: ComputedMapping): boolean => (!w.value() && !w.newValue()) || (!!w.value() && !!w.newValue())
-    })
-    newValue: publish<this, any>;
-    newValue_valid: () => boolean;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.value_valid()) {
@@ -72,6 +61,15 @@ export class ComputedMapping extends PropertyExt {
 }
 ComputedMapping.prototype._class += " ComputedMapping";
 
+export interface ComputedMapping {
+    value(): any;
+    value(_: any): this;
+    value_valid(): boolean;
+    newValue(): any;
+    newValue(_: any): this;
+    newValue_valid(): boolean;
+}
+
 export type ComputedType = "=" | "*" | "/" | "+" | "-" | "scale" | "template" | "map";
 
 export interface IComputedFieldOwner extends PropertyExt {
@@ -82,35 +80,6 @@ export interface IComputedFieldOwner extends PropertyExt {
 export class ComputedField extends PropertyExt {
     private _owner: IComputedFieldOwner;
 
-    @publish(null, "string", "Label", null, { optional: true })
-    label: publish<this, string>;
-    @publish("mapping", "set", "Project type", ["=", "*", "/", "+", "-", "scale", "template", "map"], { optional: true, disable: w => !w.label() })
-    type: publish<this, ComputedType>;
-    @publish(null, "set", "Param 1", function (this: ComputedField) { return this.columns(); }, {
-        optional: true,
-        disable: (w: ComputedField) => w.disableColumn1(),
-        validate: (w: ComputedField): boolean => w.columns().indexOf(w.column1()) >= 0
-    })
-    column1: publish<this, string>;
-    column1_valid: () => boolean;
-    @publish(null, "set", "Param 2", function (this: ComputedField) { return this.columns(); }, {
-        optional: true,
-        disable: (w: ComputedField) => w.disableColumn2(),
-        validate: (w: ComputedField): boolean => w.columns().indexOf(w.column2()) >= 0
-    })
-    column2: publish<this, string>;
-    column2_valid: () => boolean;
-    @publish(null, "number", "Const value", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["scale"].indexOf(w.type()) < 0 })
-    constValue: publish<this, number>;
-    @publish(null, "string", "template", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["template"].indexOf(w.type()) < 0 })
-    template: publish<this, string>;
-    @publish(null, "any", "Default Value", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["map"].indexOf(w.type()) < 0 })
-    default: publish<this, any>;
-    @publish([], "propertyArray", "Mapped Values", null, { autoExpand: ComputedMapping, disable: (w: ComputedField) => w.disableMapping() })
-    mapping: publish<this, ComputedMapping[]>;
-    @publish([], "propertyArray", "Child Fields", null, { autoExpand: ComputedField, disable: (w: ComputedField) => w.disableChildField() })
-    childField: publish<this, ComputedField[]>;
-
     disableColumn1(): boolean {
         return !this.label() || ["=", "*", "/", "+", "-", "scale", "map"].indexOf(this.type()) < 0;
     }
@@ -435,15 +404,34 @@ export class ComputedField extends PropertyExt {
     }
 }
 ComputedField.prototype._class += " ComputedField";
+
+export interface ComputedField {
+    label(): string;
+    label(_: string): this;
+    type(): ComputedType;
+    type(_: ComputedType): this;
+    column1(): string;
+    column1(_: string): this;
+    column1_valid(): boolean;
+    column2(): string;
+    column2(_: string): this;
+    column2_valid(): boolean;
+    constValue(): number;
+    constValue(_: number): this;
+    template(): string;
+    template(_: string): this;
+    default(): any;
+    default(_: any): this;
+    mapping(): ComputedMapping[];
+    mapping(_: ComputedMapping[]): this;
+    childField(): ComputedField[];
+    childField(_: ComputedField[]): this;
+}
+
 //  ===========================================================================
 export class MultiField extends PropertyExt implements IComputedFieldOwner {
     private _owner: IComputedFieldOwner;
 
-    @publish("", "string", "Label")
-    label: publish<this, string>;
-    @publish([], "propertyArray", "Multi Fields", null, { autoExpand: ComputedField })
-    multiFields: publish<this, ComputedField[]>;
-
     constructor() {
         super();
     }
@@ -513,6 +501,14 @@ export class MultiField extends PropertyExt implements IComputedFieldOwner {
     }
 }
 MultiField.prototype._class += " MultiField";
+
+export interface MultiField {
+    label(): string;
+    label(_: string): this;
+    multiFields(): ComputedField[];
+    multiFields(_: ComputedField[]): this;
+}
+
 //  ===========================================================================
 export class ProjectBase extends Activity {
     static ComputedField = ComputedField;
@@ -520,9 +516,6 @@ export class ProjectBase extends Activity {
     _includeLParam = false;
     _trim = false;
 
-    @publish([], "propertyArray", "Computed Fields", null, { autoExpand: ComputedField, noDeserialize: true })
-    computedFields: publish<this, Array<ComputedField | MultiField>>;
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const cf of this.validComputedFields()) {
@@ -762,3 +755,38 @@ export class Mappings extends ProjectBase {
     }
 }
 Mappings.prototype._class += " Mappings";
+
+ComputedMapping.prototype.publish("value", null, "any", "Compare Value", undefined, {
+    validate: (w: ComputedMapping): boolean => (!w.value() && !w.newValue()) || (!!w.value() && !!w.newValue())
+});
+ComputedMapping.prototype.publish("newValue", null, "any", "New Value", undefined, {
+    validate: (w: ComputedMapping): boolean => (!w.value() && !w.newValue()) || (!!w.value() && !!w.newValue())
+});
+
+ComputedField.prototype.publish("label", null, "string", "Label", null, { optional: true });
+ComputedField.prototype.publish("type", "mapping", "set", "Project type", ["=", "*", "/", "+", "-", "scale", "template", "map"], { optional: true, disable: w => !w.label() });
+ComputedField.prototype.publish("column1", null, "set", "Param 1", function (this: ComputedField) { return this.columns(); }, {
+    optional: true,
+    disable: (w: ComputedField) => w.disableColumn1(),
+    validate: (w: ComputedField): boolean => w.columns().indexOf(w.column1()) >= 0
+});
+ComputedField.prototype.publish("column2", null, "set", "Param 2", function (this: ComputedField) { return this.columns(); }, {
+    optional: true,
+    disable: (w: ComputedField) => w.disableColumn2(),
+    validate: (w: ComputedField): boolean => w.columns().indexOf(w.column2()) >= 0
+});
+ComputedField.prototype.publish("constValue", null, "number", "Const value", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["scale"].indexOf(w.type()) < 0 });
+ComputedField.prototype.publish("template", null, "string", "template", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["template"].indexOf(w.type()) < 0 });
+ComputedField.prototype.publish("default", null, "any", "Default Value", null, { optional: true, disable: (w: ComputedField) => !w.label() || ["map"].indexOf(w.type()) < 0 });
+ComputedField.prototype.publish("mapping", [], "propertyArray", "Mapped Values", null, { autoExpand: ComputedMapping, disable: (w: ComputedField) => w.disableMapping() });
+ComputedField.prototype.publish("childField", [], "propertyArray", "Child Fields", null, { autoExpand: ComputedField, disable: (w: ComputedField) => w.disableChildField() });
+
+MultiField.prototype.publish("label", "", "string", "Label");
+MultiField.prototype.publish("multiFields", [], "propertyArray", "Multi Fields", null, { autoExpand: ComputedField });
+
+export interface ProjectBase {
+    computedFields(): Array<ComputedField | MultiField>;
+    computedFields(_: Array<ComputedField | MultiField>): this;
+}
+
+ProjectBase.prototype.publish("computedFields", [], "propertyArray", "Computed Fields", null, { autoExpand: ComputedField });

package/src/ddl2/activities/rest.ts

@@ -1,18 +1,15 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
+import { PropertyExt } from "@hpcc-js/common";
 import { createConnection } from "@hpcc-js/comms";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { AsyncOrderedQueue, compare, hashSum } from "@hpcc-js/util";
-import { Element, ElementContainer } from "../model/element";
-import { IActivityError, ReferencedFields } from "./activity";
-import { rowToFields } from "./databomb";
-import { Datasource, DatasourceRef } from "./datasource";
+import { Element, ElementContainer } from "../model/element.ts";
+import { IActivityError, ReferencedFields } from "./activity.ts";
+import { rowToFields } from "./databomb.ts";
+import { Datasource, DatasourceRef } from "./datasource.ts";
 
 export class RestField extends PropertyExt {
     protected _owner: RestService;
 
-    @publish("", "string", "RestField Label")
-    fieldID: publish<this, string>;
-
     constructor() {
         super();
     }
@@ -51,15 +48,6 @@ export class RestService extends Datasource {
 
     private _responseFields: { [outputID: string]: DDL2.IField[] } = {};
 
-    @publish("", "string", "REST Url")
-    url: publish<this, string>;
-    @publish("", "string", "Query Set")
-    action: publish<this, string>;
-    @publish("get", "set", "Request mode", ["get", "post"])
-    mode: publish<this, "get" | "post">;
-    @publish([], "propertyArray", "Multi Fields", null, { autoExpand: RestField })
-    requestFields: publish<this, RestField[]>;
-
     constructor(readonly _ec: ElementContainer) {
         super();
     }
@@ -153,22 +141,13 @@ RestService.prototype._class += " RestService";
 
 export class RestResult extends Datasource {
 
-    @publish(null, "widget", "Rest service")
-    _service: RestService = new RestService(this._ec);
-    service(): RestService;
-    service(_: RestService): this;
-    service(_?: RestService): this | RestService {
-        if (!arguments.length) return this._service;
-        this._service = _;
-        this._service.refreshMeta();
-        return this;
-    }
+    _origService;
 
-    @publish("", "string", "Result Name")
-    resultName: publish<this, string>;
+    declare _service: RestService;
 
     constructor(private _ec: ElementContainer) {
         super();
+        this._service = new RestService(this._ec);
     }
 
     validRequestFields(): RestField[] {
@@ -268,37 +247,6 @@ RestResult.prototype._class += " RestResult";
 
 export class Param extends PropertyExt {
 
-    @publish(null, "string", "Label")  //  TODO Add ReadOnly
-    localField: publish<this, string>;
-    localField_exists: () => boolean;
-    @publish(null, "set", "Activity", function (this: Param) { return this.visualizationIDs(); }, {
-        optional: true,
-        disable: (w: Param): boolean => w.value_exists(),
-        validate: (w: Param): boolean => w.source_disabled() || w.visualizationIDs().indexOf(w.source()) >= 0
-    })
-    source: publish<this, string>;
-    source_exists: () => boolean;
-    source_valid: () => boolean;
-    source_disabled: () => boolean;
-    @publish(null, "set", "Source Field", function (this: Param) { return this.sourceFields(); }, {
-        optional: true,
-        disable: (w: Param): boolean => !w.source_exists() || w.value_exists(),
-        validate: (w: Param): boolean => w.remoteField_disabled() || w.sourceFields().indexOf(w.remoteField()) >= 0
-    })
-    remoteField: publish<this, string>;
-    remoteField_exists: () => boolean;
-    remoteField_valid: () => boolean;
-    remoteField_disabled: () => boolean;
-    @publish(null, "string", "Static Value", null, {
-        optional: true,
-        disable: (w: Param): boolean => w.source_exists(),
-        validate: (w: Param): boolean => w.value_disabled() || w.value_exists()
-    })
-    value: publish<this, string>;
-    value_exists: () => boolean;
-    value_valid: () => boolean;
-    value_disabled: () => boolean;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.source_valid()) {
@@ -421,16 +369,6 @@ export class RestResultRef extends DatasourceRef {
         return this.datasource().resultName();
     }
 
-    @publish([], "propertyArray", "Request Fields")
-    _request: Param[];
-    request(): Param[];
-    request(_: Param[]): this;
-    request(_?: Param[]): Param[] | this {
-        if (!arguments.length) return this._request;
-        this._request = _;
-        return this;
-    }
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const filter of this.validParams()) {
@@ -566,3 +504,90 @@ export class RestResultRef extends DatasourceRef {
     }
 }
 RestResultRef.prototype._class += " RestResultRef";
+
+export interface RestField {
+    fieldID(): string;
+    fieldID(_: string): this;
+}
+
+RestField.prototype.publish("fieldID", "", "string", "RestField Label");
+
+export interface RestService {
+    url(): string;
+    url(_: string): this;
+    action(): string;
+    action(_: string): this;
+    mode(): "get" | "post";
+    mode(_: "get" | "post"): this;
+    requestFields(): RestField[];
+    requestFields(_: RestField[]): this;
+}
+
+RestService.prototype.publish("url", "", "string", "REST Url");
+RestService.prototype.publish("action", "", "string", "Query Set");
+RestService.prototype.publish("mode", "get", "set", "Request mode", ["get", "post"]);
+RestService.prototype.publish("requestFields", [], "propertyArray", "Multi Fields", null, { autoExpand: RestField });
+
+export interface RestResult {
+    service(): RestService;
+    service(_: RestService): this;
+    resultName(): string;
+    resultName(_: string): this;
+}
+
+RestResult.prototype.publish("service", null, "widget", "Rest service");
+RestResult.prototype.publish("resultName", "", "string", "Result Name");
+
+RestResult.prototype._origService = RestResult.prototype.service;
+RestResult.prototype.service = function (this: RestResult, _?) {
+    const retVal = RestResult.prototype._origService.apply(this, arguments);
+    if (_ !== undefined) {
+        this._service.refreshMeta();
+    }
+    return retVal;
+};
+
+export interface Param {
+    localField(): string;
+    localField(_: string): this;
+    localField_exists(): boolean;
+    source(): string;
+    source(_: string): this;
+    source_exists(): boolean;
+    source_valid(): boolean;
+    source_disabled(): boolean;
+    remoteField(): string;
+    remoteField(_: string): this;
+    remoteField_exists(): boolean;
+    remoteField_valid(): boolean;
+    remoteField_disabled(): boolean;
+    value(): string;
+    value(_: string): this;
+    value_exists(): boolean;
+    value_valid(): boolean;
+    value_disabled(): boolean;
+}
+
+Param.prototype.publish("localField", null, "string", "Label");
+Param.prototype.publish("source", null, "set", "Activity", function (this: Param) { return this.visualizationIDs(); }, {
+    optional: true,
+    disable: (w: Param): boolean => w.value_exists(),
+    validate: (w: Param): boolean => w.source_disabled() || w.visualizationIDs().indexOf(w.source()) >= 0
+});
+Param.prototype.publish("remoteField", null, "set", "Source Field", function (this: Param) { return this.sourceFields(); }, {
+    optional: true,
+    disable: (w: Param): boolean => !w.source_exists() || w.value_exists(),
+    validate: (w: Param): boolean => w.remoteField_disabled() || w.sourceFields().indexOf(w.remoteField()) >= 0
+});
+Param.prototype.publish("value", null, "string", "Static Value", null, {
+    optional: true,
+    disable: (w: Param): boolean => w.source_exists(),
+    validate: (w: Param): boolean => w.value_disabled() || w.value_exists()
+});
+
+export interface RestResultRef {
+    request(): Param[];
+    request(_: Param[]): this;
+}
+
+RestResultRef.prototype.publish("request", [], "propertyArray", "Request Fields");

package/src/ddl2/activities/roxie.ts

@@ -1,11 +1,10 @@
-import { publish } from "@hpcc-js/common";
 import { Query as CommsQuery } from "@hpcc-js/comms";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { AsyncOrderedQueue, compare, hashSum } from "@hpcc-js/util";
-import { ElementContainer } from "../model/element";
-import { IActivityError, ReferencedFields } from "./activity";
-import { Datasource, DatasourceRef } from "./datasource";
-import { Param } from "./rest";
+import { ElementContainer } from "../model/element.ts";
+import { IActivityError, ReferencedFields } from "./activity.ts";
+import { Datasource, DatasourceRef } from "./datasource.ts";
+import { Param } from "./rest.ts";
 
 function parseUrl(_: string): { url: string, querySet: string, queryID: string } {
     // "http://10.241.100.157:8002/WsEcl/submit/query/roxie/carmigjx_govbisgsavi.Ins4621360_Service_00000006/json",
@@ -38,17 +37,6 @@ export class RoxieService extends Datasource {
     private _responseFields: { [outputID: string]: DDL2.IField[] } = {};
     private _type: "roxie" | "hipie" = "roxie";
 
-    @publish("", "string", "ESP Url (http://x.x.x.x:8002)")
-    url: publish<this, string>;
-    @publish("", "string", "Query Set")
-    querySet: publish<this, string>;
-    @publish("", "string", "Query ID")
-    queryID: publish<this, string>;
-    @publish(false, "boolean", "Ignore provided DDL request")
-    ignoreHipieRequest: publish<this, boolean>;
-    @publish(false, "boolean", "Ignore provided DDL response")
-    ignoreHipieResponse: publish<this, boolean>;
-
     constructor(private _ec: ElementContainer) {
         super();
     }
@@ -178,26 +166,34 @@ export class RoxieService extends Datasource {
 }
 RoxieService.prototype._class += " RoxieService";
 
+export interface RoxieService {
+    url(): string;
+    url(_: string): this;
+    querySet(): string;
+    querySet(_: string): this;
+    queryID(): string;
+    queryID(_: string): this;
+    ignoreHipieRequest(): boolean;
+    ignoreHipieRequest(_: boolean): this;
+    ignoreHipieResponse(): boolean;
+    ignoreHipieResponse(_: boolean): this;
+}
+
+RoxieService.prototype.publish("url", "", "string", "ESP Url (http://x.x.x.x:8002)");
+RoxieService.prototype.publish("querySet", "", "string", "Query Set");
+RoxieService.prototype.publish("queryID", "", "string", "Query ID");
+RoxieService.prototype.publish("ignoreHipieRequest", false, "boolean", "Ignore provided DDL request");
+RoxieService.prototype.publish("ignoreHipieResponse", false, "boolean", "Ignore provided DDL response");
+
 export class RoxieResult extends Datasource {
 
-    @publish(null, "widget", "Roxie service")
-    _service: RoxieService = new RoxieService(this._ec);
-    service(): RoxieService;
-    service(_: RoxieService): this;
-    service(_?: RoxieService): this | RoxieService {
-        if (!arguments.length) return this._service;
-        this._service = _;
-        this._service.refreshMeta();
-        return this;
-    }
+    _origService;
 
-    @publish("", "set", "Result Name", function (this: RoxieResult): string[] {
-        return this._service !== undefined ? this._service.resultNames() : [];
-    })
-    resultName: publish<this, string>;
+    declare _service: RoxieService;
 
     constructor(private _ec: ElementContainer) {
         super();
+        this._service = new RoxieService(this._ec);
     }
 
     toDDL(): DDL2.IRoxieService | DDL2.IHipieService {
@@ -263,6 +259,27 @@ export class RoxieResult extends Datasource {
 }
 RoxieResult.prototype._class += " RoxieResult";
 
+export interface RoxieResult {
+    service(): RoxieService;
+    service(_: RoxieService): this;
+    resultName(): string;
+    resultName(_: string): this;
+}
+
+RoxieResult.prototype.publish("service", null, "widget", "Roxie service");
+RoxieResult.prototype.publish("resultName", "", "set", "Result Name", function (this: RoxieResult): string[] {
+    return this._service !== undefined ? this._service.resultNames() : [];
+});
+
+RoxieResult.prototype._origService = RoxieResult.prototype.service;
+RoxieResult.prototype.service = function (this: RoxieResult, _?) {
+    const retVal = RoxieResult.prototype._origService.apply(this, arguments);
+    if (_ !== undefined) {
+        this._service.refreshMeta();
+    }
+    return retVal;
+};
+
 export class RoxieResultRef extends DatasourceRef {
 
     serviceID(): string {
@@ -293,16 +310,6 @@ export class RoxieResultRef extends DatasourceRef {
         return this.datasource().resultName();
     }
 
-    @publish([], "propertyArray", "Request Fields")
-    _request: Param[];
-    request(): Param[];
-    request(_: Param[]): this;
-    request(_?: Param[]): Param[] | this {
-        if (!arguments.length) return this._request;
-        this._request = _;
-        return this;
-    }
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const filter of this.validParams()) {
@@ -467,6 +474,13 @@ export class RoxieResultRef extends DatasourceRef {
 }
 RoxieResultRef.prototype._class += " RoxieResultRef";
 
+export interface RoxieResultRef {
+    request(): Param[];
+    request(_: Param[]): this;
+}
+
+RoxieResultRef.prototype.publish("request", [], "propertyArray", "Request Fields");
+
 export class HipieResultRef extends RoxieResultRef {
 
     fullUrl(_: string): this {
@@ -487,4 +501,4 @@ export class HipieResultRef extends RoxieResultRef {
         return request;
     }
 }
-HipieResultRef.prototype._class += " HipieResultRef";
+HipieResultRef.prototype._class += " HipieResultRef";

package/src/ddl2/activities/sort.ts

@@ -1,21 +1,12 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
+import { PropertyExt } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { hashSum } from "@hpcc-js/util";
 import { ascending as d3Ascending, descending as d3Descending } from "d3-array";
-import { Activity, IActivityError, ReferencedFields } from "./activity";
+import { Activity, IActivityError, ReferencedFields } from "./activity.ts";
 
 export class SortColumn extends PropertyExt {
     private _owner: Sort;
 
-    @publish(null, "set", "Sort Field", function (this: SortColumn) { return this.fieldIDs(); }, {
-        optional: true,
-        validate: (w: SortColumn): boolean => w.fieldIDs().indexOf(w.fieldID()) >= 0
-    })
-    fieldID: publish<this, string>;
-    fieldID_valid: () => boolean;
-    @publish(false, "boolean", "Sort Field")
-    descending: publish<this, boolean>;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.fieldID_valid()) {
@@ -81,13 +72,18 @@ export class SortColumn extends PropertyExt {
 }
 SortColumn.prototype._class += " SortColumn";
 
+export interface SortColumn {
+    fieldID(): string;
+    fieldID(_: string): this;
+    fieldID_valid(): boolean;
+    descending(): boolean;
+    descending(_: boolean): this;
+}
+
 //  ===========================================================================
 export class Sort extends Activity {
     static Column = SortColumn;
 
-    @publish([], "propertyArray", "Source Columns", null, { autoExpand: SortColumn })
-    column: publish<this, SortColumn[]>;
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const sb of this.validSortBy()) {
@@ -174,3 +170,16 @@ export class Sort extends Activity {
     }
 }
 Sort.prototype._class += " Sort";
+
+export interface Sort {
+    column(): SortColumn[];
+    column(_: SortColumn[]): this;
+}
+
+SortColumn.prototype.publish("fieldID", null, "set", "Sort Field", function (this: SortColumn) { return this.fieldIDs(); }, {
+        optional: true,
+        validate: (w: SortColumn): boolean => w.fieldIDs().indexOf(w.fieldID()) >= 0
+    });
+SortColumn.prototype.publish("descending", false, "boolean", "Sort Field");
+
+Sort.prototype.publish("column", [], "propertyArray", "Source Columns", null, { autoExpand: SortColumn });