@ethlete/query 6.0.0-next.62 → 6.0.0-next.63

package/generators/migrate-to-query-v3/module-resolution.js

@@ -0,0 +1,131 @@
+import { joinPathFragments, readJson, visitNotIgnoredFiles } from '@nx/devkit';
+import { dirname } from 'node:path';
+import { createModuleGraph } from './module-graph.js';
+const PROJECT_TSCONFIGS = ['tsconfig.lib.json', 'tsconfig.app.json', 'tsconfig.spec.json'];
+const LEGACY_RESOLUTIONS = new Set(['node', 'node10']);
+const MODULE_SPECIFIER = /(?:\bfrom\s*|\bimport\s*\(?\s*)['"]([^'"]+)['"]/g;
+const projectRootOf = (tree, filePath) => {
+    let dir = dirname(filePath);
+    while (dir !== '.' && dir !== '/' && dir !== '') {
+        if (tree.exists(joinPathFragments(dir, 'project.json')))
+            return dir;
+        dir = dirname(dir);
+    }
+    return null;
+};
+const effectiveModuleResolution = (tree, configPath, seen = new Set()) => {
+    if (seen.has(configPath) || !tree.exists(configPath))
+        return null;
+    seen.add(configPath);
+    const config = readJson(tree, configPath);
+    const own = config.compilerOptions?.moduleResolution;
+    if (own)
+        return own.toLowerCase();
+    const parents = config.extends === undefined ? [] : [config.extends].flat();
+    for (const parent of [...parents].reverse()) {
+        if (!parent.startsWith('.'))
+            continue;
+        const resolved = effectiveModuleResolution(tree, joinPathFragments(dirname(configPath), parent.endsWith('.json') ? parent : `${parent}.json`), seen);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+};
+const collectAliasEdges = (tree, graph) => {
+    const edges = new Map();
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.includes('node_modules/'))
+            return;
+        const fromRoot = projectRootOf(tree, filePath);
+        if (!fromRoot)
+            return;
+        for (const [, specifier] of (tree.read(filePath, 'utf-8') ?? '').matchAll(MODULE_SPECIFIER)) {
+            if (!specifier || specifier.startsWith('.') || !graph.isWorkspaceSpecifier(specifier))
+                continue;
+            const target = graph.resolveFile(filePath, specifier);
+            const targetRoot = target ? projectRootOf(tree, target) : null;
+            if (!targetRoot || targetRoot === fromRoot)
+                continue;
+            const list = edges.get(fromRoot) ?? [];
+            if (!list.some((edge) => edge.alias === specifier))
+                list.push({ alias: specifier, targetRoot });
+            edges.set(fromRoot, list);
+        }
+    });
+    edges.forEach((list) => list.sort((a, b) => a.alias.localeCompare(b.alias)));
+    return edges;
+};
+const projectsReaching = (tree, graph, importingRoots) => {
+    const reached = new Map([...importingRoots].map((root) => [root, null]));
+    const edges = collectAliasEdges(tree, graph);
+    const roots = [...edges.keys()].sort();
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const root of roots) {
+            if (reached.has(root))
+                continue;
+            const edge = edges.get(root).find(({ targetRoot }) => reached.has(targetRoot));
+            if (!edge)
+                continue;
+            reached.set(root, edge.alias);
+            grew = true;
+        }
+    }
+    return reached;
+};
+/**
+ * Lists every project tsconfig that resolves modules with `node` / `node10` while the project imports a specifier
+ * `matches` accepts, directly or through a workspace path alias. That resolution ignores the `exports` map, so a
+ * package subpath like `@ethlete/query/testing` does not resolve.
+ */
+export const findLegacyModuleResolutions = (tree, graph, files, matches) => {
+    const directSpecifiers = new Map();
+    for (const filePath of files) {
+        if (!filePath.endsWith('.ts'))
+            continue;
+        const root = projectRootOf(tree, filePath);
+        if (!root || directSpecifiers.has(root))
+            continue;
+        const specifier = Array.from((tree.read(filePath, 'utf-8') ?? '').matchAll(MODULE_SPECIFIER), ([, s]) => s).find((s) => s !== undefined && matches(s));
+        if (specifier)
+            directSpecifiers.set(root, specifier);
+    }
+    if (!directSpecifiers.size)
+        return [];
+    const reached = projectsReaching(tree, graph, new Set(directSpecifiers.keys()));
+    const findings = [];
+    for (const root of [...reached.keys()].sort()) {
+        const alias = reached.get(root) ?? null;
+        for (const name of PROJECT_TSCONFIGS) {
+            const configPath = joinPathFragments(root, name);
+            const resolution = effectiveModuleResolution(tree, configPath);
+            if (!resolution || !LEGACY_RESOLUTIONS.has(resolution))
+                continue;
+            findings.push({ configPath, resolution, specifier: directSpecifiers.get(root) ?? null, alias });
+        }
+    }
+    return findings;
+};
+const ETHLETE_SUBPATH = /^@ethlete\/[^/]+\/./;
+/**
+ * Records a follow-up for every node-resolving project tsconfig whose project imports an `@ethlete/*` subpath
+ * (`@ethlete/query/testing`, `@ethlete/query-devtools/lazy`, ...), directly or through a workspace path alias.
+ * Runs after the rewrites, so it also sees the subpaths the migration itself adds.
+ */
+export const reportLegacyModuleResolution = (tree, scope, report) => {
+    const files = [];
+    scope.visit(tree, (filePath) => files.push(filePath));
+    for (const { configPath, resolution, specifier, alias } of findLegacyModuleResolutions(tree, createModuleGraph(tree), files, (candidate) => ETHLETE_SUBPATH.test(candidate))) {
+        report.addFollowUp({
+            title: 'Project resolves modules with `node`, which cannot find `@ethlete/*` subpaths',
+            summary: alias
+                ? `${configPath} resolves modules with \`${resolution}\` and reaches an \`@ethlete/*\` subpath through \`${alias}\`.`
+                : `${configPath} resolves modules with \`${resolution}\` and imports \`${specifier}\`.`,
+            action: '`moduleResolution: node` (`node10`) ignores the `exports` map of the `@ethlete/*` packages, so subpath imports like `@ethlete/query-devtools/lazy` do not resolve - also when they sit in another project this one imports through a path alias. Set `moduleResolution` to `bundler` (or `node16` / `nodenext`) in the listed tsconfig or the base config it inherits it from.',
+            locations: [{ filePath: configPath }],
+            source: 'module-resolution',
+        });
+    }
+};
+//# sourceMappingURL=module-resolution.js.map

package/generators/migrate-to-query-v3/rename-symbols.js

@@ -174,16 +174,7 @@ export const renameImportedReferences = (content, renames) => {
     });
     return { content: result, shadowed };
 };
-/**
- * Drops named imports whose local name no longer appears anywhere else in the file.
- *
- * The migration rewrites away the constructs that needed `def`, `AnyLegacyQueryCreator` and friends;
- * leaving the imports behind turns every touched file into a lint error, and `formatFiles` runs in
- * the same generator invocation so they land that way. Identifiers inside template strings count as
- * usage too - a component referenced only from an inline template must not be pruned.
- */
-export const pruneUnusedNamedImports = (content) => {
-    const sourceFile = createSourceFile(content);
+const collectUsedNames = (sourceFile) => {
     const used = new Set();
     const addWordsFrom = (text) => {
         for (const word of text.match(/[A-Za-z_$][\w$]*/g) ?? []) {
@@ -204,6 +195,20 @@ export const pruneUnusedNamedImports = (content) => {
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
+    return used;
+};
+export const findUsedNames = (content) => collectUsedNames(createSourceFile(content));
+/**
+ * Drops named imports whose local name no longer appears anywhere else in the file.
+ *
+ * The migration rewrites away the constructs that needed `def`, `AnyLegacyQueryCreator` and friends;
+ * leaving the imports behind turns every touched file into a lint error, and `formatFiles` runs in
+ * the same generator invocation so they land that way. Identifiers inside template strings count as
+ * usage too - a component referenced only from an inline template must not be pruned.
+ */
+export const pruneUnusedNamedImports = (content, candidates) => {
+    const sourceFile = createSourceFile(content);
+    const used = collectUsedNames(sourceFile);
     const replacements = [];
     for (const node of sourceFile.statements) {
         if (!ts.isImportDeclaration(node) ||
@@ -212,7 +217,7 @@ export const pruneUnusedNamedImports = (content) => {
             !ts.isNamedImports(node.importClause.namedBindings)) {
             continue;
         }
-        const kept = node.importClause.namedBindings.elements.filter((element) => used.has(element.name.text));
+        const kept = node.importClause.namedBindings.elements.filter((element) => used.has(element.name.text) || (candidates && !candidates.has(element.name.text)));
         if (kept.length === node.importClause.namedBindings.elements.length)
             continue;
         const nextImport = printImportDeclaration(node, sourceFile, kept.map((element) => element.getText(sourceFile)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.62",
+  "version": "6.0.0-next.63",
   "repository": {
     "type": "git",
     "url": "https://github.com/ethlete-io/ethdk",

package/types/ethlete-query-ngrx-toolkit.d.ts

@@ -124,6 +124,19 @@ export declare const toolkitSelect: <TCreator extends AnyQueryCreator>(creator:
  * ```
  */
 export declare const toolkitCall: <TCreator extends AnyQueryCreator>(creator: TCreator, args: ActionCallArgs<TCreator>, options?: ToolkitCallOptions) => MappedEntityState<TCreator>;
+type SuccessResponseOf<TCreator> = TCreator extends AnyQueryCreator ? ResponseType<QueryArgsOf<TCreator>> : never;
+/**
+ * Emits the response every time a `toolkitCall` handle of one of the creators succeeds - the
+ * `facade.on(action.success)` of `@tomtomb/ngrx-toolkit`. Only handles of the same environment injector count.
+ *
+ * @example
+ * ```ts
+ * toolkitOnSuccess([postAcceptClaim, postDeclineClaim])
+ *   .pipe(takeUntilDestroyed())
+ *   .subscribe(() => this.reloadRoster());
+ * ```
+ */
+export declare const toolkitOnSuccess: <const TCreators extends AnyQueryCreator | readonly AnyQueryCreator[]>(creators: TCreators, options?: ToolkitCallOptions) => Observable<SuccessResponseOf<TCreators extends readonly AnyQueryCreator[] ? TCreators[number] : TCreators>>;
 /** Emits `true` while any of the given loading streams is `true`. Nullish entries are skipped. */
 export declare const joinLoading: (observables: (Observable<boolean | null> | null | undefined)[]) => Observable<boolean>;
 /** Emits every non-null error of the given error streams, or `null` when there is none. Nullish entries are skipped. */

package/types/ethlete-query.d.ts

@@ -774,7 +774,7 @@ export declare const recordExecutionArgs: <TArgs extends QueryArgs>(state: Query
  * less than 100 ms after the previous one. Executions with different args (a search term typed fast,
  * a slider bound to `withArgs`) never count against each other.
  */
-export declare const circularQueryDependencyChecker: () => {
+export declare const circularQueryDependencyChecker: (route: unknown) => {
   check: (args: RequestArgs<QueryArgs> | null | undefined) => void;
 };
 /**
@@ -3669,7 +3669,7 @@ export declare const gqlDataPropertyMissingInResponse: () => RuntimeError<600>;
 export declare const gqlErrorsInResponse: (errors: unknown[]) => HttpErrorResponse;
 export declare const tokensNotAvailableInsideAuthAndExec: () => RuntimeError<700>;
 export declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
-export declare const circularQueryDependency: () => RuntimeError<800>;
+export declare const circularQueryDependency: (route: unknown) => RuntimeError<800>;
 export declare const queryExecutedAfterDestroyMessage: (route: unknown) => string;
 export declare const queryExecutedWhileParkedMessage: (route: unknown) => string;
 export declare const legacyPrepareWithoutInjectionContext: (creatorName: string | undefined, method?: "prepare" | "createSubject" | "createSignal") => RuntimeError<950>;
@@ -6136,7 +6136,21 @@ type QueryDevtoolsOptions = {
    * never clicks a devtools element by accident. Defaults to `false`.
    */
   showInAutomation?: boolean;
+  /**
+   * Mounts the devtools UI for you, so no `<et-query-devtools-lazy>` is needed in a template. Pass the
+   * lazy entry point as a dynamic import; it loads once the application has rendered, and not at all
+   * when a devtools UI is already on the page.
+   *
+   * @example
+   * ```ts
+   * provideQueryDevtools({ ui: () => import('@ethlete/query-devtools/lazy') })
+   * ```
+   */
+  ui?: QueryDevtoolsUiLoader;
 };
+type QueryDevtoolsUiLoader = () => Promise<{
+  mountQueryDevtools: (injector: EnvironmentInjector) => unknown;
+}>;
 /**
  * Undoes the latch `provideQueryDevtools()` sets, so a later spec in the same worker sees the devtools
  * disabled again. For specs only.
@@ -7407,6 +7421,8 @@ export declare class LegacyQuery<Response, Arguments extends BaseArguments | und
   private _errorAtExecute;
   private _ownLoadSettled;
   private _wasAborted;
+  private _mockState;
+  private _mockSubscription;
   state$: Observable<V2QueryState<Data>>;
   constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined,
   /**
@@ -7425,7 +7441,8 @@ export declare class LegacyQuery<Response, Arguments extends BaseArguments | und
   _canBeCached?: boolean);
   /** The full URL of the request the underlying query is bound to, `null` before the first execution. */
   get url(): string | null;
-  get rawState(): V2QueryState<ResponseType<QueryArgsOf<TNewQuery>>>;
+  get rawState(): Loading | Failure | import("@ethlete/query").Cancelled | Prepared | Success<ResponseType<QueryArgsOf<TNewQuery>>>;
+  private syncEntity;
   /**
    * `abort()` resets the underlying query, so it holds no execution state - the shape of a query that has
    * never run. The abort flag is the only thing that tells the two apart.
@@ -7445,9 +7462,11 @@ export declare class LegacyQuery<Response, Arguments extends BaseArguments | und
   get store(): null;
   get canBeCached(): boolean;
   get _isInMockMode(): boolean;
+  private get mockConfig();
   destroy(): void;
   execute(options?: ExecuteQueryOptions): this;
   abort(): this;
+  private startMock;
   poll(config: PollConfig): this;
   stopPolling(): this;
   pausePolling(): this;
@@ -9983,5 +10002,5 @@ export type WebSocketClientResult<TMessageData extends SocketMessageView = Socke
 export type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientResult<TMessageData>;
 export declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 /** The version of `@ethlete/query` this build was cut from. */
-export declare const QUERY_VERSION = "6.0.0-next.62";
+export declare const QUERY_VERSION = "6.0.0-next.63";
 export { type BearerAuthSessionAdoption, type BuildQueryStringConfig, type GqlDataWithErrors, type GqlEnvelope, type GqlError, type PathParams, type QueryDevtoolsApiEnv, type QueryDevtoolsApiEnvSwitch, type QueryDevtoolsAppInfo, type QueryDevtoolsAuthAccount, type QueryDevtoolsAuthField, type QueryDevtoolsFeatureDescriber, type QueryDevtoolsFeatureDetail, type QueryDevtoolsOptions, type QueryDevtoolsSchemaLoader, type QueryDevtoolsSchemaLoaders, type QueryParams, type DescribableFeature as ɵDescribableFeature, EMPTY_QUERY_DEVTOOLS_FAULT as ɵEMPTY_QUERY_DEVTOOLS_FAULT, type JsonPath as ɵJsonPath, MAX_QUERY_BATCH_TOMBSTONES as ɵMAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_BATCH_TOMBSTONE_BUCKETS as ɵMAX_QUERY_BATCH_TOMBSTONE_BUCKETS, MAX_QUERY_DEVTOOLS_TOMBSTONES as ɵMAX_QUERY_DEVTOOLS_TOMBSTONES, type OverrideOp as ɵOverrideOp, QUERY_DEVTOOLS_FAULT_STATUSES as ɵQUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT as ɵQUERY_DEVTOOLS_TOKEN_TTL_LIMIT, type QueryDevtoolsAbout as ɵQueryDevtoolsAbout, type QueryDevtoolsAuthAccountView as ɵQueryDevtoolsAuthAccountView, type QueryDevtoolsAuthLocalAccount as ɵQueryDevtoolsAuthLocalAccount, type QueryDevtoolsAuthProviderHandle as ɵQueryDevtoolsAuthProviderHandle, type QueryDevtoolsAuthProviderRegistration as ɵQueryDevtoolsAuthProviderRegistration, type QueryDevtoolsAuthQuery as ɵQueryDevtoolsAuthQuery, type QueryDevtoolsAuthSeed as ɵQueryDevtoolsAuthSeed, type QueryDevtoolsAuthSession as ɵQueryDevtoolsAuthSession, type QueryDevtoolsEntry as ɵQueryDevtoolsEntry, type QueryDevtoolsEntryKind as ɵQueryDevtoolsEntryKind, type QueryDevtoolsEntryMeta as ɵQueryDevtoolsEntryMeta, type QueryDevtoolsFault as ɵQueryDevtoolsFault, type QueryDevtoolsFaultTarget as ɵQueryDevtoolsFaultTarget, type QueryDevtoolsFeature as ɵQueryDevtoolsFeature, type QueryDevtoolsFormField as ɵQueryDevtoolsFormField, type QueryDevtoolsFormHandle as ɵQueryDevtoolsFormHandle, type QueryDevtoolsFormLinksHandle as ɵQueryDevtoolsFormLinksHandle, type QueryDevtoolsFormLinksRecorder as ɵQueryDevtoolsFormLinksRecorder, type QueryDevtoolsMock as ɵQueryDevtoolsMock, type QueryDevtoolsMockTarget as ɵQueryDevtoolsMockTarget, type QueryDevtoolsOverrideEntry as ɵQueryDevtoolsOverrideEntry, type QueryDevtoolsOverrideTransfer as ɵQueryDevtoolsOverrideTransfer, type QueryDevtoolsOverrideTransferParse as ɵQueryDevtoolsOverrideTransferParse, type QueryDevtoolsOverridesHandle as ɵQueryDevtoolsOverridesHandle, type QueryDevtoolsOverridesRecorder as ɵQueryDevtoolsOverridesRecorder, type QueryDevtoolsPayload as ɵQueryDevtoolsPayload, type QueryDevtoolsRegistrar as ɵQueryDevtoolsRegistrar, type QueryDevtoolsRegistration as ɵQueryDevtoolsRegistration, type QueryDevtoolsResolvedFault as ɵQueryDevtoolsResolvedFault, type QueryDevtoolsResolvedMock as ɵQueryDevtoolsResolvedMock, type QueryDevtoolsRoutePart as ɵQueryDevtoolsRoutePart, type QueryDevtoolsRun as ɵQueryDevtoolsRun, type QueryDevtoolsRunError as ɵQueryDevtoolsRunError, type QueryDevtoolsRunStatus as ɵQueryDevtoolsRunStatus, type QueryDevtoolsSchemaComponents as ɵQueryDevtoolsSchemaComponents, type QueryDevtoolsSchemaRoute as ɵQueryDevtoolsSchemaRoute, type QueryDevtoolsSchemaSeed as ɵQueryDevtoolsSchemaSeed, type QueryDevtoolsSchemaState as ɵQueryDevtoolsSchemaState, type QueryDevtoolsSeedStyle as ɵQueryDevtoolsSeedStyle, type QueryDevtoolsSettings as ɵQueryDevtoolsSettings, type QueryDevtoolsStats as ɵQueryDevtoolsStats, type QueryDevtoolsStatsHandle as ɵQueryDevtoolsStatsHandle, type QueryDevtoolsStatsRecorder as ɵQueryDevtoolsStatsRecorder, type QueryDevtoolsStorageScope as ɵQueryDevtoolsStorageScope, type RestoredQueryDevtoolsOverrides as ɵRestoredQueryDevtoolsOverrides, addQueryDevtoolsAuthAccount as ɵaddQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides as ɵapplyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl as ɵapplyQueryDevtoolsTokenTtl, armAllQueryDevtoolsMocks as ɵarmAllQueryDevtoolsMocks, armQueryDevtoolsMock as ɵarmQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer as ɵarmQueryDevtoolsOverrideTransfer, canOverrideQueryDevtoolsTokenTtl as ɵcanOverrideQueryDevtoolsTokenTtl, clearQueryDevtoolsArmedMocks as ɵclearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials as ɵclearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions as ɵclearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults as ɵclearQueryDevtoolsFaults, clearQueryDevtoolsMockStore as ɵclearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore as ɵclearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore as ɵclearQueryDevtoolsStore, clearQueryDevtoolsTombstones as ɵclearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides as ɵclearRestoredQueryDevtoolsOverrides, collectLeafPaths as ɵcollectLeafPaths, collectQueryDevtoolsSchemaComponents as ɵcollectQueryDevtoolsSchemaComponents, countUnresolvedQueryDevtoolsOverrides as ɵcountUnresolvedQueryDevtoolsOverrides, createQueryDevtoolsOverrides as ɵcreateQueryDevtoolsOverrides, deleteQueryDevtoolsMock as ɵdeleteQueryDevtoolsMock, detectPaginationShape as ɵdetectPaginationShape, forgetQueryDevtoolsAuthSession as ɵforgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor as ɵforgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset as ɵgenerateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber as ɵgenerateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset as ɵgenerateQueryDevtoolsStringPreset, hasQueryDevtoolsOverridesAtPath as ɵhasQueryDevtoolsOverridesAtPath, isDateShapedLeaf as ɵisDateShapedLeaf, isQueryDevtoolsEnabled as ɵisQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed as ɵisQueryDevtoolsFaultArmed, isQueryDevtoolsHiddenInAutomation as ɵisQueryDevtoolsHiddenInAutomation, isQueryDevtoolsRepositoryLive as ɵisQueryDevtoolsRepositoryLive, loadQueryDevtoolsSchema as ɵloadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount as ɵloginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession as ɵlogoutQueryDevtoolsAuthSession, matchesQueryDevtoolsMockPattern as ɵmatchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery as ɵmatchesQueryDevtoolsMockQuery, measureQueryDevtoolsPayload as ɵmeasureQueryDevtoolsPayload, parseQueryDevtoolsOverrideTransfer as ɵparseQueryDevtoolsOverrideTransfer, queryDevtoolsAbout as ɵqueryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions as ɵqueryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds as ɵqueryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction as ɵqueryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope as ɵqueryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues as ɵqueryDevtoolsApiEnvValues, queryDevtoolsApiEnvs as ɵqueryDevtoolsApiEnvs, queryDevtoolsArmedMocks as ɵqueryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored as ɵqueryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor as ɵqueryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive as ɵqueryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor as ɵqueryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount as ɵqueryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions as ɵqueryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor as ɵqueryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal as ɵqueryDevtoolsAuthTabLocal, queryDevtoolsEntries as ɵqueryDevtoolsEntries, queryDevtoolsFaults as ɵqueryDevtoolsFaults, queryDevtoolsFaultsRestored as ɵqueryDevtoolsFaultsRestored, queryDevtoolsMockId as ɵqueryDevtoolsMockId, queryDevtoolsMocks as ɵqueryDevtoolsMocks, queryDevtoolsOverridePersistence as ɵqueryDevtoolsOverridePersistence, queryDevtoolsRequestPath as ɵqueryDevtoolsRequestPath, queryDevtoolsResponseHistory as ɵqueryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope as ɵqueryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames as ɵqueryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes as ɵqueryDevtoolsSchemaRoutes, queryDevtoolsSchemaState as ɵqueryDevtoolsSchemaState, queryDevtoolsSettings as ɵqueryDevtoolsSettings, queryDevtoolsStorage as ɵqueryDevtoolsStorage, queryDevtoolsTokenTtls as ɵqueryDevtoolsTokenTtls, readQueryDevtoolsStore as ɵreadQueryDevtoolsStore, registerEthleteVersion as ɵregisterEthleteVersion, removeQueryDevtoolsAuthAccount as ɵremoveQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession as ɵrenameQueryDevtoolsAuthSession, restoredQueryDevtoolsOverrides as ɵrestoredQueryDevtoolsOverrides, saveQueryDevtoolsMock as ɵsaveQueryDevtoolsMock, seedQueryDevtoolsSchemaBody as ɵseedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute as ɵseedQueryDevtoolsSchemaRoute, serializeQueryDevtoolsOverrideTransfer as ɵserializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv as ɵsetQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo as ɵsetQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope as ɵsetQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials as ɵsetQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal as ɵsetQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault as ɵsetQueryDevtoolsFault, setQueryDevtoolsFaultsScope as ɵsetQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence as ɵsetQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope as ɵsetQueryDevtoolsOverridesScope, setQueryDevtoolsSettings as ɵsetQueryDevtoolsSettings, smartDuplicateArrayItem as ɵsmartDuplicateArrayItem, snapshotQueryDevtoolsHandle as ɵsnapshotQueryDevtoolsHandle, stringifyQueryRouteParts as ɵstringifyQueryRouteParts, sumQueryDevtoolsStats as ɵsumQueryDevtoolsStats, switchQueryDevtoolsAuthSession as ɵswitchQueryDevtoolsAuthSession, tombstoneOf as ɵtombstoneOf, writeQueryDevtoolsStore as ɵwriteQueryDevtoolsStore };