breeze-client 2.2.2 → 3.0.0

package/query/entity-query.d.ts

@@ -0,0 +1,521 @@
+import { Callback, ErrorCallback } from '../core/core.js';
+import { Entity } from '../entity/entity-aspect.js';
+import type { QueriedAs } from '../entity/entity-aspect.js';
+import { EntityKey } from '../entity/entity-key.js';
+import { BreezeEnum } from '../core/enum.js';
+import { DataService, JsonResultsAdapter } from '../metadata/data-service.js';
+import { EntityManager, QueryResult } from '../manager/entity-manager.js';
+import { EntityType, NavigationProperty } from '../metadata/entity-metadata.js';
+import { QueryOptions, MergeStrategy, FetchStrategy } from './query-options.js';
+import { Predicate } from './predicate.js';
+import type { CollectionElement, CollectionPath, FilterOpFor, FilterValueFor, FunctionExpressionPath, WhereObject, NavigationPath, OrderByPath, PropertyPath, PropertyValue, QuantifierOp, SelectPath } from './property-path.js';
+export interface RecursiveArray<T> {
+    [i: number]: T | RecursiveArray<T>;
+}
+export interface EntityQueryJsonContext {
+    entityType?: EntityType;
+    propertyPathFn?: Function;
+    toNameOnServer?: boolean;
+}
+/**
+An EntityQuery instance is used to query entities either from a remote datasource or from a local {@link EntityManager}.
+
+EntityQueries are immutable - this means that all EntityQuery methods that return an EntityQuery actually create a new EntityQuery.  This means that
+EntityQueries can be 'modified' without affecting any current instances.
+*/
+export declare class EntityQuery<T = any> {
+    /** The resource name used by this query. __Read Only__ */
+    resourceName?: string;
+    /** The {@link EntityType} that is associated with the 'from' clause ( resourceName) of the query.  This is only guaranteed to be be set AFTER the query
+    has been executed because it depends on the {@link MetadataStore} associated with the {@link EntityManager} that the query was executed against.
+    This value may be null if the entityType cannot be associated with a resourceName. __Read Only__ */
+    fromEntityType?: EntityType;
+    /** The 'where' {@link Predicate} used by this query. __Read Only__ */
+    wherePredicate?: Predicate;
+    /** The `OrderByClause` used by this query. __Read Only__ */
+    orderByClause?: OrderByClause;
+    /** The `ExpandClause` used by this query. __Read Only__ */
+    expandClause?: ExpandClause;
+    /** The `SelectClause` used by this query. __Read Only__ */
+    selectClause?: SelectClause;
+    /** The number of entities to 'skip' for this query. __Read Only__ */
+    skipCount?: number;
+    /** The number of entities to 'take' for this query. __Read Only__ */
+    takeCount?: number;
+    /** Any additional parameters that were added to the query via the 'withParameters' method. __Read Only__ */
+    parameters: Object;
+    /** Whether an inline count is returned for this query. __Read Only__ */
+    inlineCountEnabled: boolean;
+    /** Whether entity tracking has been disabled for this query. __Read Only__ */
+    noTrackingEnabled: boolean;
+    /** Whether to send query as the body of a POST request.  (Server needs to accomodate POST). __Read Only__ */
+    usePostEnabled: boolean;
+    /** The {@link QueryOptions} for this query. __Read Only__  */
+    queryOptions?: QueryOptions;
+    /** The {@link DataService} for this query. __Read Only__  */
+    dataService?: DataService;
+    /** The {@link EntityManager} for this query. This may be null and can be set via the 'using' method.  */
+    entityManager?: EntityManager;
+    /**  The entityType that will be returned by this query.
+    This property will only be set if the 'toType' method was called. __Read Only__ */
+    resultEntityType: EntityType | string;
+    /** Whether the query's property paths are the server's names, sent as written. Set by {@link EntityQuery.useNameOnServer}. __Read Only__ */
+    usesNameOnServer?: boolean;
+    /** Constructor. Most queries start from the static {@link EntityQuery.from} instead, which takes a
+    registered entity class and so gives a typed query:
+    ```ts
+    const query = EntityQuery.from(Customer);   // EntityQuery<Customer>
+    ```
+  
+    When a constructor is needed, supply the type argument. As with a type argument on
+    `EntityQuery.from(resourceName)`, nothing checks it against the resource name:
+    ```ts
+    const query = new EntityQuery<Customer>("Customers");
+    ```
+  
+    Usually this constructor will be followed by calls to filtering, ordering or selection methods
+    ```ts
+    const query = new EntityQuery<Customer>("Customers")
+      .where("companyName", "startsWith", "C")
+      .orderBy("region");
+    ```
+    @param resourceName - either a resource name or a serialized EntityQuery ( created by {@link EntityQuery.toJSON})
+    */
+    constructor(resourceName?: string | Object);
+    /**
+    Specifies the resource to query for this EntityQuery.
+    ```ts
+    const query = new EntityQuery()
+      .from("Customers");
+    ```
+  
+    is the same as
+    ```ts
+    const query = new EntityQuery("Customers");
+    ```
+  
+    For a typed query, use the static `EntityQuery.from(Customer)` instead.
+    @param resourceName - The resource to query.
+    */
+    from(resourceName: string): EntityQuery<T>;
+    /**
+    Creates a 'base' entityQuery, either for a registered entity class or for a resource name.
+  
+    Given a class, the resource name comes from the metadata and the query carries the type, so the
+    results are typed:
+    ```ts
+    const query = EntityQuery.from(Customer);            // EntityQuery<Customer>
+    const custs = (await query.using(em).execute()).results;   // Customer[]
+    ```
+  
+    The class must be registered with {@link MetadataStore.registerEntityTypeCtor}; that is what
+    tells Breeze which type it stands for, and an unregistered class throws.
+  
+    A resource name may be given instead; see the other signature.
+    @param entityCtor - A constructor registered for the EntityType to query.
+    */
+    static from<U extends Entity>(entityCtor: new () => U): EntityQuery<U>;
+    /**
+    Creates a 'base' entityQuery for the specified resource name. Prefer passing a registered entity
+    class, as in `EntityQuery.from(Customer)`, which gives a typed query.
+  
+    Given a resource name, the query is untyped, as it always was:
+    ```ts
+    const query = EntityQuery.from("Customers");
+    ```
+  
+    is the same as
+    ```ts
+    const query = new EntityQuery("Customers");
+    ```
+  
+    A type argument may be supplied with a resource name, for a projection or a named server query
+    that no entity class describes. **Nothing checks it against the resource** - it is an assertion,
+    not a guarantee, and `EntityQuery.from<Customer>("Orders")` compiles:
+    ```ts
+    const query = EntityQuery.from<CustomerDto>("CompanyNamesAndIds");
+    ```
+  
+    `U` is the caller's claim about what the resource returns; nothing checks it against the name.
+    It defaults to `any`, so `from("Customers")` behaves exactly as it always has.
+    @param resourceName - The resource to query.
+    */
+    static from<U = any>(resourceName: string): EntityQuery<U>;
+    /**
+    Specifies the top level type this query will return, as a registered constructor. The query then
+    carries that type, so its results are typed - and because the constructor is resolved through
+    metadata, this is *checked*, unlike a type argument on {@link EntityQuery.from}:
+    ```ts
+    const query = EntityQuery.from("CustomersAndOrders").toType(Customer);   // EntityQuery<Customer>
+    ```
+    @param entityCtor - A constructor registered for the EntityType this query will return.
+    @summary If the json result consists of more than a simple entity or array of entities, consider using a {@link JsonResultsAdapter} instead.
+    */
+    toType<U extends Entity>(entityCtor: new () => U): EntityQuery<U>;
+    /**
+    Specifies the top level EntityType that this query will return.  Only needed when a query returns a json result that does not include type information,
+    or when using a resource name that is not associated to an EntityType.
+    ```ts
+    const query = EntityQuery.from("MyCustomMethod")
+      .toType("Customer");
+    ```
+  
+    Passing the registered class instead, as in `toType(Customer)`, also types the query.
+    @param entityType - The top level EntityType that this query will return.
+    @summary If the json result consists of more than a simple entity or array of entities, consider using a {@link JsonResultsAdapter} instead.
+    */
+    toType(entityType: string | EntityType): EntityQuery<any>;
+    where<P extends CollectionPath<T>>(collection: P, quantifier: QuantifierOp | FilterQueryOp, predicate: Predicate<CollectionElement<T, P>>): EntityQuery<T>;
+    where(collection: CollectionPath<T>, quantifier: QuantifierOp | FilterQueryOp, property: string, quantifier2: QuantifierOp | FilterQueryOp, predicate: Predicate): EntityQuery<T>;
+    where(predicate: WhereObject<T>): EntityQuery<T>;
+    where(predicate?: Predicate<T>): EntityQuery<T>;
+    where<O extends string>(property: PropertyPath<T>, operator: string extends O ? O : never, value: any): EntityQuery<T>;
+    where<P extends string>(property: P extends FunctionExpressionPath ? P : (string extends P ? P : never), operator: string | FilterQueryOp, value: any): EntityQuery<T>;
+    where<P extends string>(collection: string extends P ? P : never, quantifier: string | FilterQueryOp, property: string, operator: string | FilterQueryOp, value: any): EntityQuery<T>;
+    where<P2 extends string>(collection: CollectionPath<T>, quantifier: string | FilterQueryOp, property: string extends P2 ? P2 : never, operator: string | FilterQueryOp, value: any): EntityQuery<T>;
+    where<O2 extends string>(collection: CollectionPath<T>, quantifier: string | FilterQueryOp, property: PropertyPath<CollectionElement<T, CollectionPath<T>>> | string, operator: string extends O2 ? O2 : never, value: any): EntityQuery<T>;
+    where(property: string, filterop: string, property2: string, filterop2: string, property3: string, filterop3: string, value: any): EntityQuery<T>;
+    where(anArray: RecursiveArray<string | number | FilterQueryOp | Predicate>): EntityQuery<T>;
+    where<P extends PropertyPath<T>, O extends FilterOpFor<PropertyValue<T, P>>>(property: P, operator: O, value: FilterValueFor<T, PropertyValue<T, P>, O>): EntityQuery<T>;
+    where<P extends CollectionPath<T>, P2 extends PropertyPath<CollectionElement<T, P>>, O2 extends FilterOpFor<PropertyValue<CollectionElement<T, P>, P2>>>(collection: P, quantifier: QuantifierOp, property: P2, operator: O2, value: FilterValueFor<CollectionElement<T, P>, PropertyValue<CollectionElement<T, P>, P2>, O2>): EntityQuery<T>;
+    orderBy(propertyPaths: OrderByPath<T> | OrderByPath<T>[], isDescending?: boolean): EntityQuery<T>;
+    orderBy<P extends string>(propertyPaths: P extends `${string},${string}` ? P : (string extends P ? P : never), isDescending?: boolean): EntityQuery<T>;
+    orderBy(propertyPaths?: undefined, isDescending?: boolean): EntityQuery<T>;
+    orderBy<P extends string>(propertyPaths: string extends P ? P[] : never, isDescending?: boolean): EntityQuery<T>;
+    orderByDesc(propertyPaths: OrderByPath<T> | OrderByPath<T>[]): EntityQuery<T>;
+    orderByDesc<P extends string>(propertyPaths: P extends `${string},${string}` ? P : (string extends P ? P : never)): EntityQuery<T>;
+    orderByDesc<P extends string>(propertyPaths: string extends P ? P[] : never): EntityQuery<T>;
+    /**
+    Returns a new query that selects a list of properties from the results of the original query and returns the values of just these properties. This
+    will be referred to as a projection.
+    If the result of this selection "projection" contains entities, these entities will automatically be added to EntityManager's cache and will
+    be made 'observable'.
+    Any simple properties, i.e. strings, numbers or dates within a projection will not be cached are will NOT be made 'observable'.
+    
+    Simple data properties can be projected
+    ```ts
+    const query = EntityQuery.from(Customer)
+        .where("companyName", "startsWith", "C")
+        .select("companyName");
+    ```
+  
+    This will return an array of objects each with a single "companyName" property of type string.
+    A similar query could return a navigation property instead
+    ```ts
+    const query = EntityQuery.from(Customer)
+       .where("companyName", "startsWith", "C")
+       .select("orders");
+    ```
+  
+    where the result would be an array of objects each with a single "orders" property that would itself be an array of "Order" entities.
+    Composite projections are also possible:
+    ```ts
+    const query = EntityQuery.from(Customer)
+       .where("companyName", "startsWith", "C")
+       .select("companyName, orders");
+    ```
+  
+    As well as projections involving nested property paths
+    ```ts
+    const query = EntityQuery.from(Order)
+       .where("customer.companyName", "startsWith", "C")
+       .select("customer.companyName, customer, orderDate");
+    ```
+  
+    The projected query is an `EntityQuery<any>`: its results are no longer entities of the queried type.
+    @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.
+    If 'propertyPaths' is either null or omitted then any existing projection on the query is removed.
+    */
+    select(propertyPaths: SelectPath<T> | SelectPath<T>[]): EntityQuery<any>;
+    select<P extends string>(propertyPaths: P extends `${string},${string}` ? P : (string extends P ? P : never)): EntityQuery<any>;
+    select(propertyPaths?: undefined): EntityQuery<any>;
+    select<P extends string>(propertyPaths: string extends P ? P[] : never): EntityQuery<any>;
+    /**
+    Returns a new query that skips the specified number of entities when returning results.
+    Any existing 'skip' can be cleared by calling 'skip' with no arguments.
+    ```ts
+    const query = EntityQuery.from(Customer)
+      .where("companyName", "startsWith", "C")
+      .skip(5);
+    ```
+    @param count - The number of entities to skip over. If omitted or null any existing skip count on the query is removed.
+    */
+    skip(count?: number): EntityQuery<T>;
+    /**
+    Returns a new query that returns only the specified number of entities when returning results. - Same as 'take'.
+    Any existing 'top' can be cleared by calling 'top' with no arguments.
+    ```ts
+    const query = EntityQuery.from(Customer)
+       .top(5);
+    ```
+    @param count - The number of entities to return.
+    If 'count' is either null or omitted then any existing 'top' count on the query is removed.
+    */
+    top(count?: number): EntityQuery<T>;
+    /**
+    Returns a new query that returns only the specified number of entities when returning results - Same as 'top'.
+    Any existing take can be cleared by calling take with no arguments.
+    ```ts
+    const query = EntityQuery.from(Customer)
+       .take(5);
+    ```
+    @param count - The number of entities to return.
+    If 'count' is either null or omitted then any existing 'take' count on the query is removed.
+    */
+    take(count?: number): EntityQuery<T>;
+    expand(propertyPaths: NavigationPath<T> | NavigationPath<T>[]): EntityQuery<T>;
+    expand<P extends string>(propertyPaths: P extends `${string},${string}` ? P : (string extends P ? P : never)): EntityQuery<T>;
+    expand<P extends string>(propertyPaths: string extends P ? P[] : never): EntityQuery<T>;
+    expand(propertyPaths?: undefined): EntityQuery<T>;
+    /**
+    Returns a new query that includes a collection of parameters to pass to the server.
+    ```ts
+    const query = EntityQuery.from("EmployeesFilteredByCountryAndBirthdate")
+       .toType(Employee)
+       .withParameters({ birthDate: "1/1/1960", country: "USA" });
+    ```
+     
+    will call the 'EmployeesFilteredByCountryAndBirthdate' method on the server and pass in 2 parameters. This
+    query will be uri encoded as
+    ```ts
+    {serviceApi}/EmployeesFilteredByCountryAndBirthdate?birthDate=1%2F1%2F1960&country=USA
+    ```
+  
+    Parameters may also be mixed in with other query criteria.
+    ```ts
+    const query = EntityQuery.from("EmployeesFilteredByCountryAndBirthdate")
+       .toType(Employee)
+       .withParameters({ birthDate: "1/1/1960", country: "USA" })
+       .where("lastName", "startsWith", "S")
+       .orderBy("birthDate");
+    ```
+    @param parameters - A parameters object where the keys are the parameter names and the values are the parameter values.
+    */
+    withParameters(parameters: Object): EntityQuery<T>;
+    /**
+    Returns a query with the `inlineCount` capability either enabled or disabled.  With `inlineCount` enabled, an additional 'inlineCount' property
+    will be returned with the query results that will contain the number of entities that would have been returned by this
+    query with only the 'where'/'filter' clauses applied, i.e. without any 'skip'/'take' operators applied. For local queries this clause is ignored.
+    ```ts
+    const query = EntityQuery.from(Customer)
+       .take(20)
+       .orderBy("companyName")
+       .inlineCount(true);
+    ```
+  
+    will return the first 20 customers as well as a count of _all_ of the customers in the remote store.
+    @param enabled - (default = true) Whether or not inlineCount capability should be enabled. If this parameter is omitted, true is assumed.
+    */
+    inlineCount(enabled?: boolean): EntityQuery<T>;
+    /**
+    Returns a query whose property paths are the server's names rather than the client's, so Breeze
+    sends them as written instead of translating them with the `MetadataStore`'s naming convention.
+    ```ts
+    EntityQuery.from('Customers').where('CompanyName', 'startsWith', 'A').useNameOnServer();
+    ```
+    The query is built from a resource name because a typed query, `EntityQuery.from(Customer)`,
+    checks its paths against the client's names and would reject `'CompanyName'`.
+    Only the query sent to the server is affected: run against the cache, a query works on the
+    client's objects and needs the client's names.
+    @param usesNameOnServer - (default = true)
+    */
+    useNameOnServer(usesNameOnServer?: boolean): EntityQuery<T>;
+    /**
+    Returns a query with the `noTracking` capability either enabled or disabled.  With `noTracking` enabled, the results of this query
+    will not be coerced into entities but will instead look like raw javascript projections. i.e. simple javascript objects.
+    ```ts
+    const query = EntityQuery.from(Customer)
+        .take(20)
+        .orderBy("companyName")
+        .noTracking(true);
+    ```
+    @param enabled - (default = true) Whether or not the noTracking capability should be enabled. If this parameter is omitted, true is assumed.
+    */
+    noTracking(enabled?: boolean): EntityQuery<T>;
+    /**
+    Returns a query with the `usePost` capability either enabled or disabled.  With `usePost` enabled, the query is sent
+    as a POST request (instead of GET) and the query expression will be sent as JSON in the body of the post.
+    Note that the server must be able to parse the body of the request; otherwise the query expression will be ignored.
+    ```ts
+    const query = EntityQuery.from(Order)
+        .where("freight", "gt", 100)
+        .usePost(true);
+    ```
+    results in a POST request to `{host}/{path}/Orders`
+    with body `{"where": {"Freight":{"gt":100}}}`
+    @param enabled - (default = true) Whether or not usePost should be enabled. If this parameter is omitted, true is assumed.
+    */
+    usePost(enabled?: boolean): EntityQuery<T>;
+    using(obj: EntityManager): EntityQuery<T>;
+    using(obj: DataService): EntityQuery<T>;
+    using(obj: JsonResultsAdapter): EntityQuery<T>;
+    using(obj: QueryOptions): EntityQuery<T>;
+    using(obj: MergeStrategy): EntityQuery<T>;
+    using(obj: FetchStrategy): EntityQuery<T>;
+    execute(): Promise<QueryResult<T>>;
+    /** @deprecated Await the returned promise instead of passing callbacks. */
+    execute(callback?: Callback, errorCallback?: ErrorCallback): Promise<QueryResult<T>>;
+    /**
+    Executes this query against the local cache.  This method requires that an EntityManager have been previously specified via the "using" method.
+    ```ts
+    // assume em is an entityManager already filled with order entities;
+    const query = EntityQuery.from(Order).using(em);
+    const orders = query.executeLocally();   // Order[]
+    ```
+  
+    Note that calling this method is the same as calling {@link EntityManager.executeQueryLocally}.
+    */
+    executeLocally(): T[];
+    /**
+    Executes this query against the server and returns only the number of matching entities, without
+    materializing any of them. Requires an EntityManager, set via {@link EntityQuery.using}.
+    ```ts
+    const count = await EntityQuery.from(Order).where("freight", ">", 100).using(em).executeCount();
+    ```
+  
+    It is `take(0).inlineCount(true)` and reads `inlineCount` off the result, so the server must
+    support inline count.
+    */
+    executeCount(): Promise<number>;
+    /**
+    Returns the serializable form of this query: its resource name, clauses, parameters and options,
+    with client property names. `JSON.stringify` calls it, and passing the parsed JSON to the
+    `EntityQuery` constructor recreates the query. The `EntityManager` and `DataService` are not
+    included.
+    */
+    toJSON(): Record<string, any>;
+    static fromEntities<U extends Entity>(entity: U): EntityQuery<QueriedAs<U>>;
+    static fromEntities<U extends Entity>(entities: U[]): EntityQuery<QueriedAs<U>>;
+    /**
+    Creates an EntityQuery for the specified {@link EntityKey}.
+    ```ts
+    const entityKey = new EntityKey(Employee, 1);
+    const query = EntityQuery.fromEntityKey(entityKey);
+    ```
+  
+    or
+    ```ts
+    // 'employee' is a previously queried employee
+    const entityKey = employee.entityAspect.getKey();
+    const query = EntityQuery.fromEntityKey(entityKey);
+    ```
+    @param entityKey - The {@link EntityKey} for which a query will be created.
+    */
+    static fromEntityKey(entityKey: EntityKey): EntityQuery<any>;
+    /**
+    Creates an EntityQuery for the specified entity and {@link NavigationProperty}.
+    ```ts
+    // 'employee' is a previously queried employee
+    const query = EntityQuery.fromEntityNavigation(employee, "orders");
+    ```
+  
+    will return a query for the "orders" of the specified 'employee'. The {@link NavigationProperty}
+    itself may be passed instead of its name:
+    ```ts
+    const ordersNavProp = employee.entityType.getNavigationProperty("orders");
+    const query = EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+    ```
+    @param entity - The Entity whose navigation property will be queried.
+    @param navigationProperty - The {@link NavigationProperty} or name of the NavigationProperty to be queried.
+    */
+    static fromEntityNavigation: (entity: Entity, navigationProperty: NavigationProperty | string) => EntityQuery<any>;
+}
+/** Base class for BooleanQueryOp and FilterQueryOp */
+export interface QueryOp {
+    /** The operator for this enum. */
+    operator: string;
+}
+/**
+FilterQueryOp is an 'Enum' containing all of the valid  {@link Predicate}
+filter operators for an {@link EntityQuery}.
+*/
+export declare class FilterQueryOp extends BreezeEnum implements QueryOp {
+    /** The operator for this enum. */
+    operator: string;
+    /** Aliases: "eq", "==" */
+    static Equals: FilterQueryOp;
+    /**  Aliases: "ne", "!="  */
+    static NotEquals: FilterQueryOp;
+    /** Aliases: "gt", ">"   */
+    static GreaterThan: FilterQueryOp;
+    /** Aliases: "lt", "<"  */
+    static LessThan: FilterQueryOp;
+    /**  Aliases: "ge", ">="  */
+    static GreaterThanOrEqual: FilterQueryOp;
+    /**  Aliases: "le", "<="  */
+    static LessThanOrEqual: FilterQueryOp;
+    /**  String operation: Is a string a substring of another string.  Aliases: "substringof"   */
+    static Contains: FilterQueryOp;
+    /** No aliases */
+    static StartsWith: FilterQueryOp;
+    /** No aliases */
+    static EndsWith: FilterQueryOp;
+    /**  Aliases: "some"  */
+    static Any: FilterQueryOp;
+    /**  Aliases: "every"  */
+    static All: FilterQueryOp;
+    /** No aliases */
+    static In: FilterQueryOp;
+}
+/**
+ BooleanQueryOp is an 'Enum' containing all of the valid  boolean
+operators for an {@link EntityQuery}.
+*/
+export declare class BooleanQueryOp extends BreezeEnum implements QueryOp {
+    /** The operator for this enum. */
+    operator: string;
+    static And: BooleanQueryOp;
+    static Or: BooleanQueryOp;
+    static Not: BooleanQueryOp;
+}
+/** For use by breeze plugin authors only.  The class is used in most {@link UriBuilderAdapter} implementations
+@adapter (see {@link UriBuilderAdapter})
+@hidden
+
+An OrderByClause is a description of the properties and direction that the result
+of a query should be sorted in.  OrderByClauses are immutable, which means that any
+method that would modify an OrderByClause actually returns a new OrderByClause.
+
+For example for an Employee object with properties of 'company' and 'lastName' the following would be valid expressions:
+```ts
+const obc = new OrderByClause(["company.companyName", "lastName"]);
+```
+
+or
+```ts
+const obc = new OrderByClause(["company.companyName desc", "lastName"]);
+```
+
+or
+```ts
+const obc = new OrderByClause(["company.companyName", "lastName"], true);
+```
+*/
+export declare class OrderByClause {
+    constructor(propertyPaths: string[] | OrderByClause[], isDesc?: boolean);
+    validate(entityType: EntityType): void;
+    getComparer(entityType: EntityType): (entity1: any, entity2: any) => number;
+    toJSONExt(context: EntityQueryJsonContext): string[];
+}
+/** For use by breeze plugin authors only.  The class is used in most {@link UriBuilderAdapter} implementations
+@adapter (see {@link UriBuilderAdapter})
+@hidden
+*/
+export declare class SelectClause {
+    propertyPaths: string[];
+    constructor(propertyPaths: string[]);
+    validate(entityType: EntityType): void;
+    toFunction(config?: {
+        entityType?: EntityType;
+    }): (entity: Entity) => {};
+    toJSONExt(context: EntityQueryJsonContext): any[];
+}
+/** For use by breeze plugin authors only.  The class is used in most {@link UriBuilderAdapter} implementations
+@adapter (see {@link UriBuilderAdapter})
+@hidden
+*/
+export declare class ExpandClause {
+    propertyPaths: string[];
+    constructor(propertyPaths: string[]);
+    toJSONExt(context: EntityQueryJsonContext): any[];
+}