@jd-data-limited/easy-fm 4.0.11 → 4.0.12

package/src/records/getOperations/recordGetOperation.ts

@@ -11,6 +11,9 @@ import {FMError} from "../../FMError.js";
 import {FindRequestSymbol, Query} from "../../utils/query.js";
 
 export type SortOrder = "ascend" | "descend"
+export type FindRequestRaw = {
+    [key: string]: string
+}
 export type FindRequest = {
     [key: string]: Query
 }
@@ -38,7 +41,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
     protected sortData: { fieldName: string, sortOrder: SortOrder }[] = []
     protected portals: Partial<PortalData<T>>
     protected offset: number = 1
-    protected queries: {req: FindRequest, omit: boolean}[] = []
+    protected queries: {req: FindRequestRaw, omit: boolean}[] = []
 
     constructor(layout: LayoutBase, options: OPTIONS) {
         this.layout = layout
@@ -53,21 +56,23 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
     }
 
     private formatQueries() {
-        return this.queries.map(query => {
+        let test = this.queries.map(query => {
             let out: any = {}
             for (let key of Object.keys(query.req)) {
-                if (query.req[key][FindRequestSymbol]) out[key] = query.req[key][FindRequestSymbol]
+                if (query.req[key]) out[key] = query.req[key]
                 else {out[key] = query.req[key]}
             }
             if (query.omit) out.omit = "true"
             return out
         })
+        return test
     }
 
     protected generateParamsBody(offset: number, limit: number) {
         const params: {[key: string]: any} = {
             limit: limit.toString(),
             offset: offset.toString(),
+            dateformats: 2 // Ensure dates are received in ISO8601 format
         }
         if (this.sortData.length !== 0) params.sort = this.sortData
 
@@ -96,6 +101,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
         const params = new URLSearchParams({
             _limit: limit.toString(),
             _offset: offset.toString(),
+            dateformats: "2" // Ensure dates are received in ISO8601 format
         })
         if (this.sortData.length !== 0) params.set("_sort", JSON.stringify(this.sortData))
 
@@ -128,8 +134,24 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
         return this
     }
 
+    private parseFindRequest<I extends FindRequest>(query: I): {[key in keyof I]: string} {
+        let out: any = {}
+        for (let key of Object.keys(query)) {
+            out[key] = query[key][FindRequestSymbol].map(item => {
+                if (typeof item === "string") return item
+
+                // Re-write date into correct format
+                return item
+                    .clone()
+                    .utcOffset(this.layout.database.host.timezoneOffset)
+                    .format("MM/DD/YYYY HH:mm:ss")
+            }).join("")
+        }
+        return out
+    }
+
     addRequest(query: FindRequest, omit = false) {
-        this.queries.push({req: query, omit})
+        this.queries.push({req: this.parseFindRequest(query), omit})
         return this
     }
 

package/src/records/layoutRecord.d.ts

@@ -6,7 +6,7 @@ import { LayoutInterface } from "../layouts/layoutInterface.js";
 import { LayoutRecordBase } from "./layoutRecordBase.js";
 import { ApiPortalData, ApiRowDataDef } from "../models/apiResults.js";
 import { LayoutBase } from "../layouts/layoutBase.js";
-import { FieldBase, FieldValue } from "./fieldBase.js";
+import { Field, FieldValue } from "./field.js";
 export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
     portals: LAYOUT["portals"];
     private readonly portalsToInclude;
@@ -17,6 +17,6 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
     get(): Promise<this>;
     duplicate(): Promise<LayoutRecord<LAYOUT>>;
     delete(): Promise<void>;
-    fieldsToObject(filter?: (a: FieldBase<FieldValue>) => boolean): Omit<ApiRowDataDef, "portalData">;
-    toObject(filter?: (a: FieldBase<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<never>) => any, portalFieldFilter?: (a: FieldBase<FieldValue>) => any): ApiRowDataDef;
+    fieldsToObject(filter?: (a: Field<FieldValue>) => boolean): Omit<ApiRowDataDef, "portalData">;
+    toObject(filter?: (a: Field<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<never>) => any, portalFieldFilter?: (a: Field<FieldValue>) => any): ApiRowDataDef;
 }

package/src/records/layoutRecord.js

@@ -186,7 +186,7 @@ export class LayoutRecord extends RecordBase {
     toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
         let obj = {
             ...this.fieldsToObject(filter),
-            portalData: {}
+            portalData: {},
         };
         // Check if there's been any edited portal information
         let portals = this.portalsArray.filter(a => portalFilter(a));

package/src/records/layoutRecord.ts

@@ -11,8 +11,8 @@ import {FMError} from "../FMError.js";
 import {LayoutRecordBase} from "./layoutRecordBase.js";
 import {ApiFieldData, ApiPortalData, ApiRecordResponseObj, ApiRowDataDef} from "../models/apiResults.js";
 import {LayoutBase} from "../layouts/layoutBase.js"
-import {FieldBase, FieldValue} from "./fieldBase.js";
 import * as moment from "moment/moment.js";
+import {Field, FieldValue} from "./field.js";
 
 export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
     // @ts-ignore
@@ -182,9 +182,9 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
         }
     }
 
-    fieldsToObject(filter = (a: FieldBase<FieldValue>) => a.edited): Omit<ApiRowDataDef, "portalData"> {
+    fieldsToObject(filter = (a: Field<FieldValue>) => a.edited): Omit<ApiRowDataDef, "portalData"> {
         let fields_processed: ApiFieldData = {}
-        let field: FieldBase<FieldValue>
+        let field: Field<FieldValue>
         for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value as string | number | Date
             if (value instanceof Date) {
@@ -216,14 +216,14 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
     }
 
     toObject(
-        filter: (a: FieldBase<FieldValue>) => any = (a) => a.edited,
+        filter: (a: Field<FieldValue>) => any = (a) => a.edited,
         portalFilter: (a: Portal<any>) => any = (a) => a.records.find(record => record.edited),
         portalRowFilter: (a: PortalRecord<never>) => any = (a) => a.edited,
-        portalFieldFilter: (a: FieldBase<FieldValue>) => any = (a) => a.edited
+        portalFieldFilter: (a: Field<FieldValue>) => any = (a) => a.edited
     ) {
         let obj: ApiRowDataDef = {
             ...this.fieldsToObject(filter),
-            portalData: {}
+            portalData: {},
         };
 
         // Check if there's been any edited portal information

package/src/records/portalRecord.d.ts

@@ -2,14 +2,14 @@ import { RecordBase } from "./recordBase.js";
 import { extraBodyOptions, RecordTypes } from "../types.js";
 import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
 import { PortalBase } from "./portalBase.js";
-import { FieldBase, FieldValue } from "./fieldBase.js";
+import { Field, FieldValue } from "./field.js";
 export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
     readonly type = RecordTypes.PORTAL;
     constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {});
     _onSave(): void;
     commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../index.js").LayoutInterface>>;
-    toObject(fieldFilter: (a: FieldBase<FieldValue>) => boolean): {
+    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
         modId?: string;
         recordId?: string;
     } & {

package/src/records/portalRecord.ts

@@ -7,7 +7,7 @@ import {extraBodyOptions, RecordTypes} from "../types.js";
 
 import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
 import {PortalBase} from "./portalBase.js";
-import {FieldBase, FieldValue} from "./fieldBase.js";
+import {Field, FieldValue} from "./field.js";
 
 export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
@@ -27,7 +27,7 @@ export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
         return this.portal.record.commit(extraBody)
     }
 
-    toObject(fieldFilter: (a: FieldBase<FieldValue>) => boolean): {
+    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
         modId?: string,
         recordId?: string,
     } & {[key: string]: string} {

package/src/records/recordBase.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from "events";
-import { FieldBase, FieldValue } from "./fieldBase.js";
 import { RecordTypes } from "../types.js";
 import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
 import { LayoutBase } from "../layouts/layoutBase.js";
 import { ApiFieldData } from "../models/apiResults.js";
+import { Field, FieldValue } from "./field.js";
 export declare abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
     readonly type: RecordTypes;
@@ -15,7 +15,7 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
     protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: ApiFieldData);
     get endpoint(): string;
     get edited(): boolean;
-    get fieldsArray(): FieldBase<FieldValue>[];
+    get fieldsArray(): Field<FieldValue>[];
     protected processFieldData(fieldData: ApiFieldData): T;
     _onSave(): void;
 }

package/src/records/recordBase.js

@@ -3,8 +3,8 @@
  */
 import { EventEmitter } from "events";
 import * as moment from "moment";
-import { FieldBase } from "./fieldBase.js";
 import { RecordTypes } from "../types.js";
+import { Field } from "./field.js";
 export class RecordBase extends EventEmitter {
     layout;
     type = RecordTypes.UNKNOWN;
@@ -31,14 +31,14 @@ export class RecordBase extends EventEmitter {
     processFieldData(fieldData) {
         let fields = {};
         for (let key of Object.keys(fieldData)) {
-            let _field = new FieldBase(this, key, fieldData[key]);
+            let _field = new Field(this, key, fieldData[key]);
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "time") {
@@ -46,7 +46,7 @@ export class RecordBase extends EventEmitter {
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "date") {
@@ -54,7 +54,7 @@ export class RecordBase extends EventEmitter {
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
             }

package/src/records/recordBase.ts

@@ -4,11 +4,12 @@
 
 import {EventEmitter} from "events";
 import * as moment from "moment";
-import {FieldBase, FieldValue} from "./fieldBase.js";
+import {Moment} from "moment";
 import {RecordTypes} from "../types.js";
 import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
 import {LayoutBase} from "../layouts/layoutBase.js";
 import {ApiFieldData} from "../models/apiResults.js";
+import {Field, FieldValue} from "./field.js";
 
 export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
@@ -34,7 +35,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
         return !!this.fieldsArray.find(i => i.edited)
     }
 
-    get fieldsArray(): FieldBase<FieldValue>[] {
+    get fieldsArray(): Field<FieldValue>[] {
         return Object.values(this.fields)
     }
 
@@ -42,14 +43,14 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
         let fields: RecordFieldsMap = {}
 
         for (let key of Object.keys(fieldData)) {
-            let _field = new FieldBase(this, key, fieldData[key])
+            let _field = new Field<number | string | Moment>(this, key, fieldData[key])
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
 
                 }
@@ -58,7 +59,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
                 }
                 else if (_field.metadata.result === "date") {
@@ -66,7 +67,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
                 }
             }

package/src/utils/query.d.ts

@@ -1,10 +1,9 @@
+import { Moment } from "moment";
 export declare const FindRequestSymbol: unique symbol;
-type QueryParameter = string | number | Date;
+type QueryParameter = string | number | Moment;
 export type Query = {
-    [FindRequestSymbol]: string;
+    [FindRequestSymbol]: (string | Moment)[];
 };
 export declare function queryEscape(str: string): string;
-export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): {
-    [FindRequestSymbol]: string;
-};
+export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query;
 export {};

package/src/utils/query.js

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
+import moment from "moment/moment.js";
 export const FindRequestSymbol = Symbol("easyfm-findrequest");
 const SPECIAL_CHARACTERS = ["\\", "=", "<", "≤", "≥", ">", "…", "...", "//", "@", "#", "*", "\"", "~"];
 export function queryEscape(str) {
@@ -11,11 +12,17 @@ export function queryEscape(str) {
 }
 export function query(strings, ...args) {
     let argStrings = args.map(item => {
-        return queryEscape(item.toString());
+        if (moment.isMoment(item))
+            return item;
+        else if (typeof item === "number") {
+            return queryEscape(item.toString());
+        }
+        else
+            return queryEscape(item);
     });
     // Zip the parameters together
     const query = strings.map((str, index) => {
-        return str + (argStrings[index] || '');
-    });
-    return { [FindRequestSymbol]: query.join("") };
+        return [str, (argStrings[index] || '')];
+    }).flat(1);
+    return { [FindRequestSymbol]: query };
 }

package/src/utils/query.ts

@@ -2,10 +2,13 @@
  * Copyright (c) 2024. See LICENSE file for more information
  */
 
+import {Moment} from "moment";
+import moment from "moment/moment.js";
+
 export const FindRequestSymbol = Symbol("easyfm-findrequest");
 const SPECIAL_CHARACTERS = ["\\", "=", "<", "≤", "≥", ">", "…", "...", "//", "@", "#", "*", "\"", "~"]
-type QueryParameter = string | number | Date
-export type Query = {[FindRequestSymbol]: string}
+type QueryParameter = string | number | Moment
+export type Query = {[FindRequestSymbol]: (string | Moment)[]}
 
 export function queryEscape(str: string) {
     for (let char of SPECIAL_CHARACTERS) {
@@ -14,14 +17,18 @@ export function queryEscape(str: string) {
     return str
 }
 
-export function query(strings: TemplateStringsArray, ...args: QueryParameter[]) {
+export function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query {
     let argStrings = args.map(item => {
-        return queryEscape(item.toString())
+        if (moment.isMoment(item)) return item
+        else if (typeof item === "number") {
+            return queryEscape(item.toString())
+        }
+        else return queryEscape(item)
     })
 
     // Zip the parameters together
     const query = strings.map((str, index) => {
-        return str + (argStrings[index] || '')
-    })
-    return {[FindRequestSymbol]: query.join("")}
+        return [str, (argStrings[index] || '')]
+    }).flat(1)
+    return {[FindRequestSymbol]: query}
 }

package/src/records/fieldBase.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import * as http from "http";
-import { ContainerBufferResult, DownloadModes, RecordTypes } from "../types.js";
-import { ApiFieldMetadata } from "../models/apiResults.js";
-import { LayoutBase } from "../layouts/layoutBase.js";
-export type FieldValue = string | number | Date | Container;
-export type Container = null;
-export type Parentable = {
-    layout: LayoutBase;
-    type: RecordTypes;
-    endpoint: string;
-};
-export declare class FieldBase<T extends FieldValue> {
-    parent: Parentable;
-    id: string;
-    protected _value: T;
-    edited: boolean;
-    constructor(record: Parentable, id: string, contents: T);
-    set(content: string | number | Date | undefined | null): void;
-    get metadata(): ApiFieldMetadata;
-    get value(): T;
-    set value(value: T);
-    get string(): string;
-    get date(): Date;
-    get number(): number;
-    upload(buffer: Buffer, filename: string, mime: string): Promise<void>;
-    download(mode: DownloadModes.Stream): Promise<http.IncomingMessage>;
-    download(mode: DownloadModes.Buffer): Promise<ContainerBufferResult>;
-}

package/src/records/fieldBase.js

@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-import { DownloadModes, RecordTypes } from "../types.js";
-import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
-export class FieldBase {
-    parent;
-    id;
-    _value;
-    edited;
-    constructor(record, id, contents) {
-        this.parent = record;
-        this.id = id;
-        this._value = contents;
-        this.edited = false;
-    }
-    set(content) {
-        if (this.metadata.result === "container")
-            throw "Cannot set container value using set(). Use upload() instead.";
-        if ((this.metadata.result === "timeStamp" ||
-            this.metadata.result === "date" ||
-            this.metadata.result === "time")
-            && !(content instanceof Date) && !!content) {
-            throw "Value was not an instance of Date: " + content;
-        }
-        // @ts-ignore
-        if (!content)
-            this._value = "";
-        // @ts-ignore
-        else
-            this._value = content;
-        this.edited = true;
-    }
-    get metadata() {
-        if (!this.parent.layout.metadata) {
-            // Default to a regular text field
-            return {
-                name: this.id.toString(),
-                type: ApiFieldTypes.NORMAL,
-                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                result: ApiFieldResultTypes.TEXT,
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitions: 1,
-                valueList: ""
-            };
-        }
-        if (this.parent.type === RecordTypes.PORTAL) {
-            // @ts-ignore
-            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || "portal not attached"].find(i => i.name === this.id) || {
-                name: this.id.toString(),
-                type: 'normal',
-                displayType: 'editText',
-                result: 'text',
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitionStart: 1,
-                repetitionEnd: 1
-            };
-        }
-        else {
-            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
-                name: this.id.toString(),
-                type: ApiFieldTypes.NORMAL,
-                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                result: ApiFieldResultTypes.TEXT,
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitions: 1,
-                valueList: ""
-            };
-        }
-    }
-    get value() {
-        // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get string() {
-        if (typeof this._value === "string") {
-            return this._value;
-        }
-        throw "Field value is not a string";
-    }
-    get date() {
-        if (this._value instanceof Date) {
-            return this._value;
-        }
-        throw "Field value is not a date";
-    }
-    get number() {
-        if (typeof this._value === "number") {
-            return this._value;
-        }
-        throw "Field value is not a number";
-    }
-    async upload(buffer, filename, mime) {
-        let trace = new Error();
-        if (this.metadata.result !== "container")
-            throw "Cannot upload a file to the field; " + this.id + " (not a container field)";
-        let form = new FormData();
-        form.append("upload", new File([buffer], filename, { type: mime }));
-        let res = await this.parent.layout.database.apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
-            method: "POST",
-            // @ts-ignore
-            body: form
-        });
-        if (!res.ok)
-            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
-    }
-    async download(mode = DownloadModes.Stream) {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
-            throw new Error("Cannot perform download() on a non-container field");
-        let stream = await this.parent.layout.database.streamURL(this.string);
-        if (mode === DownloadModes.Stream) {
-            return stream;
-        }
-        let body = [];
-        return new Promise((resolve, reject) => {
-            stream.on("data", chunk => {
-                body.push(chunk);
-            });
-            stream.on("error", (e) => {
-                reject(e);
-            });
-            stream.on("end", () => {
-                resolve({
-                    buffer: Buffer.concat(body),
-                    mime: stream.headers["content-type"],
-                    request: stream
-                });
-            });
-        });
-    }
-}

package/src/records/getOperations/find.d.ts

@@ -1,15 +0,0 @@
-import { RecordGetOperation } from "./recordGetOperation.js";
-import { LayoutRecord } from "../layoutRecord.js";
-import { LayoutInterface } from "../../layouts/layoutInterface";
-import { LayoutBase } from "../../layouts/layoutBase.js";
-export declare class Find<T extends LayoutInterface> extends RecordGetOperation<T> {
-    protected queries: object[];
-    constructor(layout: LayoutBase, start?: number, limit?: number);
-    private toObject;
-    addRequests(...requests: any[]): this;
-    /**
-     * @deprecated in favour of .fetch()
-     */
-    run(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
-    fetch(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
-}