angular-odata 0.121.0 → 0.123.0

package/lib/helper.d.ts

@@ -2,7 +2,7 @@ import { ODataMetadataType } from './types';
 export declare const COLLECTION: RegExp;
 export declare const PROPERTY: RegExp;
 export declare const EXPAND: RegExp;
-export declare type ODataContext = {
+export type ODataContext = {
     serviceRootUrl?: string;
     metadataUrl?: string;
     entitySet?: string;

package/lib/models/model.d.ts

@@ -3,7 +3,8 @@ import { Observable } from 'rxjs';
 import { EntityKey, ODataActionOptions, ODataEntityAnnotations, ODataEntityResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
-import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelRelation } from './options';
+import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelAttribute } from './options';
+import { ParserOptions } from '../types';
 export declare class ODataModel<T> {
     static options: ModelOptions;
     static meta: ODataModelOptions<any>;
@@ -23,9 +24,7 @@ export declare class ODataModel<T> {
         ] | null;
         resource: ODataResource<T> | null;
     }[];
-    _attributes: Map<string, any>;
-    _changes: Map<string, any>;
-    _relations: Map<string, ODataModelRelation<any>>;
+    _attributes: Map<string, ODataModelAttribute<any>>;
     _annotations: ODataEntityAnnotations<T> | null;
     _reset: boolean;
     _reparent: boolean;
@@ -62,13 +61,13 @@ export declare class ODataModel<T> {
     } | undefined;
     isOpenModel(): boolean;
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
-    referential(field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    referential(attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
         [name: string]: any;
     } | null | undefined;
-    referenced(field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    referenced(attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
@@ -104,15 +103,6 @@ export declare class ODataModel<T> {
     toJSON(): T | {
         [name: string]: any;
     };
-    attributes({ changes_only, include_concurrency, include_computed, include_non_field, field_mapping, }?: {
-        changes_only?: boolean;
-        include_concurrency?: boolean;
-        include_computed?: boolean;
-        include_non_field?: boolean;
-        field_mapping?: boolean;
-    }): {
-        [name: string]: any;
-    };
     set(path: string | string[], value: any, { type }?: {
         type?: string;
     }): any;
@@ -159,6 +149,7 @@ export declare class ODataModel<T> {
     hasChanged({ include_navigation, }?: {
         include_navigation?: boolean;
     }): boolean;
+    encode<E>(name: keyof T, options?: ParserOptions): any;
     isNew(): boolean;
     withResource<R>(resource: any, ctx: (model: this) => R): R;
     /**
@@ -174,8 +165,8 @@ export declare class ODataModel<T> {
     getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
     setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
     getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
-    equals(other: ODataModel<T>): boolean;
     get [Symbol.toStringTag](): string;
+    equals(other: ODataModel<T>): boolean;
     collection(): ODataCollection<T, ODataModel<T>> | undefined;
     next(): ODataModel<T> | undefined;
     prev(): ODataModel<T> | undefined;

package/lib/models/options.d.ts

@@ -2,18 +2,30 @@ 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 { EdmType, Parser, ParserOptions } from '../types';
-import type { ODataCollection } from './collection';
+import { ODataCollection } from './collection';
 import type { ODataModel } from './model';
-export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
+import { EventEmitter } from '@angular/core';
+export declare enum ODataModelEventType {
+    Change = "change",
+    Reset = "reset",
+    Update = "update",
+    Destroy = "destroy",
+    Add = "add",
+    Remove = "remove",
+    Invalid = "invalid",
+    Request = "request",
+    Sync = "sync",
+    Attach = "attach"
+}
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
     value?: any;
     previous?: any;
     options?: any;
-    constructor(name: ODataModelEventType, { model, collection, previous, value, field, options, }?: {
+    constructor(name: ODataModelEventType, { model, collection, previous, value, attr, options, }?: {
         model?: ODataModel<T>;
         collection?: ODataCollection<T, ODataModel<T>>;
-        field?: ODataModelField<any> | number;
+        attr?: ODataModelAttribute<any> | number;
         previous?: any;
         value?: any;
         options?: any;
@@ -22,9 +34,9 @@ export declare class ODataModelEvent<T> {
     stopPropagation(): void;
     chain: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        ODataModelField<any> | number | null
+        ODataModelAttribute<any> | number | null
     ][];
-    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, field: ODataModelField<any> | number): ODataModelEvent<T>;
+    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, attr: ODataModelAttribute<any> | number): ODataModelEvent<T>;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     get path(): string;
     model?: ODataModel<T>;
@@ -32,7 +44,7 @@ export declare class ODataModelEvent<T> {
     collection?: ODataCollection<T, ODataModel<T>>;
     get currentCollection(): ODataCollection<any, ODataModel<any>> | undefined;
 }
-export declare const BUBBLING: string[];
+export declare const BUBBLING: ODataModelEventType[];
 export declare const INCLUDE_SHALLOW: {
     include_concurrency: boolean;
     include_computed: boolean;
@@ -48,16 +60,15 @@ export declare const INCLUDE_DEEP: {
 export declare enum ODataModelState {
     Added = 0,
     Removed = 1,
-    Changed = 2,
-    Unchanged = 3
+    Unchanged = 2
 }
-export declare type ModelOptions = {
+export type ModelOptions = {
     cid?: string;
     fields: {
         [name: string]: ModelFieldOptions;
     };
 };
-export declare type ModelFieldOptions = {
+export type ModelFieldOptions = {
     field?: string;
     parser?: ODataStructuredTypeFieldParser<any>;
     default?: any;
@@ -75,7 +86,7 @@ export declare function Model({ cid }?: {
 export declare function ModelField({ name, ...options }?: {
     name?: string;
 } & ModelFieldOptions): (target: any, key: string) => void;
-export declare type ODataModelFieldOptions<F> = ModelFieldOptions & {
+export type ODataModelFieldOptions<F> = ModelFieldOptions & {
     name: string;
     field: string;
     parser: ODataStructuredTypeFieldParser<F>;
@@ -139,13 +150,32 @@ export declare class ODataModelField<F> {
         reset?: boolean;
     }): ODataCollection<F, ODataModel<F>>;
 }
-export declare type ODataModelRelation<T> = {
-    state: ODataModelState;
-    model?: ODataModel<T> | ODataCollection<T, ODataModel<T>> | null;
-    field: ODataModelField<T>;
-    subscription?: Subscription;
-};
-export declare type ODataModelEntry<T, M extends ODataModel<T>> = {
+export declare class ODataModelAttribute<T> {
+    private _model;
+    private _field;
+    private value?;
+    private change?;
+    private subscription?;
+    events$: EventEmitter<ODataModelEvent<T>>;
+    constructor(_model: ODataModel<any>, _field: ODataModelField<T>);
+    get navigation(): boolean;
+    get computed(): boolean | undefined;
+    get concurrency(): boolean;
+    get referentials(): import("../schema").ODataReferential[];
+    get options(): ODataModelOptions<any>;
+    get meta(): ODataModelOptions<any> | undefined;
+    get name(): string;
+    get fieldName(): string;
+    get(): T | ODataModel<T> | ODataCollection<T, ODataModel<T>> | null | undefined;
+    set(value: T | ODataModel<T> | ODataCollection<T, ODataModel<T>> | null | undefined, reset?: boolean, reparent?: boolean): boolean;
+    isChanged({ include_navigation, }?: {
+        include_navigation?: boolean;
+    }): boolean;
+    reset(): void;
+    private link;
+    private unlink;
+}
+export type ODataModelEntry<T, M extends ODataModel<T>> = {
     state: ODataModelState;
     model: M;
     key?: EntityKey<T> | {
@@ -220,7 +250,7 @@ export declare class ODataModelOptions<T> {
     } | undefined;
     resolveReferential(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
+    } | null, attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
         single?: boolean;
@@ -229,7 +259,7 @@ export declare class ODataModelOptions<T> {
     } | null | undefined;
     resolveReferenced(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
+    } | null, attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
         single?: boolean;
@@ -264,15 +294,6 @@ export declare class ODataModelOptions<T> {
     }): T | {
         [name: string]: any;
     };
-    attributes(self: ODataModel<T>, { changes_only, include_concurrency, include_computed, include_non_field, field_mapping, }?: {
-        changes_only?: boolean;
-        include_concurrency?: boolean;
-        include_computed?: boolean;
-        include_non_field?: boolean;
-        field_mapping?: boolean;
-    }): {
-        [name: string]: any;
-    };
     reset(self: ODataModel<T>, { name, silent }?: {
         name?: string;
         silent?: boolean;
@@ -289,8 +310,6 @@ export declare class ODataModelOptions<T> {
     private _updateCollection;
     private _updateModel;
     get<F>(self: ODataModel<T>, field: ODataModelField<F> | string): F | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null | undefined;
-    private _setStructured;
-    private _setValue;
     set<F>(self: ODataModel<T>, field: ODataModelField<F> | string, value: F | F[] | {
         [name: string]: any;
     } | {
@@ -298,6 +317,5 @@ export declare class ODataModelOptions<T> {
     }[] | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null, { type }?: {
         type?: string;
     }): boolean;
-    private _unlink;
     private _link;
 }

package/lib/resources/path/segments.d.ts

@@ -1,7 +1,7 @@
 import { PathSegment } from '../../types';
 import { EntityKey } from '../resource';
 import { SegmentHandler } from './handlers';
-export declare type ODataSegment = {
+export type ODataSegment = {
     name: PathSegment;
     path: string;
     type?: string;

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

@@ -1,8 +1,8 @@
-export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
-export declare type Select<T> = SelectType<T> | SelectType<T>[];
-export declare type SelectType<T> = string | keyof T;
-export declare type Filter<T> = FilterType | FilterType[];
-export declare type FilterType = string | {
+export type Unpacked<T> = T extends (infer U)[] ? U : T;
+export type Select<T> = SelectType<T> | SelectType<T>[];
+export type SelectType<T> = string | keyof T;
+export type Filter<T> = FilterType | FilterType[];
+export type FilterType = string | {
     [name: string]: any;
 };
 export declare enum StandardAggregateMethods {
@@ -12,25 +12,25 @@ export declare enum StandardAggregateMethods {
     average = "average",
     countdistinct = "countdistinct"
 }
-export declare type Aggregate = string | {
+export type Aggregate = string | {
     [propertyName: string]: {
         with: StandardAggregateMethods;
         as: string;
     };
 };
-export declare type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
-export declare type OrderByType<T> = string | OrderByObject<T>;
-export declare type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
-export declare type NestedOrderBy<T> = {
+export type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
+export type OrderByType<T> = string | OrderByObject<T>;
+export type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
+export type NestedOrderBy<T> = {
     [P in keyof T]?: T[P] extends Array<infer E> ? OrderBy<E> : OrderBy<T[P]>;
 };
-export declare type Expand<T> = ExpandType<T> | ExpandType<T>[];
-export declare type ExpandType<T> = string | ExpandObject<T>;
-export declare type ExpandObject<T> = keyof T | NestedExpandOptions<T>;
-export declare type NestedExpandOptions<T> = {
+export type Expand<T> = ExpandType<T> | ExpandType<T>[];
+export type ExpandType<T> = string | ExpandObject<T>;
+export type ExpandObject<T> = keyof T | NestedExpandOptions<T>;
+export type NestedExpandOptions<T> = {
     [P in keyof T]?: ExpandOptions<Unpacked<T[P]>>;
 };
-export declare type ExpandOptions<T> = {
+export type ExpandOptions<T> = {
     select?: Select<T>;
     filter?: Filter<T>;
     orderBy?: OrderBy<T>;
@@ -40,12 +40,12 @@ export declare type ExpandOptions<T> = {
     count?: boolean | Filter<T>;
     expand?: Expand<T>;
 };
-export declare type Transform<T> = {
+export type Transform<T> = {
     aggregate?: Aggregate | Array<Aggregate>;
     filter?: Filter<T>;
     groupBy?: GroupBy<T>;
 };
-export declare type GroupBy<T> = {
+export type GroupBy<T> = {
     properties: Array<keyof T>;
     transform?: Transform<T>;
 };
@@ -55,18 +55,19 @@ export declare enum QueryCustomTypes {
     Duration = 2,
     Binary = 3
 }
-export declare type QueryCustomType = {
+export type QueryCustomType = {
     type: QueryCustomTypes;
     value: any;
     name?: string;
 };
-export declare type Value = string | Date | number | boolean | QueryCustomType;
+export type Value = string | Date | number | boolean | QueryCustomType;
 export declare const raw: (value: string) => QueryCustomType;
 export declare const alias: (value: any, name?: string) => QueryCustomType;
 export declare const duration: (value: string) => QueryCustomType;
 export declare const binary: (value: string) => QueryCustomType;
 export declare const isQueryCustomType: (value: any) => boolean;
-export declare type QueryOptions<T> = ExpandOptions<T> & {
+export declare const isRawType: (value: any) => boolean;
+export type QueryOptions<T> = ExpandOptions<T> & {
     search: string;
     transform: {
         [name: string]: any;

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

@@ -7,9 +7,9 @@ export declare abstract class Expression<T> implements Renderable {
     });
     get [Symbol.toStringTag](): string;
     abstract render({ aliases, escape, prefix, }: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
     }): string;
     abstract clone(): Expression<T>;
     children(): Renderable[];

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

@@ -1,7 +1,7 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
-export declare type ComputeExpressionBuilder<T> = {
+export type ComputeExpressionBuilder<T> = {
     t: Required<Readonly<T>>;
     e: () => ComputeExpression<T>;
 };
@@ -17,7 +17,7 @@ export declare class ComputeExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): ComputeExpression<unknown>;
+    clone(): ComputeExpression<T>;
     private _add;
     field<T extends object>(name: string, opts: (e: {
         o: ODataOperators<T>;

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

@@ -18,10 +18,10 @@ export declare class CountField<T extends object> implements Renderable {
         prefix?: string;
     }): string;
     filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    clone(): CountField<object>;
+    clone(): CountField<T>;
     private option;
 }
-export declare type CountExpressionBuilder<T> = {
+export type CountExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => CountExpression<T>;
 };
@@ -36,7 +36,7 @@ export declare class CountExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): CountExpression<unknown>;
+    clone(): CountExpression<T>;
     field<F extends Object>(field: F[], opts?: (e: {
         t: F;
         f: CountField<F>;

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

@@ -1,4 +1,4 @@
-import type { QueryCustomType } from '../builder';
+import type { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
@@ -20,18 +20,19 @@ export declare class ExpandField<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
-    clone(): ExpandField<unknown>;
+    clone(): ExpandField<T>;
     select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
-    expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
-    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): any;
-    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
-    skip(n: number): any;
-    top(n: number): any;
-    levels(n: number | 'max'): any;
+    expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
+    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
+    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
+    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    skip(n: number): number;
+    top(n: number): number;
+    levels(n: number | 'max'): number | "max";
+    count(): boolean;
     private option;
 }
-export declare type ExpandExpressionBuilder<T> = {
+export type ExpandExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => ExpandExpression<T>;
 };
@@ -45,7 +46,7 @@ export declare class ExpandExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): ExpandExpression<unknown>;
+    clone(): ExpandExpression<T>;
     private _add;
-    field<F>(field: F, opts?: (e: ExpandField<F>) => void): ExpandExpression<F>;
+    field<F extends keyof T>(field: T[F], opts?: (e: ExpandField<Unpacked<T[F]>>) => void): ExpandExpression<T>;
 }

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

@@ -1,9 +1,9 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
-import { ODataFunctions, ODataOperators, Renderable } from './syntax';
-export declare type FilterConnector = 'and' | 'or';
-export declare type FilterExpressionBuilder<T> = {
+import { Normalize, ODataFunctions, ODataOperators, Renderable } from './syntax';
+export type FilterConnector = 'and' | 'or';
+export type FilterExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: (connector?: FilterConnector) => FilterExpression<T>;
     o: ODataOperators<T>;
@@ -30,22 +30,22 @@ export declare class FilterExpression<F> extends Expression<F> {
         escape?: boolean;
         prefix?: string;
     }): string;
-    clone(): FilterExpression<unknown>;
+    clone(): FilterExpression<F>;
     private _add;
     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>;
+    eq(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    ne(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    gt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    ge(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    lt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    le(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    has(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    in(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    contains(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    startsWith(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    endsWith(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
     any<N extends object>(left: N[], opts?: (e: {
         e: (connector?: FilterConnector) => FilterExpression<N>;
         t: N;

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

@@ -8,7 +8,7 @@ export declare class OrderByField implements Renderable {
     get [Symbol.toStringTag](): string;
     toJSON(): {
         field: any;
-        order: "desc" | "asc";
+        order: "asc" | "desc";
     };
     render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
@@ -17,7 +17,7 @@ export declare class OrderByField implements Renderable {
     }): string;
     clone(): OrderByField;
 }
-export declare type OrderByExpressionBuilder<T> = {
+export type OrderByExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => OrderByExpression<T>;
 };
@@ -32,7 +32,7 @@ export declare class OrderByExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): OrderByExpression<unknown>;
+    clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
 }

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

@@ -1,7 +1,7 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
-export declare type SearchConnector = 'AND' | 'OR';
+export type SearchConnector = 'AND' | 'OR';
 export declare class SearchTerm implements Renderable {
     protected value: string;
     constructor(value: string);
@@ -17,7 +17,7 @@ export declare class SearchTerm implements Renderable {
     }): string;
     clone(): SearchTerm;
 }
-export declare type SearchExpressionBuilder<T> = {
+export type SearchExpressionBuilder<T> = {
     e: (connector?: SearchConnector) => SearchExpression<T>;
 };
 export declare class SearchExpression<T> extends Expression<T> {
@@ -35,7 +35,7 @@ export declare class SearchExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): SearchExpression<unknown>;
+    clone(): SearchExpression<T>;
     toJSON(): {
         children: any[];
         connector: SearchConnector;

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

@@ -1,7 +1,7 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
-export declare type SelectExpressionBuilder<T> = {
+export type SelectExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => SelectExpression<T>;
 };
@@ -15,7 +15,7 @@ export declare class SelectExpression<T> extends Expression<T> {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
-    clone(): SelectExpression<unknown>;
+    clone(): SelectExpression<T>;
     private _add;
     field(field: any): SelectExpression<T>;
 }