nesoi 3.4.14 → 3.4.16

package/lib/elements/entities/bucket/view/bucket_view.js

@@ -38,7 +38,9 @@ class BucketView {
         if ('__root' in this.schema.fields || '__parent' in this.schema.fields || '__value' in this.schema.fields) {
             Object.assign(parsed, root);
         }
-        let layer = Object.values(this.schema.fields).map(field => ({
+        let layer = Object.values(this.schema.fields)
+            .sort((a, b) => a.idx - b.idx)
+            .map(field => ({
             bucket: meta,
             field,
             data: [{
@@ -102,12 +104,6 @@ class BucketView {
                 continue;
             next.push(...this.parseModelProp(node, flags));
         }
-        // Computed props
-        for (const node of layer) {
-            if (node.field.scope !== 'computed')
-                continue;
-            await this.parseComputedProp(trx, node);
-        }
         // Graph props
         for (const node of layer) {
             if (node.field.scope !== 'graph')
@@ -131,12 +127,20 @@ class BucketView {
                     d.target[d.key] = d.value;
                 }
             }
-            next.push(...Object.values(node.field.children).map(field => ({
+            next.push(...Object.values(node.field.children)
+                .sort((a, b) => a.idx - b.idx)
+                .map(field => ({
                 bucket: node.bucket,
                 field,
                 data: node.data
             })));
         }
+        // Computed props
+        for (const node of layer) {
+            if (node.field.scope !== 'computed')
+                continue;
+            await this.parseComputedProp(trx, node);
+        }
         // Exclude eventual nodes without data
         next = next.filter(node => node.data.length);
         return next;
@@ -197,7 +201,9 @@ class BucketView {
         const next = [];
         // Add children (subview) to queue
         if (node.field.children) {
-            for (const key in node.field.children) {
+            const children = Object.entries(node.field.children)
+                .sort((a, b) => a[1].idx - b[1].idx);
+            for (const [key, field] of children) {
                 if (key === '__root')
                     continue;
                 if (key === '__parent')
@@ -206,10 +212,10 @@ class BucketView {
                     continue;
                 next.push({
                     bucket: node.bucket,
-                    field: node.field.children[key],
+                    field: field,
                     data: nextData.map(d => ({
                         ...d,
-                        key: d.key ?? node.field.children[key].name
+                        key: d.key ?? field.name
                     }))
                 });
             }
@@ -370,7 +376,7 @@ class BucketView {
     async parseComputedProp(trx, node) {
         const meta = node.field.meta.computed;
         for (const entry of node.data) {
-            entry.target[entry.key] = await promise_1.default.solve(meta.fn({ trx, root: entry.root, parent: entry.parent, value: entry.value, bucket: node.bucket.schema }));
+            entry.target[entry.key] = await promise_1.default.solve(meta.fn({ trx, root: entry.root, parent: entry.parent, value: entry.value, bucket: node.bucket.schema, target: entry.target }));
         }
     }
     /**
@@ -502,7 +508,7 @@ class BucketView {
             // const bucket = await Daemon.getBucketMetadata(module.daemon!, otherBucketDep);
             // Next data is empty if meta.prop is defined, since there's no need to go deeper
             if (nextData.length) {
-                for (const field of Object.values(v)) {
+                for (const field of Object.values(v).sort((a, b) => a.idx - b.idx)) {
                     next.push({
                         bucket: otherBucket,
                         field,
@@ -564,7 +570,9 @@ class BucketView {
             const module = trx_node_1.TrxNode.getModule(trx);
             const subview_bucket = daemon_1.Daemon.getBucketMetadata(module.daemon, link.bucket);
             // Add subview data to queue
-            for (const key in node.field.children) {
+            const children = Object.entries(node.field.children)
+                .sort((a, b) => a[1].idx - b[1].idx);
+            for (const [key, field] of children) {
                 if (key === '__root')
                     continue;
                 if (key === '__parent')
@@ -573,14 +581,14 @@ class BucketView {
                     continue;
                 next.push({
                     bucket: subview_bucket,
-                    field: node.field.children[key],
+                    field: field,
                     data: subview_data.map(data => ({
                         root: data.root,
                         parent: data.value,
                         index: [],
                         value: data.value,
                         target: data.target,
-                        key: node.field.children[key].name
+                        key: field.name
                     }))
                 });
             }

package/lib/elements/entities/bucket/view/bucket_view.schema.d.ts

@@ -6,6 +6,7 @@ export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket, Pa
     parent: Parent;
     value: Value;
     bucket: $Bucket;
+    target: Record<string, any>;
 }) => any | Promise<any>;
 export type $BucketViewFieldMeta = {
     model?: {
@@ -39,9 +40,10 @@ export declare class $BucketViewField {
     children?: $BucketViewFields | undefined;
     chain?: $BucketViewField | undefined;
     as_dict?: number[] | undefined;
+    idx: number;
     $t: string;
     '#data': unknown;
-    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, prop?: string | undefined, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined, as_dict?: number[] | undefined);
+    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, prop?: string | undefined, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined, as_dict?: number[] | undefined, idx?: number);
 }
 export type $BucketViewFields = {
     [x: string]: $BucketViewField;

package/lib/elements/entities/bucket/view/bucket_view.schema.js

@@ -14,9 +14,10 @@ class $BucketViewField {
     children;
     chain;
     as_dict;
+    idx;
     $t = 'bucket.view.field';
     '#data';
-    constructor(name, scope, alias, meta, prop, children, chain, as_dict) {
+    constructor(name, scope, alias, meta, prop, children, chain, as_dict, idx = 0) {
         this.name = name;
         this.scope = scope;
         this.alias = alias;
@@ -25,6 +26,7 @@ class $BucketViewField {
         this.children = children;
         this.chain = chain;
         this.as_dict = as_dict;
+        this.idx = idx;
     }
 }
 exports.$BucketViewField = $BucketViewField;

package/lib/elements/entities/bucket/view/bucket_view_field.builder.d.ts

@@ -48,6 +48,7 @@ export declare class BucketViewFieldBuilder<Module extends $Module, Bucket exten
     protected _prop?: string;
     protected _chain?: ($: BucketViewFieldFactory<any, Module, Bucket>) => BucketViewFieldBuilder<Module, Bucket, any, any, any>;
     protected _as_dict?: number[];
+    protected _idx: number;
     constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, subview?: (BucketViewFieldBuilders<any> | BucketViewDef<any, any, any>) | undefined);
     prop<Obj extends Data extends any[] ? Data[number] : Data, K extends keyof Obj>(prop: K): BucketViewFieldBuilder<Module, Bucket, ChainBucket, Obj[K], Scope, GraphLink>;
     map<Def extends BucketViewDef<any, Module, ChainBucket>>(def: Def): BucketViewFieldBuilder<Module, Bucket, ChainBucket, { [K in keyof Def]: Def extends BucketViewFieldBuilder<any, any, infer X, any, any> ? X : never; }, Scope, GraphLink>;
@@ -58,6 +59,7 @@ export declare class BucketViewFieldBuilder<Module extends $Module, Bucket exten
     } : {
         [x: string]: Data;
     }, Scope, GraphLink>;
+    order(idx: number): this;
     static build(builder: BucketViewFieldBuilder<any, any, any, any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number, tree?: ModuleTree): $BucketViewField;
     static buildFields(fields: BucketViewFieldBuilders<any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number, tree?: ModuleTree): $BucketViewFields;
 }

package/lib/elements/entities/bucket/view/bucket_view_field.builder.js

@@ -117,6 +117,7 @@ class BucketViewFieldBuilder {
     _prop;
     _chain;
     _as_dict;
+    _idx = 0;
     constructor(scope, meta, subview) {
         this.scope = scope;
         this.meta = meta;
@@ -169,6 +170,10 @@ class BucketViewFieldBuilder {
         this._as_dict = indexes ?? [-1];
         return this;
     }
+    order(idx) {
+        this._idx = idx;
+        return this;
+    }
     // Build
     static build(builder, model, graph, views, name, n_indexes, tree) {
         let children = undefined;
@@ -240,7 +245,7 @@ class BucketViewFieldBuilder {
             const subview = builder._chain(factory);
             chain = BucketViewFieldBuilder.build(subview, model, graph, views, name, n_indexes + spread_n, tree);
         }
-        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, builder._prop, children, chain, builder._as_dict);
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, builder._prop, children, chain, builder._as_dict, builder._idx);
     }
     static buildFields(fields, model, graph, views, n_indexes = 0, tree) {
         const schema = {};

package/lib/elements/entities/message/template/message_template.schema.d.ts

@@ -36,6 +36,7 @@ export type $MessageTemplateFieldMeta = {
     msg?: {
         tag: Tag;
     };
+    custom?: Record<string, any>;
 };
 export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_number' | 'id' | 'msg';
 /**

package/lib/elements/entities/message/template/message_template_field.builder.d.ts

@@ -61,7 +61,7 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
  * */
 export declare class MessageTemplateFieldBuilder<Module extends $Module, Message extends $Message, Input, Output, Children extends MessageTemplateFieldBuilders, Optional = [false, false], InputSuffix extends string = ''> {
     private type;
-    private meta;
+    private _meta;
     private alias?;
     private children?;
     '#input': Input;
@@ -73,7 +73,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     private _nullable;
     private _rawName?;
     private _rules;
-    constructor(type: $MessageTemplateFieldType, meta: Omit<$MessageTemplateFieldMeta, 'enum' | 'msg' | 'id'> & {
+    constructor(type: $MessageTemplateFieldType, _meta: Omit<$MessageTemplateFieldMeta, 'enum' | 'msg' | 'id'> & {
         enum?: {
             options: Record<string, any>;
         } | {
@@ -100,6 +100,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     get nullable(): MessageTemplateFieldBuilder<Module, Message, Input | null, Output | null, Children, Optional, InputSuffix>;
     rule(rule: MessageTemplateRuleDef<Output, Message['#raw']>): this;
     rawName(name: string): this;
+    meta(data: Record<string, any>): this;
     static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePathRaw: string, basePathParsed: string): $MessageTemplateField;
     static buildMany(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePathRaw?: string, basePathParsed?: string, name?: string, key?: string): $MessageTemplateFields;
 }

package/lib/elements/entities/message/template/message_template_field.builder.js

@@ -128,7 +128,7 @@ exports.MessageTemplateFieldFactory = MessageTemplateFieldFactory;
  * */
 class MessageTemplateFieldBuilder {
     type;
-    meta;
+    _meta;
     alias;
     children;
     '#input';
@@ -140,9 +140,9 @@ class MessageTemplateFieldBuilder {
     _nullable = false;
     _rawName;
     _rules = [];
-    constructor(type, meta, alias, children) {
+    constructor(type, _meta, alias, children) {
         this.type = type;
-        this.meta = meta;
+        this._meta = _meta;
         this.alias = alias;
         this.children = children;
     }
@@ -171,6 +171,11 @@ class MessageTemplateFieldBuilder {
         this._rawName = name;
         return this;
     }
+    meta(data) {
+        this._meta.custom ??= {};
+        Object.assign(this._meta.custom, data);
+        return this;
+    }
     // Build
     static build(builder, name, tree, module, basePathRaw, basePathParsed) {
         const pathRaw = basePathRaw +
@@ -181,14 +186,14 @@ class MessageTemplateFieldBuilder {
         let type = builder.type;
         let children;
         if (builder.type === 'id') {
-            const bucket = dependency_1.Tag.resolve(builder.meta.id.bucket.tag, tree);
-            builder.meta.id.type = bucket.model.fields.id.type;
-            builder.meta.id.bucket = builder.meta.id.bucket.tag;
+            const bucket = dependency_1.Tag.resolve(builder._meta.id.bucket.tag, tree);
+            builder._meta.id.type = bucket.model.fields.id.type;
+            builder._meta.id.bucket = builder._meta.id.bucket.tag;
         }
         else if (builder.type === 'enum') {
-            if ('dep' in builder.meta.enum) {
-                const _enum = dependency_1.Tag.resolve(builder.meta.enum.dep.tag, tree);
-                builder.meta.enum = {
+            if ('dep' in builder._meta.enum) {
+                const _enum = dependency_1.Tag.resolve(builder._meta.enum.dep.tag, tree);
+                builder._meta.enum = {
                     options: _enum.options
                 };
             }
@@ -196,7 +201,7 @@ class MessageTemplateFieldBuilder {
         // A .msg() parameter is an obj which takes fields from
         // another message
         else if (builder.type === 'msg') {
-            const dep = builder.meta.msg;
+            const dep = builder._meta.msg;
             if (dep.tag.type !== 'message') {
                 throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(dep.tag.name);
             }
@@ -218,7 +223,7 @@ class MessageTemplateFieldBuilder {
             type = 'obj';
             children = {};
             injectFields(children, $msg.template.fields);
-            builder.meta.msg = { tag: dep.tag };
+            builder._meta.msg = { tag: dep.tag };
         }
         else if (builder.type === 'list') {
             children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed, '#', '#');
@@ -233,7 +238,7 @@ class MessageTemplateFieldBuilder {
         else if (builder.children) {
             children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed);
         }
-        return new message_template_schema_1.$MessageTemplateField(type, name, builder.alias || name, pathRaw, pathParsed, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.meta, children);
+        return new message_template_schema_1.$MessageTemplateField(type, name, builder.alias || name, pathRaw, pathParsed, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder._meta, children);
     }
     static buildMany(fields, tree, module, basePathRaw = '', basePathParsed = '', name, key) {
         const schema = {};

package/lib/engine/data/date.d.ts

@@ -1,3 +1,6 @@
+import { NesoiDatetime } from './datetime';
+import type { DateDuration } from './duration';
+import { NesoiDuration } from './duration';
 /**
  * @category Engine
  * @subcategory Data
@@ -7,8 +10,41 @@ export declare class NesoiDate {
     month: number;
     year: number;
     constructor(day: number, month: number, year: number);
+    static from(iso_or_date: any): NesoiDate;
     static fromISO(iso: string): NesoiDate;
     static now(): NesoiDate;
     static isoNow(): string;
     toISO(): string;
+    toString(): string;
+    toISODatetime(at: 'start' | 'end', tz?: keyof typeof NesoiDatetime.tz): string;
+    plus(period: DateDuration | NesoiDuration): NesoiDate;
+    minus(period: DateDuration | NesoiDuration): NesoiDate;
+    private shift;
+    /**
+     * Returns a new `NesoiDate` which refers to the
+     * start of a given period.
+     * @param period
+     * @returns
+     */
+    startOf(period: 'week' | 'month' | 'year'): NesoiDate;
+    /**
+     * Returns a new `NesoiDatetime` which refers to the
+     * end of a given period.
+     * @param period
+     * @returns
+     */
+    endOf(period: 'week' | 'month' | 'year'): NesoiDate;
+    /**
+     * Returns a float with the distance in days between the dates.
+     * - `> 0`: left is greater
+     * - `== 0`: dates match
+     * - `< 0`: right is greater
+     */
+    compare(other: NesoiDate): number;
+    eq(other: NesoiDate): boolean;
+    gt(other: NesoiDate): boolean;
+    gteq(other: NesoiDate): boolean;
+    lt(other: NesoiDate): boolean;
+    lteq(other: NesoiDate): boolean;
+    toDatetime(at: 'start' | 'end', tz?: keyof typeof NesoiDatetime.tz): NesoiDatetime;
 }

package/lib/engine/data/date.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NesoiDate = void 0;
+const datetime_1 = require("./datetime");
+const duration_1 = require("./duration");
 const error_1 = require("./error");
 /**
  * @category Engine
@@ -15,13 +17,21 @@ class NesoiDate {
         this.month = month;
         this.year = year;
     }
+    static from(iso_or_date) {
+        if (typeof iso_or_date === 'string') {
+            return this.fromISO(iso_or_date);
+        }
+        if (iso_or_date instanceof NesoiDate) {
+            return iso_or_date;
+        }
+        throw error_1.NesoiError.Data.InvalidDate({ value: iso_or_date });
+    }
     static fromISO(iso) {
         const match = iso.match(/(\d{4})-(\d{2})-(\d{2})/);
         // TODO: Check invalid date
         if (!match) {
             throw error_1.NesoiError.Data.InvalidISOString({ value: iso });
         }
-        const jsDate = new Date(iso);
         return new NesoiDate(parseInt(match[3]), parseInt(match[2]), parseInt(match[1]));
     }
     static now() {
@@ -35,5 +45,154 @@ class NesoiDate {
     toISO() {
         return `${('0000' + this.year).slice(-4)}-${('00' + this.month).slice(-2)}-${('00' + this.day).slice(-2)}`;
     }
+    toString() {
+        return this.toISO();
+    }
+    toISODatetime(at, tz = 'Z') {
+        return `${('0000' + this.year).slice(-4)}-${('00' + this.month).slice(-2)}-${('00' + this.day).slice(-2)}`
+            + (at === 'start'
+                ? 'T00:00:00.000'
+                : 'T23:59:59.999')
+            + tz;
+    }
+    // Shift
+    plus(period) {
+        return this.shift(true, period);
+    }
+    minus(period) {
+        return this.shift(false, period);
+    }
+    shift(plus, period) {
+        let duration;
+        if (typeof period === 'string') {
+            try {
+                const [_, val, type] = period.match(/(\d+) +(\w+)/);
+                duration = new duration_1.NesoiDuration({
+                    [type]: val
+                });
+            }
+            catch {
+                throw new Error(`Attempt to shift NesoiDate failed due to invalid period '${period}'`);
+            }
+        }
+        else {
+            if (period instanceof duration_1.NesoiDuration) {
+                duration = period;
+            }
+            else {
+                duration = new duration_1.NesoiDuration(period);
+            }
+        }
+        if (!['days', 'weeks', 'months', 'years'].includes(duration.unit)) {
+            throw new Error(`Attempt to shift NesoiDate failed due to invalid duration unit '${duration.unit}'`);
+        }
+        const mult = plus ? 1 : -1;
+        const d = new Date(this.year, this.month - 1, this.day);
+        switch (duration.unit) {
+            case 'days':
+                d.setDate(d.getDate() + mult * duration.value);
+                break;
+            case 'weeks':
+                d.setDate(d.getDate() + mult * duration.value * 7);
+                break;
+            case 'months':
+                d.setMonth(d.getMonth() + mult * duration.value);
+                break;
+            case 'years':
+                d.setFullYear(d.getFullYear() + mult * duration.value);
+                break;
+        }
+        return new NesoiDate(d.getDate(), d.getMonth() + 1, d.getFullYear());
+    }
+    // Start Of
+    /**
+     * Returns a new `NesoiDate` which refers to the
+     * start of a given period.
+     * @param period
+     * @returns
+     */
+    startOf(period) {
+        switch (period) {
+            case 'week':
+                {
+                    const d = new Date(this.year, this.month - 1, this.day);
+                    d.setDate(d.getDate() - d.getDay());
+                    return new NesoiDate(d.getDate(), d.getMonth() + 1, d.getFullYear());
+                }
+            case 'month':
+                return new NesoiDate(1, this.month, this.year);
+            case 'year':
+                return new NesoiDate(1, 1, this.year);
+        }
+    }
+    // End Of
+    /**
+     * Returns a new `NesoiDatetime` which refers to the
+     * end of a given period.
+     * @param period
+     * @returns
+     */
+    endOf(period) {
+        switch (period) {
+            case 'week':
+                {
+                    const d = new Date(this.year, this.month - 1, this.day);
+                    d.setDate(d.getDate() + 6 - d.getDay());
+                    return new NesoiDate(d.getDate(), d.getMonth() + 1, d.getFullYear());
+                }
+            case 'month':
+                return new NesoiDate(new Date(this.year, this.month, 0).getDate(), this.month, this.year);
+            case 'year':
+                return new NesoiDate(new Date(this.year, 12, 0).getDate(), 12, this.year);
+        }
+    }
+    // Comparisons
+    /**
+     * Returns a float with the distance in days between the dates.
+     * - `> 0`: left is greater
+     * - `== 0`: dates match
+     * - `< 0`: right is greater
+     */
+    compare(other) {
+        return (this.year - other.year) * 365.25
+            + (this.month - other.month) * 12
+            + (this.day - other.day);
+    }
+    eq(other) {
+        return this.compare(other) === 0;
+    }
+    gt(other) {
+        return this.compare(other) > 0;
+    }
+    gteq(other) {
+        return this.compare(other) >= 0;
+    }
+    lt(other) {
+        return this.compare(other) < 0;
+    }
+    lteq(other) {
+        return this.compare(other) <= 0;
+    }
+    // to NesoiDateTime
+    toDatetime(at, tz = 'Z') {
+        if (at === 'start')
+            return datetime_1.NesoiDatetime.fromValues({
+                ...this,
+                hour: 0,
+                minute: 0,
+                second: 0,
+                ms: 0,
+                tz
+            });
+        else
+            return datetime_1.NesoiDatetime.fromValues({
+                ...this,
+                hour: 23,
+                minute: 59,
+                second: 59,
+                ms: 999,
+                tz
+            });
+    }
 }
 exports.NesoiDate = NesoiDate;

package/lib/engine/data/datetime.d.ts

@@ -1,3 +1,5 @@
+import { NesoiDate } from './date';
+import type { DateDuration, TimeDuration } from './duration';
 import { NesoiDuration } from './duration';
 export type NesoiDateTimeValues = {
     year: number;
@@ -50,12 +52,6 @@ export declare class NesoiDatetime {
     tz: keyof typeof NesoiDatetime.tz;
     constructor(epoch?: number, tz?: keyof typeof NesoiDatetime.tz);
     atTimezone(tz: NesoiDatetime['tz']): NesoiDatetime;
-    /**
-     * Parse a timestamp from ISO 8601 format.
-     *
-     * Example: `2025-04-16T23:04:42.000-03:00`
-     */
-    static fromISO(iso: string): NesoiDatetime;
     /**
      * Make a new `NesoiDateTime`
      * @param year Numeric year
@@ -69,16 +65,26 @@ export declare class NesoiDatetime {
      * @returns
      */
     static make(year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, ms?: number, tz?: NesoiDatetime['tz']): NesoiDatetime;
+    static parse(value: string | NesoiDatetime): NesoiDatetime;
+    /**
+     * Create a NesoiDatetime from a string on the ISO 8601 format.
+     *
+     * Example: `2025-04-16T23:04:42.000-03:00`
+     */
+    static fromISO(iso: string): NesoiDatetime;
+    static fromJSDate(date: Date, tz?: keyof typeof NesoiDatetime.tz): NesoiDatetime;
     static fromValues(values: Partial<NesoiDateTimeValues>): NesoiDatetime;
     toISO(): string;
+    toString(): string;
+    toISODate(): string;
     toValues(): NesoiDateTimeValues;
     toJSDate(): Date;
     static now(): NesoiDatetime;
     static isoNow(): string;
     static shortIsoNow(): string;
-    plus(period: `${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
-    minus(period: `${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
-    shift(period: `${'+' | '-'} ${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
+    plus(period: DateDuration | TimeDuration | NesoiDuration): NesoiDatetime;
+    minus(period: DateDuration | TimeDuration | NesoiDuration): NesoiDatetime;
+    private shift;
     /**
      * Returns a new `NesoiDatetime` which refers to the
      * start of a given period **on the object timezone**.
@@ -86,4 +92,24 @@ export declare class NesoiDatetime {
      * @returns
      */
     startOf(period: 'day' | 'month' | 'year'): NesoiDatetime;
+    /**
+     * Returns a new `NesoiDatetime` which refers to the
+     * end of a given period **on the object timezone**.
+     * @param period
+     * @returns
+     */
+    endOf(period: 'day' | 'month' | 'year'): NesoiDatetime;
+    /**
+     * Returns a float with the distance in milliseconds between the datetimes.
+     * - `> 0`: left is greater
+     * - `== 0`: dates match
+     * - `< 0`: right is greater
+     */
+    compare(other: NesoiDatetime): number;
+    eq(other: NesoiDatetime): boolean;
+    gt(other: NesoiDatetime): boolean;
+    gteq(other: NesoiDatetime): boolean;
+    lt(other: NesoiDatetime): boolean;
+    lteq(other: NesoiDatetime): boolean;
+    toDate(): NesoiDate;
 }