breeze-client 2.2.1 → 3.0.0

package/{src → query}/query-options.d.ts

@@ -1,119 +1,143 @@
-import { BreezeEnum } from './enum';
-/**
-MergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.
-
-@class MergeStrategy
-@static
-**/
-export declare class MergeStrategy extends BreezeEnum {
-    /**
-    MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed
-    state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will
-    remain [[EntityState.Unchanged]] unless you’re importing entities in which case the new EntityState will
-    be that of the imported entities.
-    **/
-    static PreserveChanges: MergeStrategy;
-    /**
-    MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in
-    a changed state (added, modified, deleted). After the merge, the pending changes are lost.
-    The new EntityState will be  [[EntityState/Unchanged]] unless you’re importing entities
-    in which case the new EntityState will be that of the imported entities.
-    **/
-    static OverwriteChanges: MergeStrategy;
-    /**
-    SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.
-    This is the fastest merge strategy but your existing cached data will remain “stale”.
-    **/
-    static SkipMerge: MergeStrategy;
-    /**
-    Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.
-    Use this strategy when you want to be sure that the incoming entity is not already in cache.
-    This is the default strategy for EntityManager.attachEntity.
-    **/
-    static Disallowed: MergeStrategy;
-}
-/**
-FetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.
-**/
-export declare class FetchStrategy extends BreezeEnum {
-    /**
-    FromServer is used to tell the query to execute the query against a remote data source on the server.
-    **/
-    static FromServer: FetchStrategy;
-    /**
-    FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.
-    **/
-    static FromLocalCache: FetchStrategy;
-}
-/** Configuration info to be passed to the [[QueryOptions]] constructor. */
-export interface QueryOptionsConfig {
-    /** The [[FetchStrategy]] to use with any queries.*/
-    fetchStrategy?: FetchStrategy;
-    /** The [[MergeStrategy]] to use with any queries.*/
-    mergeStrategy?: MergeStrategy;
-    /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */
-    includeDeleted?: boolean;
-}
-/**
-A QueryOptions instance is used to specify the 'options' under which a query will occur.
-**/
-export declare class QueryOptions {
-    /** @hidden @internal */
-    _$typeName: string;
-    /** The [[FetchStrategy]] to use with any queries. __Read Only__ */
-    fetchStrategy: FetchStrategy;
-    /** The [[MergeStrategy]] to use with any queries. __Read Only__ */
-    mergeStrategy: MergeStrategy;
-    /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */
-    includeDeleted: boolean;
-    /**
-    The default instance for use whenever QueryOptions are not specified.
-    **/
-    static defaultInstance: QueryOptions;
-    /**
-    QueryOptions constructor
-    >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
-    >     // assume em1 is a preexisting EntityManager
-    >     em1.setProperties( { queryOptions: newQo });
-    Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.
-    -  from query.queryOptions
-    -  to   entityManager.queryOptions
-    -  to   QueryOptions.defaultInstance;
-  
-    @param config - A configuration object.
-    **/
-    constructor(config?: QueryOptionsConfig);
-    static resolve(queryOptionsArray: any[]): QueryOptions;
-    /**
-    Returns a copy of this QueryOptions with the specified [[MergeStrategy]],
-    [[FetchStrategy]], or 'includeDeleted' option applied.
-    >     // Given an EntityManager instance, em
-    >     var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);
-  
-    or
-    >     var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);
-  
-    or
-    >     var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });
-  
-    or
-    >     var queryOptions = em.queryOptions.using({
-    >        includeDeleted: true,
-    >        fetchStrategy:  FetchStrategy.FromLocalCache
-    >     });
-    @param config - A configuration object or a standalone [[MergeStrategy]] or [[FetchStrategy]]
-    @return A new QueryOptions instance.
-    **/
-    using(qoConfig: QueryOptionsConfig | MergeStrategy | FetchStrategy): QueryOptions;
-    /**
-    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
-    The current instance is returned unchanged.
-    >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
-    >     newQo.setAsDefault();
-    **/
-    setAsDefault(): any;
-    toJSON(): Object;
-    static fromJSON(json: any): QueryOptions;
-    /** @hidden @internal */
-    private static _updateWithConfig;
-}
+import { BreezeEnum } from '../core/enum.js';
+/**
+MergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.
+
+*/
+export declare class MergeStrategy extends BreezeEnum {
+    /**
+    MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed
+    state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will
+    remain {@link EntityState.Unchanged} unless you’re importing entities in which case the new EntityState will
+    be that of the imported entities.
+    */
+    static PreserveChanges: MergeStrategy;
+    /**
+    MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in
+    a changed state (added, modified, deleted). After the merge, the pending changes are lost.
+    The new EntityState will be  {@link EntityState.Unchanged} unless you’re importing entities
+    in which case the new EntityState will be that of the imported entities.
+    */
+    static OverwriteChanges: MergeStrategy;
+    /**
+    SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.
+    This is the fastest merge strategy but your existing cached data will remain “stale”.
+    */
+    static SkipMerge: MergeStrategy;
+    /**
+    Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.
+    Use this strategy when you want to be sure that the incoming entity is not already in cache.
+    This is the default strategy for EntityManager.attachEntity.
+    */
+    static Disallowed: MergeStrategy;
+}
+/**
+FetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.
+*/
+export declare class FetchStrategy extends BreezeEnum {
+    /**
+    FromServer is used to tell the query to execute the query against a remote data source on the server.
+    */
+    static FromServer: FetchStrategy;
+    /**
+    FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.
+    */
+    static FromLocalCache: FetchStrategy;
+}
+/** Configuration info to be passed to the {@link QueryOptions} constructor. */
+export interface QueryOptionsConfig {
+    /** The {@link FetchStrategy} to use with any queries.*/
+    fetchStrategy?: FetchStrategy;
+    /** The {@link MergeStrategy} to use with any queries.*/
+    mergeStrategy?: MergeStrategy;
+    /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */
+    includeDeleted?: boolean;
+}
+/**
+A QueryOptions instance is used to specify the 'options' under which a query will occur.
+*/
+export declare class QueryOptions {
+    /** The {@link FetchStrategy} to use with any queries. __Read Only__ */
+    fetchStrategy: FetchStrategy;
+    /** The {@link MergeStrategy} to use with any queries. __Read Only__ */
+    mergeStrategy: MergeStrategy;
+    /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */
+    includeDeleted: boolean;
+    /**
+    The default instance for use whenever QueryOptions are not specified.
+    */
+    static defaultInstance: QueryOptions;
+    /**
+    QueryOptions constructor
+    ```ts
+    var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    // assume em1 is a preexisting EntityManager
+    em1.setProperties( { queryOptions: newQo });
+    ```
+    Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.
+    -  from query.queryOptions
+    -  to   entityManager.queryOptions
+    -  to   QueryOptions.defaultInstance;
+  
+    @param config - A configuration object.
+    */
+    constructor(config?: QueryOptionsConfig);
+    /**
+    Combines several QueryOptions into one, taking each property from the first of them that has it
+    set. Breeze uses it to combine a query's own options with its EntityManager's and
+    {@link QueryOptions.defaultInstance}; applications do not normally need it.
+    @param queryOptionsArray - The QueryOptions to combine, most specific first. Entries may be null
+    or undefined.
+    */
+    static resolve(queryOptionsArray: any[]): QueryOptions;
+    /**
+    Returns a copy of this QueryOptions with the specified {@link MergeStrategy},
+    {@link FetchStrategy}, or 'includeDeleted' option applied.
+    ```ts
+    // Given an EntityManager instance, em
+    var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using({
+       includeDeleted: true,
+       fetchStrategy:  FetchStrategy.FromLocalCache
+    });
+    ```
+    @param qoConfig - A configuration object or a standalone {@link MergeStrategy} or {@link FetchStrategy}
+    @returns A new QueryOptions instance.
+    */
+    using(qoConfig: QueryOptionsConfig | MergeStrategy | FetchStrategy): QueryOptions;
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    ```ts
+    var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    newQo.setAsDefault();
+    ```
+    */
+    setAsDefault(): any;
+    /**
+    Returns the serializable form of these options: the names of the `fetchStrategy` and
+    `mergeStrategy`, and `includeDeleted` when it is `true`. `JSON.stringify` calls it when
+    `EntityManager.exportEntities` exports the manager's options and when a query is serialized;
+    {@link QueryOptions.fromJSON} reads it back.
+    */
+    toJSON(): Object;
+    /**
+    Creates a QueryOptions from the output of {@link QueryOptions.toJSON}. Used by
+    `EntityManager.importEntities` and when a serialized query is read back.
+    @param json - A serialized QueryOptions.
+    */
+    static fromJSON(json: any): QueryOptions;
+}

package/query/query-options.js

@@ -0,0 +1,180 @@
+import { core } from '../core/core.js';
+import { BreezeEnum } from '../core/enum.js';
+import { assertConfig } from '../core/assert-param.js';
+/**
+MergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.
+
+*/
+export class MergeStrategy extends BreezeEnum {
+    /**
+    MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed
+    state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will
+    remain {@link EntityState.Unchanged} unless you’re importing entities in which case the new EntityState will
+    be that of the imported entities.
+    */
+    static PreserveChanges = new MergeStrategy();
+    /**
+    MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in
+    a changed state (added, modified, deleted). After the merge, the pending changes are lost.
+    The new EntityState will be  {@link EntityState.Unchanged} unless you’re importing entities
+    in which case the new EntityState will be that of the imported entities.
+    */
+    static OverwriteChanges = new MergeStrategy();
+    /**
+    SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.
+    This is the fastest merge strategy but your existing cached data will remain “stale”.
+    */
+    static SkipMerge = new MergeStrategy();
+    /**
+    Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.
+    Use this strategy when you want to be sure that the incoming entity is not already in cache.
+    This is the default strategy for EntityManager.attachEntity.
+    */
+    static Disallowed = new MergeStrategy();
+}
+MergeStrategy.prototype._$typeName = "MergeStrategy";
+MergeStrategy.resolveSymbols();
+/**
+FetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.
+*/
+export class FetchStrategy extends BreezeEnum {
+    /**
+    FromServer is used to tell the query to execute the query against a remote data source on the server.
+    */
+    static FromServer = new FetchStrategy();
+    /**
+    FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.
+    */
+    static FromLocalCache = new FetchStrategy();
+}
+FetchStrategy.prototype._$typeName = "FetchStrategy";
+FetchStrategy.resolveSymbols();
+/**
+A QueryOptions instance is used to specify the 'options' under which a query will occur.
+*/
+export class QueryOptions {
+    /**
+    The default instance for use whenever QueryOptions are not specified.
+    */
+    static defaultInstance = new QueryOptions({
+        fetchStrategy: FetchStrategy.FromServer,
+        mergeStrategy: MergeStrategy.PreserveChanges,
+        includeDeleted: false
+    });
+    /**
+    QueryOptions constructor
+    ```ts
+    var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    // assume em1 is a preexisting EntityManager
+    em1.setProperties( { queryOptions: newQo });
+    ```
+    Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.
+    -  from query.queryOptions
+    -  to   entityManager.queryOptions
+    -  to   QueryOptions.defaultInstance;
+  
+    @param config - A configuration object.
+    */
+    constructor(config) {
+        QueryOptions._updateWithConfig(this, config);
+    }
+    /**
+    Combines several QueryOptions into one, taking each property from the first of them that has it
+    set. Breeze uses it to combine a query's own options with its EntityManager's and
+    {@link QueryOptions.defaultInstance}; applications do not normally need it.
+    @param queryOptionsArray - The QueryOptions to combine, most specific first. Entries may be null
+    or undefined.
+    */
+    static resolve(queryOptionsArray) {
+        return new QueryOptions(core.resolveProperties(queryOptionsArray, ["fetchStrategy", "mergeStrategy", "includeDeleted"]));
+    }
+    /**
+    Returns a copy of this QueryOptions with the specified {@link MergeStrategy},
+    {@link FetchStrategy}, or 'includeDeleted' option applied.
+    ```ts
+    // Given an EntityManager instance, em
+    var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });
+    ```
+  
+    or
+    ```ts
+    var queryOptions = em.queryOptions.using({
+       includeDeleted: true,
+       fetchStrategy:  FetchStrategy.FromLocalCache
+    });
+    ```
+    @param qoConfig - A configuration object or a standalone {@link MergeStrategy} or {@link FetchStrategy}
+    @returns A new QueryOptions instance.
+    */
+    using(qoConfig) {
+        if (!qoConfig)
+            return this;
+        let result = new QueryOptions(this);
+        if (qoConfig instanceof MergeStrategy) {
+            qoConfig = { mergeStrategy: qoConfig };
+        }
+        else if (qoConfig instanceof FetchStrategy) {
+            qoConfig = { fetchStrategy: qoConfig };
+        }
+        return QueryOptions._updateWithConfig(result, qoConfig);
+    }
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    ```ts
+    var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    newQo.setAsDefault();
+    ```
+    */
+    setAsDefault() {
+        return core.setAsDefault(this, QueryOptions);
+    }
+    /**
+    Returns the serializable form of these options: the names of the `fetchStrategy` and
+    `mergeStrategy`, and `includeDeleted` when it is `true`. `JSON.stringify` calls it when
+    `EntityManager.exportEntities` exports the manager's options and when a query is serialized;
+    {@link QueryOptions.fromJSON} reads it back.
+    */
+    toJSON() {
+        return core.toJson(this, {
+            fetchStrategy: null,
+            mergeStrategy: null,
+            includeDeleted: false
+        });
+    }
+    /**
+    Creates a QueryOptions from the output of {@link QueryOptions.toJSON}. Used by
+    `EntityManager.importEntities` and when a serialized query is read back.
+    @param json - A serialized QueryOptions.
+    */
+    static fromJSON(json) {
+        return new QueryOptions({
+            fetchStrategy: FetchStrategy.fromName(json.fetchStrategy),
+            mergeStrategy: MergeStrategy.fromName(json.mergeStrategy),
+            includeDeleted: json.includeDeleted === true
+        });
+    }
+    /** @hidden @internal */
+    static _updateWithConfig(obj, config) {
+        if (config) {
+            assertConfig(config)
+                .whereParam("fetchStrategy").isEnumOf(FetchStrategy).isOptional()
+                .whereParam("mergeStrategy").isEnumOf(MergeStrategy).isOptional()
+                .whereParam("includeDeleted").isBoolean().isOptional()
+                .applyAll(obj);
+        }
+        return obj;
+    }
+}
+QueryOptions.prototype._$typeName = "QueryOptions";
+//# sourceMappingURL=query-options.js.map

package/query/query-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.js","sourceRoot":"","sources":["../../src/query/query-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from '../core/core.js';\nimport { BreezeEnum } from '../core/enum.js';\nimport { assertConfig } from '../core/assert-param.js';\n\n/**\nMergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.\n\n*/\nexport class MergeStrategy extends BreezeEnum {\n\n  /**\n  MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed\n  state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will\n  remain {@link EntityState.Unchanged} unless you’re importing entities in which case the new EntityState will\n  be that of the imported entities.\n  */\n  static PreserveChanges = new MergeStrategy();\n  /**\n  MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in\n  a changed state (added, modified, deleted). After the merge, the pending changes are lost.\n  The new EntityState will be  {@link EntityState.Unchanged} unless you’re importing entities\n  in which case the new EntityState will be that of the imported entities.\n  */\n  static OverwriteChanges = new MergeStrategy();\n\n  /**\n  SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.\n  This is the fastest merge strategy but your existing cached data will remain “stale”.\n  */\n  static SkipMerge = new MergeStrategy();\n\n  /**\n  Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.\n  Use this strategy when you want to be sure that the incoming entity is not already in cache.\n  This is the default strategy for EntityManager.attachEntity.\n  */\n  static Disallowed = new MergeStrategy();\n\n\n}\nMergeStrategy.prototype._$typeName = \"MergeStrategy\";\nMergeStrategy.resolveSymbols();\n\n/**\nFetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.\n*/\nexport class FetchStrategy extends BreezeEnum {\n\n  /**\n  FromServer is used to tell the query to execute the query against a remote data source on the server.\n  */\n  static FromServer = new FetchStrategy();\n  /**\n  FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.\n  */\n  static FromLocalCache = new FetchStrategy();\n\n}\nFetchStrategy.prototype._$typeName = \"FetchStrategy\";\nFetchStrategy.resolveSymbols();\n\n/** Configuration info to be passed to the {@link QueryOptions} constructor. */\nexport interface QueryOptionsConfig {\n  /** The {@link FetchStrategy} to use with any queries.*/\n  fetchStrategy?: FetchStrategy;\n  /** The {@link MergeStrategy} to use with any queries.*/\n  mergeStrategy?: MergeStrategy;\n  /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */\n  includeDeleted?: boolean;\n}\n\n/**\nA QueryOptions instance is used to specify the 'options' under which a query will occur.\n*/\nexport class QueryOptions {\n  /** @hidden @internal */\n  declare _$typeName: string;\n  /** The {@link FetchStrategy} to use with any queries. __Read Only__ */\n  declare fetchStrategy: FetchStrategy;\n  /** The {@link MergeStrategy} to use with any queries. __Read Only__ */\n  declare mergeStrategy: MergeStrategy;\n  /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */\n  declare includeDeleted: boolean;\n\n  /**\n  The default instance for use whenever QueryOptions are not specified.\n  */\n  static defaultInstance = new QueryOptions({\n    fetchStrategy: FetchStrategy.FromServer,\n    mergeStrategy: MergeStrategy.PreserveChanges,\n    includeDeleted: false\n  });\n\n  /**\n  QueryOptions constructor\n  ```ts\n  var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });\n  // assume em1 is a preexisting EntityManager\n  em1.setProperties( { queryOptions: newQo });\n  ```\n  Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.\n  -  from query.queryOptions\n  -  to   entityManager.queryOptions\n  -  to   QueryOptions.defaultInstance;\n\n  @param config - A configuration object.\n  */\n  constructor(config?: QueryOptionsConfig) {\n    QueryOptions._updateWithConfig(this, config);\n  }\n\n  /**\n  Combines several QueryOptions into one, taking each property from the first of them that has it\n  set. Breeze uses it to combine a query's own options with its EntityManager's and\n  {@link QueryOptions.defaultInstance}; applications do not normally need it.\n  @param queryOptionsArray - The QueryOptions to combine, most specific first. Entries may be null\n  or undefined.\n  */\n  static resolve(queryOptionsArray: any[]) {\n    return new QueryOptions(core.resolveProperties(queryOptionsArray, [\"fetchStrategy\", \"mergeStrategy\", \"includeDeleted\"]));\n  }\n\n  /**\n  Returns a copy of this QueryOptions with the specified {@link MergeStrategy},\n  {@link FetchStrategy}, or 'includeDeleted' option applied.\n  ```ts\n  // Given an EntityManager instance, em\n  var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);\n  ```\n\n  or\n  ```ts\n  var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);\n  ```\n\n  or\n  ```ts\n  var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });\n  ```\n\n  or\n  ```ts\n  var queryOptions = em.queryOptions.using({\n     includeDeleted: true,\n     fetchStrategy:  FetchStrategy.FromLocalCache \n  });\n  ```\n  @param qoConfig - A configuration object or a standalone {@link MergeStrategy} or {@link FetchStrategy} \n  @returns A new QueryOptions instance.\n  */\n  using(qoConfig: QueryOptionsConfig | MergeStrategy | FetchStrategy) {\n    if (!qoConfig) return this;\n    let result = new QueryOptions(this);\n    if ( qoConfig instanceof MergeStrategy) {\n      qoConfig = { mergeStrategy: qoConfig };\n    } else if ( qoConfig instanceof FetchStrategy) {\n      qoConfig = { fetchStrategy: qoConfig };\n    }\n    return QueryOptions._updateWithConfig(result, qoConfig);\n  }\n\n  /**\n  Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.\n  The current instance is returned unchanged.\n  ```ts\n  var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });\n  newQo.setAsDefault();\n  ```\n  */\n  setAsDefault() {\n    return core.setAsDefault(this, QueryOptions);\n  }\n\n  /**\n  Returns the serializable form of these options: the names of the `fetchStrategy` and\n  `mergeStrategy`, and `includeDeleted` when it is `true`. `JSON.stringify` calls it when\n  `EntityManager.exportEntities` exports the manager's options and when a query is serialized;\n  {@link QueryOptions.fromJSON} reads it back.\n  */\n  toJSON() {\n    return core.toJson(this, {\n      fetchStrategy: null,\n      mergeStrategy: null,\n      includeDeleted: false\n    });\n  }\n\n  /**\n  Creates a QueryOptions from the output of {@link QueryOptions.toJSON}. Used by\n  `EntityManager.importEntities` and when a serialized query is read back.\n  @param json - A serialized QueryOptions.\n  */\n  static fromJSON(json: any) {\n    return new QueryOptions({\n      fetchStrategy: FetchStrategy.fromName(json.fetchStrategy),\n      mergeStrategy: MergeStrategy.fromName(json.mergeStrategy),\n      includeDeleted: json.includeDeleted === true\n    });\n  }\n\n  /** @hidden @internal */\n  private static _updateWithConfig(obj: QueryOptions, config?: QueryOptionsConfig) {\n    if (config) {\n      assertConfig(config)\n        .whereParam(\"fetchStrategy\").isEnumOf(FetchStrategy).isOptional()\n        .whereParam(\"mergeStrategy\").isEnumOf(MergeStrategy).isOptional()\n        .whereParam(\"includeDeleted\").isBoolean().isOptional()\n        .applyAll(obj);\n    }\n    return obj;\n  }\n\n}\nQueryOptions.prototype._$typeName = \"QueryOptions\";\n"]}

package/rxjs/breeze-rxjs.d.ts

@@ -0,0 +1,72 @@
+import { Observable } from 'rxjs';
+import type { BreezeEvent } from '../core/event.js';
+import type { Entity, PropertyChangedEventArgs } from '../entity/entity-aspect.js';
+import type { EntityChangedEventArgs, EntityManager, ValidationErrorsChangedEventArgs } from '../manager/entity-manager.js';
+/**
+ * Any {@link BreezeEvent} as an Observable: each value the event publishes is emitted, for as long
+ * as the subscription lasts.
+ *
+ * The other functions in this module are this, applied to a particular event. Use it directly for
+ * the ones they do not cover - `metadataStore.metadataFetched`, say.
+ *
+ * ```ts
+ * fromBreezeEvent(em.metadataStore.metadataFetched).subscribe(args => console.log(args.metadata));
+ * ```
+ *
+ * An error thrown by a subscriber does not reach Breeze: rxjs reports it on its own, and the
+ * event's other subscribers still hear about the change.
+ *
+ * @param event - the event to observe
+ * @returns an Observable that subscribes to `event` when it is subscribed to, and unsubscribes when
+ * it is torn down
+ */
+export declare function fromBreezeEvent<T>(event: BreezeEvent<T>): Observable<T>;
+/**
+ * {@link EntityManager.entityChanged} as an Observable: every entity added, attached, detached,
+ * changed, saved or rejected in `em`.
+ *
+ * Filter for what you want with rxjs:
+ *
+ * ```ts
+ * entityChanged$(em).pipe(
+ *   filter(e => e.entityAction === EntityAction.PropertyChange),
+ * ).subscribe(e => markDirty(e.entity));
+ * ```
+ */
+export declare function entityChanged$(em: EntityManager): Observable<EntityChangedEventArgs>;
+/**
+ * Whether `em` has unsaved changes, as an Observable that starts with the current value.
+ *
+ * {@link EntityManager.hasChangesChanged} only fires on a change, so on its own it cannot tell a
+ * late subscriber what the answer is *now*. This emits `em.hasChanges()` as soon as it is
+ * subscribed to, then each change after that, and never the same value twice in a row. Bind a Save
+ * button to it and the button is right from the first render.
+ *
+ * ```ts
+ * hasChanges$(em).subscribe(dirty => saveButton.disabled = !dirty);
+ * ```
+ *
+ * The current value is read when you subscribe, not when you call this function.
+ */
+export declare function hasChanges$(em: EntityManager): Observable<boolean>;
+/**
+ * {@link EntityManager.validationErrorsChanged} as an Observable: validation errors added to or
+ * removed from any entity in `em`.
+ *
+ * Each value says what changed, not the complete set. For "every validation error in the manager
+ * right now", see the recipe in the guide, which builds one from this.
+ */
+export declare function validationErrorsChanged$(em: EntityManager): Observable<ValidationErrorsChangedEventArgs>;
+/**
+ * {@link EntityAspect.propertyChanged} as an Observable: each property of one entity that changes.
+ *
+ * ```ts
+ * propertyChanged$(order).pipe(
+ *   filter(e => e.propertyName === 'shipCountry'),
+ * ).subscribe(() => recalculateTax(order));
+ * ```
+ *
+ * A live subscription keeps `entity` reachable, as any subscription to it would. Unsubscribe when
+ * the screen showing it goes away.
+ */
+export declare function propertyChanged$(entity: Entity): Observable<PropertyChangedEventArgs>;