@ethlete/query 5.43.0 → 6.0.0-beta.8

package/generators/migrate-to-query-v3/shared.js

@@ -0,0 +1,97 @@
+import * as ts from 'typescript';
+const TEMP_SOURCE_FILE = 'temp.ts';
+export const createSourceFile = (content, filePath = TEMP_SOURCE_FILE) => ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+export const capitalizeFirstLetter = (value) => {
+    if (value.length === 0) {
+        return value;
+    }
+    return `${value[0].toUpperCase()}${value.slice(1)}`;
+};
+export const ensureConfigSuffix = (name) => {
+    if (/Config$/i.test(name)) {
+        return name;
+    }
+    return `${name}Config`;
+};
+export const ensureNamedImports = ({ content, importsNeeded, moduleSpecifier }) => {
+    const sourceFile = createSourceFile(content);
+    let importNode;
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === moduleSpecifier) {
+            importNode = node;
+        }
+    });
+    const missingImports = new Set(importsNeeded);
+    if (importNode?.importClause?.namedBindings && ts.isNamedImports(importNode.importClause.namedBindings)) {
+        const namedBindings = importNode.importClause.namedBindings;
+        namedBindings.elements.forEach((element) => {
+            missingImports.delete(element.name.text);
+        });
+        if (missingImports.size === 0) {
+            return content;
+        }
+        const existingImports = namedBindings.elements.map((element) => element.getText(sourceFile));
+        const nextImports = [...existingImports, ...Array.from(missingImports).sort()].sort();
+        const nextImportStatement = `import { ${nextImports.join(', ')} } from '${moduleSpecifier}';`;
+        return content.slice(0, importNode.getStart(sourceFile)) + nextImportStatement + content.slice(importNode.getEnd());
+    }
+    let lastImportEnd = 0;
+    ts.forEachChild(sourceFile, (node) => {
+        if (!ts.isImportDeclaration(node)) {
+            return;
+        }
+        const end = node.getEnd();
+        if (end > lastImportEnd) {
+            lastImportEnd = end;
+        }
+    });
+    const nextImportStatement = `\nimport { ${Array.from(missingImports).sort().join(', ')} } from '${moduleSpecifier}';`;
+    if (lastImportEnd > 0) {
+        return content.slice(0, lastImportEnd) + nextImportStatement + content.slice(lastImportEnd);
+    }
+    return `import { ${Array.from(missingImports).sort().join(', ')} } from '${moduleSpecifier}';\n\n${content}`;
+};
+export const ensureImportFromQuery = (content, importsNeeded) => ensureNamedImports({ content, importsNeeded, moduleSpecifier: '@ethlete/query' });
+export const ensureAngularCoreImports = (content, importsNeeded) => ensureNamedImports({ content, importsNeeded, moduleSpecifier: '@angular/core' });
+export const getVariableStatementEnd = (sourceFile, variableName, initializerName) => {
+    let variableStatementEnd;
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === variableName &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === initializerName) {
+            let parent = node.parent;
+            while (parent && !ts.isVariableStatement(parent)) {
+                parent = parent.parent;
+            }
+            if (parent && ts.isVariableStatement(parent)) {
+                variableStatementEnd = parent.getEnd();
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return variableStatementEnd;
+};
+export const getIndentation = (content, position) => {
+    let lineStart = position;
+    while (lineStart > 0 && content[lineStart - 1] !== '\n') {
+        lineStart -= 1;
+    }
+    let indentation = '';
+    for (let index = lineStart; index < position && /\s/.test(content[index]); index += 1) {
+        indentation += content[index];
+    }
+    return indentation || '  ';
+};
+export const getLineNumber = (node, sourceFile) => {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    return line + 1;
+};
+export const getLineNumberFromPosition = (content, position) => content.slice(0, position).split('\n').length;
+//# sourceMappingURL=shared.js.map

package/generators/prep-for-query-v3/migration.js

@@ -0,0 +1,329 @@
+import { formatFiles, visitNotIgnoredFiles } from '@nx/devkit';
+import * as ts from 'typescript';
+export default async function migrate(tree, schema) {
+    console.log('\n🔄 Starting Query v3 symbol conflict migration...');
+    renameConflictingSymbols(tree);
+    replaceExperimentalQueryNamespace(tree);
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Migration completed successfully!');
+}
+//#endregion
+//#region Symbol renaming
+// Map of old symbol names to new symbol names
+const TYPE_RENAMES = new Map([
+    ['BearerAuthProvider', 'V2BearerAuthProvider'],
+    ['AnyQueryCreator', 'AnyV2QueryCreator'],
+    ['CacheAdapterFn', 'V2CacheAdapterFn'],
+    ['Query', 'V2Query'],
+    ['QueryArgsOf', 'V2QueryArgsOf'],
+    ['QueryClient', 'V2QueryClient'],
+    ['QueryClientConfig', 'V2QueryClientConfig'],
+    ['QueryConfig', 'V2QueryConfig'],
+    ['QueryCreator', 'V2QueryCreator'],
+    ['QueryState', 'V2QueryState'],
+    ['RouteType', 'V2RouteType'],
+    ['RouteString', 'V2RouteString'],
+    ['AnyQuery', 'AnyV2Query'],
+]);
+const FUNCTION_RENAMES = new Map([
+    ['buildQueryCacheKey', 'v2BuildQueryCacheKey'],
+    ['extractExpiresInSeconds', 'v2ExtractExpiresInSeconds'],
+    ['shouldCacheQuery', 'v2ShouldCacheQuery'],
+    ['shouldRetryRequest', 'v2ShouldRetryRequest'],
+]);
+function renameConflictingSymbols(tree) {
+    const updatedFiles = [];
+    const symbolUsageCounts = new Map();
+    // Initialize counts
+    [...TYPE_RENAMES.keys(), ...FUNCTION_RENAMES.keys()].forEach((symbol) => {
+        symbolUsageCounts.set(symbol, 0);
+    });
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Check if file imports from @ethlete/query
+        if (!content.includes('@ethlete/query'))
+            return;
+        const newContent = renameSymbolsInFile(content, filePath, symbolUsageCounts);
+        if (newContent !== content) {
+            tree.write(filePath, newContent);
+            updatedFiles.push(filePath);
+        }
+    });
+    // Log statistics
+    if (updatedFiles.length > 0) {
+        console.log(`\n📊 Renamed symbols in ${updatedFiles.length} files:`);
+        const hasRenames = Array.from(symbolUsageCounts.entries()).filter(([_, count]) => count > 0);
+        if (hasRenames.length > 0) {
+            console.log('\n   Symbol usage counts:');
+            hasRenames.forEach(([symbol, count]) => {
+                const newName = TYPE_RENAMES.get(symbol) || FUNCTION_RENAMES.get(symbol);
+                console.log(`   - ${symbol} → ${newName}: ${count} occurrences`);
+            });
+        }
+    }
+    else {
+        console.log('\n✅ No conflicting symbols found in workspace');
+    }
+}
+function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const replacements = [];
+    // Track which symbols are imported from @ethlete/query
+    const importedSymbols = new Set();
+    function visit(node) {
+        // Track imports from @ethlete/query
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@ethlete/query') {
+                const namedBindings = node.importClause?.namedBindings;
+                if (namedBindings && ts.isNamedImports(namedBindings)) {
+                    namedBindings.elements.forEach((element) => {
+                        const importedName = element.propertyName?.text || element.name.text;
+                        if (TYPE_RENAMES.has(importedName) || FUNCTION_RENAMES.has(importedName)) {
+                            importedSymbols.add(importedName);
+                        }
+                    });
+                }
+            }
+        }
+        // Rename identifiers that match our rename maps
+        if (ts.isIdentifier(node)) {
+            const name = node.text;
+            const parent = node.parent;
+            // Only rename if this symbol was imported from @ethlete/query
+            if (!importedSymbols.has(name)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const newName = TYPE_RENAMES.get(name) || FUNCTION_RENAMES.get(name);
+            if (!newName) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            // Skip if it's the imported name in an import specifier (we'll handle that separately)
+            if (ts.isImportSpecifier(parent) && (parent.propertyName === node || parent.name === node)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            // Rename the identifier
+            replacements.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                replacement: newName,
+                oldName: name,
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // Update imports in @ethlete/query import declarations
+    const importReplacements = updateImports(sourceFile, content);
+    replacements.push(...importReplacements);
+    // Count usages
+    replacements.forEach((r) => {
+        const count = symbolUsageCounts.get(r.oldName) || 0;
+        symbolUsageCounts.set(r.oldName, count + 1);
+    });
+    // Apply replacements in reverse order
+    let result = content;
+    replacements.sort((a, b) => b.start - a.start);
+    for (const { start, end, replacement } of replacements) {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    }
+    return result;
+}
+function updateImports(sourceFile, content) {
+    const replacements = [];
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@ethlete/query') {
+                const namedBindings = node.importClause?.namedBindings;
+                if (namedBindings && ts.isNamedImports(namedBindings)) {
+                    namedBindings.elements.forEach((element) => {
+                        const importedName = element.propertyName?.text || element.name.text;
+                        const newName = TYPE_RENAMES.get(importedName) || FUNCTION_RENAMES.get(importedName);
+                        if (newName) {
+                            if (element.propertyName) {
+                                // Handle: import { Query as MyQuery }
+                                // Rename to: import { V2Query as MyQuery }
+                                replacements.push({
+                                    start: element.propertyName.getStart(sourceFile),
+                                    end: element.propertyName.getEnd(),
+                                    replacement: newName,
+                                    oldName: importedName,
+                                });
+                            }
+                            else {
+                                // Handle: import { Query }
+                                // Rename to: import { V2Query }
+                                replacements.push({
+                                    start: element.name.getStart(sourceFile),
+                                    end: element.name.getEnd(),
+                                    replacement: newName,
+                                    oldName: importedName,
+                                });
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return replacements;
+}
+//#endregion
+//#region ExperimentalQuery namespace replacement
+function replaceExperimentalQueryNamespace(tree) {
+    const updatedFiles = [];
+    let totalReplacements = 0;
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Check if file imports ExperimentalQuery
+        if (!content.includes('ExperimentalQuery'))
+            return;
+        const result = replaceNamespaceInFile(content, filePath);
+        if (result.modified) {
+            tree.write(filePath, result.content);
+            updatedFiles.push(filePath);
+            totalReplacements += result.replacementCount;
+        }
+    });
+    if (updatedFiles.length > 0) {
+        console.log(`\n📦 Replaced ExperimentalQuery namespace in ${updatedFiles.length} files (${totalReplacements} usages)`);
+    }
+}
+function replaceNamespaceInFile(content, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const replacements = [];
+    const usedSymbols = new Set();
+    let hasExperimentalQueryImport = false;
+    let experimentalQueryAlias;
+    // First pass: find ExperimentalQuery import and get the alias
+    function collectImport(node) {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@ethlete/query') {
+                const namedBindings = node.importClause?.namedBindings;
+                if (namedBindings && ts.isNamedImports(namedBindings)) {
+                    namedBindings.elements.forEach((element) => {
+                        const importedName = element.propertyName?.text || element.name.text;
+                        if (importedName === 'ExperimentalQuery') {
+                            hasExperimentalQueryImport = true;
+                            // The local name (alias) is what we use in the code
+                            experimentalQueryAlias = element.name.text;
+                        }
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, collectImport);
+    }
+    collectImport(sourceFile);
+    // If no ExperimentalQuery import found, return unchanged
+    if (!hasExperimentalQueryImport || !experimentalQueryAlias) {
+        return { content, modified: false, replacementCount: 0 };
+    }
+    // Second pass: collect used symbols
+    function findUsages(node) {
+        // Find usages: ExperimentalQuery.someSymbol or E.someSymbol (if aliased)
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === experimentalQueryAlias) {
+            const symbolName = node.name.text;
+            usedSymbols.add(symbolName);
+        }
+        ts.forEachChild(node, findUsages);
+    }
+    findUsages(sourceFile);
+    // Build the new import statement with used symbols
+    const sortedSymbols = Array.from(usedSymbols).sort();
+    // Third pass: create replacements
+    function createReplacements(node) {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@ethlete/query') {
+                const namedBindings = node.importClause?.namedBindings;
+                if (namedBindings && ts.isNamedImports(namedBindings)) {
+                    // We need to update the entire import declaration
+                    const otherImports = [];
+                    let hasExperimentalQuery = false;
+                    namedBindings.elements.forEach((element) => {
+                        const importedName = element.propertyName?.text || element.name.text;
+                        if (importedName === 'ExperimentalQuery') {
+                            hasExperimentalQuery = true;
+                        }
+                        else {
+                            // Keep other imports as-is
+                            if (element.propertyName) {
+                                otherImports.push(`${element.propertyName.text} as ${element.name.text}`);
+                            }
+                            else {
+                                otherImports.push(element.name.text);
+                            }
+                        }
+                    });
+                    if (hasExperimentalQuery) {
+                        // Combine other imports with the expanded ExperimentalQuery symbols
+                        const allImports = [...otherImports, ...sortedSymbols].sort();
+                        let newImport;
+                        if (allImports.length === 0) {
+                            // No imports needed, remove the entire import
+                            newImport = '';
+                        }
+                        else if (allImports.length <= 3) {
+                            // Single line
+                            newImport = `import { ${allImports.join(', ')} } from '@ethlete/query';`;
+                        }
+                        else {
+                            // Multi-line
+                            newImport = `import {\n  ${allImports.join(',\n  ')}\n} from '@ethlete/query';`;
+                        }
+                        replacements.push({
+                            start: node.getStart(sourceFile),
+                            end: node.getEnd(),
+                            replacement: newImport,
+                        });
+                    }
+                }
+            }
+        }
+        // Replace usages: ExperimentalQuery.someSymbol → someSymbol
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === experimentalQueryAlias) {
+            replacements.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                replacement: node.name.text,
+            });
+        }
+        ts.forEachChild(node, createReplacements);
+    }
+    createReplacements(sourceFile);
+    // Apply replacements in reverse order
+    let result = content;
+    replacements.sort((a, b) => b.start - a.start);
+    for (const { start, end, replacement } of replacements) {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    }
+    return {
+        content: result,
+        modified: replacements.length > 0,
+        replacementCount: replacements.length - 1, // Subtract 1 for the import replacement
+    };
+}
+//#endregion
+//# sourceMappingURL=migration.js.map

package/generators/prep-for-query-v3/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "prep-for-query-v3",
+  "title": "Prepare to migrate to Query v3",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/package.json

@@ -1,32 +1,40 @@
 {
   "name": "@ethlete/query",
-  "version": "5.43.0",
+  "version": "6.0.0-beta.8",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {
-    "@angular/common": "20.3.6",
-    "@angular/core": "20.3.6",
-    "@angular/forms": "20.3.6",
-    "@angular/router": "20.3.6",
-    "@ethlete/core": "^4.0.3",
-    "@ethlete/types": "^1.6.2",
-    "@nx/devkit": "21.6.5",
+    "@analogjs/vite-plugin-angular": "2.5.1",
+    "@angular/common": "21.2.13",
+    "@angular/core": "21.2.13",
+    "@angular/forms": "21.2.13",
+    "@angular/router": "21.2.13",
+    "@ethlete/core": "^5.0.0-beta.11",
+    "@ethlete/types": "^2.0.0-beta.4",
+    "@nx/devkit": "22.7.2",
+    "@nx/vite": "22.7.2",
     "rxjs": "7.8.2",
-    "socket.io-client": "4.8.1",
-    "typescript": "5.9.3"
+    "socket.io-client": "4.8.3",
+    "typescript": "5.9.3",
+    "vite": "8.0.13"
   },
   "generators": "./generators/generators.json",
   "module": "fesm2022/ethlete-query.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/ethlete-query.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/ethlete-query.d.ts",
       "default": "./fesm2022/ethlete-query.mjs"
+    },
+    "./testing": {
+      "types": "./types/ethlete-query-testing.d.ts",
+      "default": "./fesm2022/ethlete-query-testing.mjs"
     }
   },
+  "type": "module",
   "dependencies": {
     "tslib": "^2.3.0"
   }

package/types/ethlete-query-testing.d.ts

@@ -0,0 +1,167 @@
+import { AnyCreateQueryClientResult, QueryClientRef, createGetQuery, createPostQuery, createPutQuery, createPatchQuery, createDeleteQuery, BearerAuthProviderFeatureContext, AnyQueryBuilder, BearerAuthProvider, AuthQueryBuilder, TokenRefreshQueryBuilder, TokenRefreshQueryConfig } from '@ethlete/query';
+import { HttpClient } from '@angular/common/http';
+import { HttpTestingController } from '@angular/common/http/testing';
+import { Injector } from '@angular/core';
+
+type QueryTestSetup = {
+    queryClient: NonNullable<ReturnType<AnyCreateQueryClientResult[1]>>;
+    queryClientRef: QueryClientRef;
+    httpClient: HttpClient;
+    httpTesting: HttpTestingController;
+    injector: Injector;
+    baseUrl: string;
+    createGet: ReturnType<typeof createGetQuery>;
+    createPost: ReturnType<typeof createPostQuery>;
+    createPut: ReturnType<typeof createPutQuery>;
+    createPatch: ReturnType<typeof createPatchQuery>;
+    createDelete: ReturnType<typeof createDeleteQuery>;
+};
+type QueryTestSetupConfig = {
+    baseUrl?: string;
+    name?: string;
+    mockErrorHandler?: boolean;
+};
+declare const setupQueryTest: (config?: QueryTestSetupConfig) => QueryTestSetup;
+
+type AnyFeatureBuilder = (context: BearerAuthProviderFeatureContext<any, readonly AnyQueryBuilder[]>) => {
+    type: string;
+    instance: unknown;
+};
+type AuthTestSetupConfig<TLoginArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TRefreshArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TFeatures extends readonly AnyFeatureBuilder[] = [], TBearerData = unknown> = {
+    /** The query test setup instance */
+    querySetup: QueryTestSetup;
+    /** Login endpoint path. Default: '/auth/login' */
+    loginPath?: string;
+    /** Refresh endpoint path. Default: '/auth/refresh' */
+    refreshPath?: string;
+    /** Whether to enable auto-retry on 401. Default: false */
+    autoRetryOn401?: boolean;
+    /** Function to extract tokens from login response */
+    extractLoginTokens?: (response: TLoginArgs['response']) => {
+        accessToken: string;
+        refreshToken: string;
+    };
+    /** Function to extract tokens from refresh response */
+    extractRefreshTokens?: (response: TRefreshArgs['response']) => {
+        accessToken: string;
+        refreshToken: string;
+    };
+    /** Feature builders for additional auth functionality */
+    features?: [...TFeatures];
+    /** Custom bearer decrypt function for testing */
+    bearerDecryptFn?: (token: string) => TBearerData;
+    /** Whether to disable multi-tab sync. Default: false */
+    multiTabSync?: false | {
+        enabled?: boolean;
+        channelName?: string;
+        syncTokens?: boolean;
+        syncLogout?: boolean;
+        leaderElection?: boolean;
+    };
+    /** Refresh strategy configuration. See TokenRefreshQueryConfig for details */
+    refreshStrategy?: TokenRefreshQueryConfig<TRefreshArgs>['refreshStrategy'];
+    /** Minimum refresh interval in milliseconds */
+    minRefreshInterval?: number;
+    /** Whether to refresh if token is already expired */
+    refreshIfExpired?: boolean;
+    /** Property name for expiration in JWT */
+    expiresInPropertyName?: string;
+};
+type AuthTestSetup<TLoginArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TRefreshArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TFeatures extends readonly AnyFeatureBuilder[] = [], TBearerData = unknown> = {
+    /** The bearer auth provider instance */
+    auth: BearerAuthProvider<[
+        AuthQueryBuilder<'login', TLoginArgs>,
+        TokenRefreshQueryBuilder<'refresh', TRefreshArgs>
+    ], TFeatures, TBearerData>;
+    /** Helper to login a user and flush the HTTP request */
+    login: (credentials: TLoginArgs['body'], response: TLoginArgs['response']) => void;
+    /** Helper to trigger a refresh and flush the HTTP request */
+    refresh: (token: string, response: TRefreshArgs['response']) => void;
+    /** Helper to make a secure request that requires authentication */
+    makeSecureRequest: (route: string) => void;
+};
+declare const setupAuthTest: <TLoginArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TRefreshArgs extends {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+} = {
+    body: Record<string, unknown>;
+    response: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}, TFeatures extends readonly AnyFeatureBuilder[] = readonly AnyFeatureBuilder[], TBearerData = unknown>(config: AuthTestSetupConfig<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>) => AuthTestSetup<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>;
+
+declare const expectAndFlush: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
+    status: number;
+    statusText: string;
+}) => void;
+declare const expectFlushAndWait: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
+    status: number;
+    statusText: string;
+}) => void;
+
+export { expectAndFlush, expectFlushAndWait, setupAuthTest, setupQueryTest };
+export type { AnyFeatureBuilder, AuthTestSetup, AuthTestSetupConfig, QueryTestSetup, QueryTestSetupConfig };