angular-odata 0.99.2 → 0.100.1

package/lib/helper.d.ts

@@ -17,81 +17,52 @@ export interface ODataVersionHelper {
     ODATA_ANNOTATION_PREFIX: string;
     ODATA_FUNCTION_PREFIX: string;
     ODATA_ID: string;
+    ODATA_TYPE: string;
     ODATA_COUNT: string;
     ODATA_ETAG: string;
     ODATA_CONTEXT: string;
     ODATA_MEDIA_ETAG: string;
     entity(value: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
     entities(value: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
     property(value: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
     annotations(value: {
-        [name: string]: any;
-    }): {
-        [name: string]: any;
-    };
+        [key: string]: any;
+    }): Map<string, any>;
     attributes(value: {
-        [name: string]: any;
+        [key: string]: any;
     }, metadata: ODataMetadataType): any;
-    id(value: {
-        [name: string]: any;
-    }, id?: string): string | undefined;
-    etag(value: {
-        [name: string]: any;
-    }, etag?: string): string | undefined;
-    type(value: {
-        [name: string]: any;
-    }, type?: string): string | undefined;
-    count(value: {
-        [name: string]: any;
-    }): number | undefined;
-    context(value: {
-        [name: string]: any;
+    context(annots: Map<string, any> | {
+        [key: string]: any;
     }): ODataContext;
-    functions(value: {
-        [name: string]: any;
-    }): {
-        [name: string]: any;
-    };
-    properties(value: {
-        [name: string]: any;
-    }): {
-        [name: string]: any;
-    };
-    mediaEtag(value: {
-        [name: string]: any;
-    }): string | undefined;
-    metadataEtag(value: {
-        [name: string]: any;
-    }): string | undefined;
-    nextLink(value: {
-        [name: string]: any;
-    }): string | undefined;
-    readLink(value: {
-        [name: string]: any;
-    }): string | undefined;
-    mediaReadLink(value: {
-        [name: string]: any;
-    }): string | undefined;
-    editLink(value: {
-        [name: string]: any;
-    }): string | undefined;
-    mediaEditLink(value: {
-        [name: string]: any;
+    id(annots: Map<string, any> | {
+        [key: string]: any;
     }): string | undefined;
-    mediaContentType(value: {
-        [name: string]: any;
+    etag(annots: Map<string, any> | {
+        [key: string]: any;
     }): string | undefined;
-    deltaLink(value: {
-        [name: string]: any;
+    type(annots: Map<string, any> | {
+        [key: string]: any;
     }): string | undefined;
+    count(annots: Map<string, any>): number | undefined;
+    functions(annots: Map<string, any>): Map<string, any>;
+    properties(annots: Map<string, any>): Map<string, Map<string, any>>;
+    mediaEtag(annots: Map<string, any>): string | undefined;
+    metadataEtag(annots: Map<string, any>): string | undefined;
+    nextLink(annots: Map<string, any>): string | undefined;
+    readLink(annots: Map<string, any>): string | undefined;
+    mediaReadLink(annots: Map<string, any>): string | undefined;
+    editLink(annots: Map<string, any>): string | undefined;
+    mediaEditLink(annots: Map<string, any>): string | undefined;
+    mediaContentType(annots: Map<string, any>): string | undefined;
+    deltaLink(annots: Map<string, any>): string | undefined;
     countParam(): {
-        [name: string]: string;
+        [key: string]: string;
     };
 }
 export declare const ODataHelper: {

package/lib/models/collection.d.ts

@@ -110,8 +110,10 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     [Symbol.iterator](): {
         next(): IteratorResult<M>;
     };
-    filter(predicate: (m: M, index: number) => boolean): M[];
-    find(predicate: (m: M, index: number) => boolean): M | undefined;
+    filter(predicate: (value: M, index: number, array: M[]) => unknown, thisArg?: any): M[];
+    map<U>(callbackfn: (value: M, index: number, array: M[]) => U, thisArg?: any): U[];
+    find(predicate: (value: M, index: number, obj: M[]) => unknown, thisArg?: any): M | undefined;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: M, currentIndex: number, array: M[]) => U, initialValue: U): U;
     first(): M | undefined;
     last(): M | undefined;
     next(model: M): M | undefined;

package/lib/models/model.d.ts

@@ -15,15 +15,9 @@ export declare class ODataModel<T> {
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ] | null;
-    _attributes: {
-        [name: string]: any;
-    };
-    _changes: {
-        [name: string]: any;
-    };
-    _relations: {
-        [name: string]: ODataModelRelation<any>;
-    };
+    _attributes: Map<string, any>;
+    _changes: Map<string, any>;
+    _relations: Map<string, ODataModelRelation<any>>;
     _resource: ODataResource<T> | null;
     _annotations: ODataEntityAnnotations;
     _reset: boolean;

package/lib/models/options.d.ts

@@ -1,19 +1,12 @@
 import { Subscription } from 'rxjs';
 import { EntityKey, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, ODataQueryOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataEntitySet, ODataStructuredType, ODataStructuredTypeFieldParser } from '../schema';
-import { Options, OptionsHelper } from '../types';
+import { OptionsHelper } from '../types';
 import type { ODataCollection } from './collection';
 import type { ODataModel } from './model';
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
-    bubbling: boolean;
-    model?: ODataModel<T>;
-    collection?: ODataCollection<T, ODataModel<T>>;
-    chain: [
-        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        string | number | null
-    ][];
     value?: any;
     previous?: any;
     options?: any;
@@ -25,10 +18,19 @@ export declare class ODataModelEvent<T> {
         value?: any;
         options?: any;
     });
+    bubbling: boolean;
     stopPropagation(): void;
+    chain: [
+        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+        string | number | null
+    ][];
     push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, track: string | number): void;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     get path(): string;
+    model?: ODataModel<T>;
+    get currentModel(): ODataModel<any> | undefined;
+    collection?: ODataCollection<T, ODataModel<T>>;
+    get currentCollection(): ODataCollection<any, ODataModel<any>> | undefined;
 }
 export declare const BUBBLING: string[];
 export declare const INCLUDE_SHALLOW: {
@@ -114,9 +116,9 @@ export declare class ODataModelField<F> {
         navigation?: boolean;
     }): any;
     defaults(): any;
-    deserialize(value: any, options?: Options): F;
-    serialize(value: F, options?: Options): any;
-    encode(value: F, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): F;
+    serialize(value: F, options?: OptionsHelper): any;
+    encode(value: F, options?: OptionsHelper): any;
     resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
     annotationsFactory(base: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
     schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;

package/lib/options.d.ts

@@ -1,4 +1,4 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, Options, OptionsHelper, QueryOptionNames } from './types';
+import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, OptionsHelper, QueryOptionNames } from './types';
 export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     /**
      * Default OData version
@@ -7,7 +7,7 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     /**
      * Send enum as string in the request
      */
-    stringAsEnum?: boolean;
+    stringAsEnum: boolean;
     /**
      * Strip metadata from the response
      */
@@ -75,12 +75,12 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
         includeAnnotations?: string;
     };
     deleteRefBy: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction: boolean;
     constructor(config: ApiOptions);
     get helper(): import("./helper").ODataVersionHelper;
 }
 export declare class ODataParserOptions implements OptionsHelper {
     version: ODataVersion;
-    stringAsEnum?: boolean;
-    constructor(config: Options);
+    constructor(config: OptionsHelper);
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/query/builder.d.ts

@@ -32,6 +32,7 @@ export declare type ExpandOptions<T> = {
     filter?: Filter<T>;
     orderBy?: OrderBy<T>;
     top?: number;
+    skip?: number;
     levels?: number | 'max';
     count?: boolean | Filter<T>;
     expand?: Expand<T>;
@@ -90,7 +91,7 @@ export default function <T>({ select, search, skiptoken, format, top, skip, filt
 export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
-export declare function normalizeValue(value: Value, { aliases, escape }: {
+export declare function normalizeValue(value: Value, { aliases, escape, }?: {
     aliases?: QueryCustomType[];
     escape?: boolean;
 }): any;

package/lib/resources/query/expressions/base.d.ts

@@ -11,6 +11,7 @@ export declare abstract class Expression<T> implements Renderable {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    abstract clone(): Expression<T>;
     children(): Renderable[];
     length(): number;
     toJSON(): {

package/lib/resources/query/expressions/compute.d.ts

@@ -9,15 +9,16 @@ export declare class ComputeExpression<T> extends Expression<T> {
     });
     static e<T>(): ComputeExpression<T>;
     static s<T extends object>(): T;
-    static compute<T extends object>(opts: (e: {
+    static compute<T extends object>(opts: (builder: {
         s: T;
         e: () => ComputeExpression<T>;
-    }) => ComputeExpression<T>): ComputeExpression<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): ComputeExpression<unknown>;
     private _add;
     field<T extends object>(name: string, opts: (e: {
         o: ODataOperators<T>;

package/lib/resources/query/expressions/expand.d.ts

@@ -1,9 +1,16 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { Renderable } from './syntax';
+import { FilterConnector, FilterExpression } from './filter';
+import { OrderByExpression } from './orderby';
+import { SearchConnector, SearchExpression } from './search';
+import { SelectExpression } from './select';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare class ExpandField<T> implements Renderable {
-    protected field: Renderable;
-    constructor(field: Renderable);
+    protected field: any;
+    private values;
+    constructor(field: any, values?: {
+        [name: string]: any;
+    });
     get [Symbol.toStringTag](): string;
     toJSON(): {
         field: any;
@@ -13,12 +20,32 @@ export declare class ExpandField<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
-    select(): void;
-    filter(): void;
-    levels(): void;
-    orderBy(): void;
-    top(): void;
-    skip(): void;
+    clone(): ExpandField<unknown>;
+    select<T extends object>(opts: (builder: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T extends object>(opts: (builder: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
+    filter<T extends object>(opts: (builder: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    search<T extends object>(opts: (builder: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): any;
+    orderBy<T extends object>(opts: (builder: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
+    skip(n: number): any;
+    top(n: number): any;
+    levels(n: number | 'max'): any;
+    private option;
 }
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
@@ -26,15 +53,16 @@ export declare class ExpandExpression<T> extends Expression<T> {
     });
     static e<T>(): ExpandExpression<T>;
     static s<T extends object>(): T;
-    static expand<T extends object>(opts: (e: {
+    static expand<T extends object>(opts: (builder: {
         s: T;
         e: () => ExpandExpression<T>;
-    }) => ExpandExpression<T>): ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): ExpandExpression<unknown>;
     private _add;
-    field<T extends object>(field: any, opts?: (e: ExpandField<keyof T>) => void): ExpandExpression<T>;
+    field<F>(field: F, opts?: (e: ExpandField<F>) => void): ExpandExpression<F>;
 }

package/lib/resources/query/expressions/filter.d.ts

@@ -2,7 +2,7 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
-export declare class FilterExpression<T> extends Expression<T> {
+export declare class FilterExpression<F> extends Expression<F> {
     private _connector;
     private _negated;
     constructor({ children, connector, negated, }?: {
@@ -12,12 +12,12 @@ export declare class FilterExpression<T> extends Expression<T> {
     });
     static s<T extends object>(): T;
     static e<T>(connector?: FilterConnector): FilterExpression<T>;
-    static filter<T extends object>(opts: (e: {
+    static filter<T extends object>(opts: (builder: {
         s: T;
         e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => FilterExpression<T>): FilterExpression<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJSON(): {
         children: any[];
         connector: FilterConnector;
@@ -30,29 +30,30 @@ export declare class FilterExpression<T> extends Expression<T> {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): FilterExpression<unknown>;
     private _add;
-    or(exp: FilterExpression<T>): FilterExpression<T>;
-    and(exp: FilterExpression<T>): FilterExpression<T>;
-    not(exp: FilterExpression<T>): FilterExpression<T>;
-    eq(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    ne(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    gt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    ge(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    lt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    le(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    has(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    in(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    contains(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    or(exp: FilterExpression<F>): FilterExpression<F>;
+    and(exp: FilterExpression<F>): FilterExpression<F>;
+    not(exp: FilterExpression<F>): FilterExpression<F>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     any<N extends object>(left: N[], opts: (e: {
         s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
-    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     all<N extends object>(left: N[], opts: (e: {
         s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
-    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
-    isof(type: string): FilterExpression<T>;
-    isof(left: T, type: string): FilterExpression<T>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
+    isof(type: string): FilterExpression<F>;
+    isof(left: F, type: string): FilterExpression<F>;
 }

package/lib/resources/query/expressions/orderby.d.ts

@@ -15,6 +15,7 @@ export declare class OrderByField implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): OrderByField;
 }
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
@@ -22,16 +23,17 @@ export declare class OrderByExpression<T> extends Expression<T> {
     });
     static e<T>(): OrderByExpression<T>;
     static s<T extends object>(): T;
-    static orderBy<T extends object>(opts: (e: {
+    static orderBy<T extends object>(opts: (builder: {
         s: T;
         e: () => OrderByExpression<T>;
-    }) => OrderByExpression<T>): OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): OrderByExpression<unknown>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
 }

package/lib/resources/query/expressions/search.d.ts

@@ -7,6 +7,7 @@ export declare class SearchTerm implements Renderable {
     constructor(value: string);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         value: string;
     };
     render({ aliases, escape, prefix, }: {
@@ -14,6 +15,7 @@ export declare class SearchTerm implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): SearchTerm;
 }
 export declare class SearchExpression<T> extends Expression<T> {
     private _connector;
@@ -24,15 +26,16 @@ export declare class SearchExpression<T> extends Expression<T> {
         negated?: boolean;
     });
     static e<T>(connector?: SearchConnector): SearchExpression<T>;
-    static search<T extends object>(opts: (e: {
+    static search<T extends object>(opts: (builder: {
         e: (connector?: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): SearchExpression<T>;
+    }, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): SearchExpression<unknown>;
     toJSON(): {
         children: any[];
         connector: SearchConnector;

package/lib/resources/query/expressions/select.d.ts

@@ -7,15 +7,16 @@ export declare class SelectExpression<T> extends Expression<T> {
     });
     static e<T>(): SelectExpression<T>;
     static s<T extends object>(): T;
-    static select<T extends object>(opts: (e: {
+    static select<T extends object>(builder: (b: {
         s: T;
         e: () => SelectExpression<T>;
-    }) => SelectExpression<T>): SelectExpression<T>;
+    }, c?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): SelectExpression<unknown>;
     private _add;
     field(field: any): SelectExpression<T>;
 }

package/lib/resources/query/expressions/syntax.d.ts

@@ -7,12 +7,14 @@ export interface Renderable {
     }): string;
     toString(): string;
     toJSON(): any;
+    clone(): any;
 }
 export declare class Field<T extends object> implements ProxyHandler<T> {
     name: string;
     constructor(name?: string);
-    static factory<T extends object>(): T;
-    get(target: T, p: string | symbol): any;
+    static factory<T extends object>(name?: string): T;
+    get(target: T, key: string | symbol): any;
+    has(target: T, key: string): any;
 }
 export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
     aliases?: QueryCustomType[];
@@ -28,6 +30,7 @@ export declare class Function<T> implements Renderable {
     constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         name: string;
         values: any[];
         normalize: boolean;
@@ -37,6 +40,7 @@ export declare class Function<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Function<T>;
 }
 export declare class StringAndCollectionFunctions<T> {
     concat(field: any, value: any, normalize?: boolean): Function<T>;
@@ -97,6 +101,7 @@ export declare class Operator<T> implements Renderable {
     constructor(op: string, values: any[], normalize?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         normalize: boolean;
@@ -106,6 +111,7 @@ export declare class Operator<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Operator<unknown>;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -131,6 +137,7 @@ export declare class Grouping<T> implements Renderable {
     constructor(group: Renderable);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         group: any;
     };
     render({ aliases, escape, prefix, }: {
@@ -138,6 +145,7 @@ export declare class Grouping<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Grouping<unknown>;
 }
 export declare class Lambda<T> implements Renderable {
     protected op: string;
@@ -146,6 +154,7 @@ export declare class Lambda<T> implements Renderable {
     constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         alias: string | undefined;
@@ -155,6 +164,7 @@ export declare class Lambda<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Lambda<unknown>;
 }
 export declare class LambdaOperators<T> {
     any(field: T, value: any, alias?: string): Lambda<unknown>;