@dcupl/common 1.11.11 → 2.0.0-beta.0

package/dist/esm/indices.controller.d.ts

@@ -1,7 +1,18 @@
 import { InverseIndexValuesMap, InverseIndexDataValuesMap, ListItem } from './types';
+/**
+ * Statistics about indices for monitoring
+ */
+export interface IndexStats {
+    shallow: number;
+    deep: number;
+    total: number;
+    oldestAge: number;
+    avgAge: number;
+}
 export declare class IndicesController {
     private indexMap;
     private dataMap;
+    private indexMetadata;
     constructor();
     reset(attributeKey?: string): void;
     fillDataMap(attributeKey: string, attributeValue: Array<string | undefined | ListItem>): void;
@@ -10,4 +21,85 @@ export declare class IndicesController {
     getData(attributeKey: string, context?: any): InverseIndexDataValuesMap | undefined;
     getOrCreateIndex(attributeKey: string, relevantData: Map<string, ListItem>, context?: any): InverseIndexValuesMap;
     getIndexName(attributeKey: string, context?: any): string;
+    /**
+     * Removes a specific item from an inverse index
+     * @param attributeKey - The attribute key
+     * @param itemKey - The item key to remove
+     * @param oldValues - The old attribute values to remove from the index
+     */
+    removeFromInverseIndex(attributeKey: string, itemKey: string, oldValues: Array<string | undefined | ListItem>): void;
+    /**
+     * Updates inverse index for a specific item by removing old values and adding new ones
+     * @param attributeKey - The attribute key
+     * @param itemKey - The item key being updated
+     * @param oldValues - The old attribute values to remove
+     * @param newValues - The new attribute values to add
+     */
+    updateInverseIndex(attributeKey: string, itemKey: string, oldValues: Array<string | undefined | ListItem>, newValues: Array<string | undefined | ListItem>): void;
+    /**
+     * Removes a specific item from the data map
+     * @param attributeKey - The attribute key
+     * @param values - The values to remove
+     */
+    removeFromDataMap(attributeKey: string, values: Array<string | undefined | ListItem>): void;
+    /**
+     * Updates data map for a specific item by removing old values and adding new ones
+     * @param attributeKey - The attribute key
+     * @param oldValues - The old values to remove
+     * @param newValues - The new values to add
+     */
+    updateDataMap(attributeKey: string, oldValues: Array<string | undefined | ListItem>, newValues: Array<string | undefined | ListItem>): void;
+    /**
+     * Completely removes an item from all indices
+     * Used when an item is deleted
+     * @param itemKey - The item key to remove
+     */
+    removeItemFromAllIndices(itemKey: string): void;
+    /**
+     * Resets indices for specific attributes only
+     * Useful for partial updates when only certain attributes changed
+     * @param attributeKeys - Array of attribute keys to reset
+     */
+    resetAttributes(attributeKeys: string[]): void;
+    /**
+     * Checks if an index key represents a deep query (contains dots in the attribute path)
+     * Uses deep query service for accurate detection
+     * @param indexKey - The index key to check
+     * @returns true if the index is for a deep query attribute
+     */
+    private isDeepQueryIndex;
+    /**
+     * Gets all deep query index keys currently in the index map
+     * @returns Array of index keys that represent deep queries
+     */
+    getDeepIndexKeys(): string[];
+    /**
+     * Resets all deep query indices (e.g., "customer.country", "order.customer.address.city")
+     * This is critical for data updates as deep query indices need to be rebuilt
+     * when underlying data changes.
+     *
+     * Shallow indices (direct attributes) are preserved as they're updated incrementally.
+     */
+    resetAllDeepIndices(): void;
+    /**
+     * Gets count of indices by type for monitoring and debugging
+     * @returns Object with counts of shallow and deep indices
+     */
+    getIndexCount(): {
+        shallow: number;
+        deep: number;
+        total: number;
+    };
+    /**
+     * Removes stale indices that haven't been accessed recently
+     * This helps prevent memory buildup from indices with varying contexts
+     * @param maxAge - Maximum age in milliseconds (default: 5 minutes)
+     * @returns Number of indices cleaned up
+     */
+    cleanupStaleIndices(maxAge?: number): number;
+    /**
+     * Gets comprehensive statistics about indices for monitoring
+     * @returns IndexStats object with counts and age information
+     */
+    getStats(): IndexStats;
 }

package/dist/esm/logger/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger, logger } from './logger';
+export type { LogLevel, LoggerConfig, LogEntry, TrackedErrorEntry } from './logger';

package/dist/esm/logger/logger.d.ts

@@ -0,0 +1,101 @@
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+export interface LoggerConfig {
+    /** Minimum log level to output */
+    level?: LogLevel;
+    /** Output format: 'json' for production/cloud, 'pretty' for development */
+    format?: 'json' | 'pretty';
+    /** Optional prefix for all log messages (useful for module identification) */
+    prefix?: string;
+    /** Custom log handler (useful for sending logs to external services) */
+    onLog?: (entry: LogEntry) => void;
+    /** Handler for tracked errors (integrates with QualityController) */
+    onTrackError?: (entry: TrackedErrorEntry) => void;
+}
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: number;
+    prefix?: string;
+    context?: Record<string, any>;
+    error?: Error;
+}
+export interface TrackedErrorEntry extends LogEntry {
+    level: 'error';
+    errorType?: string;
+    errorGroup?: string;
+}
+export declare class Logger {
+    private config;
+    private static globalConfig;
+    constructor(config?: LoggerConfig);
+    /**
+     * Set global logger configuration (affects all logger instances)
+     */
+    static setGlobalConfig(config: Partial<LoggerConfig>): void;
+    /**
+     * Get the global logger configuration
+     */
+    static getGlobalConfig(): Partial<LoggerConfig>;
+    /**
+     * Configure module-specific log levels
+     * @example
+     * logger.setModuleLevel('ModelParser', 'debug');
+     * logger.setModuleLevel('Catalog', 'warn');
+     */
+    static setModuleLevel(module: string, level: LogLevel): void;
+    /**
+     * Get module-specific log level
+     */
+    private static getModuleLevel;
+    private getDefaultLevel;
+    private getDefaultFormat;
+    private getEffectiveLevel;
+    private shouldLog;
+    private formatMessage;
+    private getLevelIcon;
+    private log;
+    /**
+     * Log an error message
+     */
+    error(message: string, errorOrContext?: Error | Record<string, any>, context?: Record<string, any>): void;
+    /**
+     * Log and track an error (integrates with QualityController)
+     * @param message Error message
+     * @param error Error object
+     * @param options Additional context and error classification
+     */
+    trackError(message: string, error?: Error, options?: {
+        context?: Record<string, any>;
+        errorType?: string;
+        errorGroup?: string;
+    }): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, context?: Record<string, any>): void;
+    /**
+     * Log an info message
+     */
+    info(message: string, context?: Record<string, any>): void;
+    /**
+     * Log a debug message
+     */
+    debug(message: string, context?: Record<string, any>): void;
+    /**
+     * Create a child logger with additional context or configuration
+     * Child loggers inherit parent config but can override specific settings
+     *
+     * @example
+     * const modelLogger = logger.child({ prefix: 'ModelParser' });
+     * modelLogger.info('Processing data'); // [ModelParser] Processing data
+     *
+     * @example
+     * const debugLogger = logger.child({ prefix: 'Catalog', level: 'debug' });
+     */
+    child(childConfig: Partial<LoggerConfig>): Logger;
+    /**
+     * Update this logger's configuration
+     */
+    configure(config: Partial<LoggerConfig>): void;
+}
+export declare const logger: Logger;

package/dist/esm/pivot.d.ts

@@ -19,10 +19,11 @@ export type PivotOptions = {
 };
 type PivotResponseItem = {
     key: string;
+    value?: any;
     values?: Aggregation[];
     columns?: Omit<PivotResponseItem, 'rows'>[];
     rows?: PivotResponseItem[];
 };
 export type PivotResponse = PivotResponseItem;
-export declare function pivot<ListType extends ListItem = ListItem>(relevantData: Map<string, ListType>, options: PivotOptions, response?: PivotResponse, parentPath?: string, indicesCtrl?: IndicesController): PivotResponse;
+export declare function pivot<ListType extends ListItem = ListItem>(relevantData: Map<string, ListType>, options: PivotOptions, response?: PivotResponse, parentPath?: string, indicesCtrl?: IndicesController, projectedData?: Map<string, ListType>): PivotResponse;
 export {};

package/dist/esm/query-builder.d.ts

@@ -1,12 +1,43 @@
 import { DcuplGlobalQueryOptions, DcuplItemsOptions, DcuplQuery, DcuplQueryGroup } from './types';
+import { DeepQueryService } from './deep-query.service';
+export type QueryAttributeEntry = {
+    attribute: string;
+    reference?: string;
+    referenceAttribute?: string;
+    isDeepQuery?: boolean;
+};
 export declare class DcuplQueryBuilder {
     private _defaultQueryOptions;
     private _initOptions;
     private currentQuery;
-    constructor();
+    private deepQueryService;
+    constructor(deepQueryServiceInstance?: DeepQueryService);
+    /**
+     * Initialize the query builder.
+     * Accepts either minimal options with just modelKey, or a complete query object.
+     *
+     * @param options - Minimal { modelKey } or full DcuplGlobalQueryOptions
+     *
+     * @example
+     * // Minimal initialization
+     * builder.init({ modelKey: 'Product' });
+     *
+     * @example
+     * // Full query initialization
+     * builder.init({
+     *   modelKey: 'Product',
+     *   groupType: 'and',
+     *   queries: [
+     *     { operator: 'eq', attribute: 'status', value: 'active' },
+     *     { operator: 'gte', attribute: 'price', value: 100 }
+     *   ],
+     *   count: 10,
+     *   sort: { price: 'asc' }
+     * });
+     */
     init(options: {
         modelKey: string;
-    }): void;
+    } | DcuplGlobalQueryOptions<any>): void;
     reset(): DcuplGlobalQueryOptions<any>;
     isQuery(query: Partial<DcuplQuery> | Partial<DcuplQueryGroup>): query is DcuplQuery;
     isQueryGroup(query: Partial<DcuplQuery> | Partial<DcuplQueryGroup>): query is DcuplQueryGroup;
@@ -23,10 +54,412 @@ export declare class DcuplQueryBuilder {
         errors?: Error[];
     };
     applyOptions(options: DcuplItemsOptions<any>, mode?: 'set' | 'update'): DcuplGlobalQueryOptions<any>;
+    /**
+     * Apply query conditions, groups, or complete queries.
+     * This method has implicit behavior based on input type.
+     *
+     * @deprecated Use explicit methods instead for clearer intent:
+     * - {@link addCondition} - Add single condition
+     * - {@link addConditions} - Add multiple conditions
+     * - {@link addGroup} - Add query group
+     * - {@link setCondition} - Replace condition
+     * - {@link setConditions} - Replace conditions
+     * - {@link setGroup} - Replace query group
+     * - {@link mergeQuery} - Merge complete query
+     * - {@link replaceQuery} - Replace complete query
+     *
+     * @param queryToApply - Query, condition, or array to apply
+     * @param options - Mode: 'add' (default) or 'set' (replace)
+     * @param relevantQuery - Target query (defaults to current)
+     * @returns Updated query
+     */
     applyQuery(queryToApply: DcuplGlobalQueryOptions<any> | DcuplQueryGroup | DcuplQuery | DcuplQuery[] | DcuplQueryGroup[], options?: {
         mode?: 'set' | 'add';
     }, relevantQuery?: DcuplGlobalQueryOptions<any>): DcuplGlobalQueryOptions<any>;
+    /**
+     * Remove all query conditions.
+     *
+     * @deprecated Use {@link clearConditions} for clearer intent.
+     * @returns Query with no conditions
+     */
     removeAllQueries(): DcuplGlobalQueryOptions<any>;
+    /**
+     * Remove a specific query or query group.
+     *
+     * @param queryToRemove - Query or group to remove (partial match)
+     * @param relevantQuery - Target query (defaults to current)
+     * @returns Updated query
+     */
     removeQuery(queryToRemove: Partial<DcuplQueryGroup | DcuplQuery>, relevantQuery?: DcuplGlobalQueryOptions<any>): DcuplGlobalQueryOptions<any>;
     private validateQuery;
+    /**
+     * Get all attribute names used in the query.
+     *
+     * @deprecated Use {@link getAttributeNames} for clearer naming.
+     * @param query - Optional query to analyze
+     * @returns Array of attribute names
+     */
+    getQueryAttributes(query?: DcuplGlobalQueryOptions<any>): string[];
+    /**
+     * Extract detailed attribute information from query.
+     *
+     * @deprecated Use {@link getAttributeDetails} for clearer naming.
+     * @param query - Query to analyze
+     * @returns Array of QueryAttributeEntry objects
+     */
+    extractQueryAttributes(query: DcuplGlobalQueryOptions<any>): QueryAttributeEntry[];
+    /**
+     * Parse an attribute string into its components using the DeepQueryService
+     * This method now delegates to the centralized DeepQueryService for consistent
+     * parsing, caching, and validation across the codebase.
+     *
+     * @param attribute - The attribute path to parse (e.g., 'customer.name', 'items[0].price')
+     * @returns QueryAttributeEntry with isDeepQuery, reference, referenceAttribute
+     */
+    getQueryAttributeForString(attribute: string): QueryAttributeEntry;
+    /**
+     * Get the DeepQueryService instance used by this query builder
+     * Useful for accessing cache statistics and other service methods
+     *
+     * @returns The DeepQueryService instance
+     */
+    getDeepQueryService(): DeepQueryService;
+    getProjectionForAttributes(attributes: string[]): Record<string, boolean>;
+    getProjectionForAttributeEntries(attributes: QueryAttributeEntry[]): Record<string, boolean | Record<string, boolean>>;
+    /**
+     * Get all attribute names used in the query.
+     * Returns a simple array of unique attribute names.
+     *
+     * Clearer alternative to {@link getQueryAttributes}.
+     *
+     * @param query - Optional query to analyze. If not provided, uses current query.
+     * @returns Array of attribute names used in the query
+     *
+     * @example
+     * ```typescript
+     * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+     * builder.addCondition({ operator: 'gte', attribute: 'price', value: 100 });
+     * const attrs = builder.getAttributeNames(); // ['status', 'price']
+     * ```
+     */
+    getAttributeNames(query?: DcuplGlobalQueryOptions<any>): string[];
+    /**
+     * Get detailed information about attributes used in the query.
+     * Returns entries with deep query information (reference, referenceAttribute).
+     *
+     * Clearer alternative to {@link extractQueryAttributes}.
+     *
+     * @param query - Query to analyze. Defaults to current query if not provided.
+     * @returns Array of QueryAttributeEntry objects with details about each attribute
+     *
+     * @example
+     * ```typescript
+     * builder.addCondition({ operator: 'eq', attribute: 'customer.name', value: 'John' });
+     * const details = builder.getAttributeDetails();
+     * // [{ attribute: 'customer.name', isDeepQuery: true, reference: 'customer', referenceAttribute: 'name' }]
+     * ```
+     */
+    getAttributeDetails(query?: DcuplGlobalQueryOptions<any>): QueryAttributeEntry[];
+    /**
+     * Get attribute names from the current query state.
+     * Convenience method that operates on the current query.
+     *
+     * @returns Array of attribute names in current query
+     *
+     * @example
+     * ```typescript
+     * const attrs = builder.getCurrentAttributeNames();
+     * ```
+     */
+    getCurrentAttributeNames(): string[];
+    /**
+     * Get detailed attribute information from the current query state.
+     * Convenience method that operates on the current query.
+     *
+     * @returns Array of QueryAttributeEntry objects from current query
+     *
+     * @example
+     * ```typescript
+     * const details = builder.getCurrentAttributeDetails();
+     * ```
+     */
+    getCurrentAttributeDetails(): QueryAttributeEntry[];
+    /**
+     * Add query condition(s) to the current query.
+     * Accepts single condition or array of conditions.
+     * Each condition is added to its respective attribute group.
+     *
+     * Clearer alternative to `applyQuery(condition, { mode: 'add' })`.
+     *
+     * @param condition - Single query condition or array of conditions to add
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * // Add single condition
+     * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+     *
+     * // Add multiple conditions
+     * builder.addCondition([
+     *   { operator: 'eq', attribute: 'status', value: 'active' },
+     *   { operator: 'gte', attribute: 'price', value: 100 }
+     * ]);
+     * ```
+     */
+    addCondition(condition: DcuplQuery | DcuplQuery[]): DcuplGlobalQueryOptions<any>;
+    /**
+     * Add a query group to the current query.
+     * If a group with the same groupKey exists, extends it; otherwise creates new group.
+     *
+     * @param group - Query group to add
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * builder.addGroup({
+     *   groupKey: 'priceRange',
+     *   groupType: 'and',
+     *   queries: [
+     *     { operator: 'gte', attribute: 'price', value: 50 },
+     *     { operator: 'lte', attribute: 'price', value: 100 }
+     *   ]
+     * });
+     * ```
+     */
+    addGroup(group: DcuplQueryGroup): DcuplGlobalQueryOptions<any>;
+    /**
+     * Replace query with new condition(s).
+     * Accepts single condition or array of conditions.
+     * Each condition replaces all existing conditions for its attribute.
+     *
+     * Clearer alternative to `applyQuery(condition, { mode: 'set' })`.
+     *
+     * @param condition - Single query condition or array of conditions to set
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * // Replace with single condition
+     * builder.setCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+     *
+     * // Replace with multiple conditions
+     * builder.setCondition([
+     *   { operator: 'eq', attribute: 'status', value: 'active' },
+     *   { operator: 'gte', attribute: 'price', value: 100 }
+     * ]);
+     * ```
+     */
+    setCondition(condition: DcuplQuery | DcuplQuery[]): DcuplGlobalQueryOptions<any>;
+    /**
+     * Replace a query group with new definition.
+     * If group exists, replaces it; otherwise creates new group.
+     *
+     * @param group - Query group to set
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * builder.setGroup({
+     *   groupKey: 'priceRange',
+     *   groupType: 'and',
+     *   queries: [
+     *     { operator: 'gte', attribute: 'price', value: 100 },
+     *     { operator: 'lte', attribute: 'price', value: 200 }
+     *   ]
+     * });
+     * ```
+     */
+    setGroup(group: DcuplQueryGroup): DcuplGlobalQueryOptions<any>;
+    /**
+     * Merge a complete query into the current query.
+     * Adds all conditions and groups from the provided query.
+     *
+     * @param query - Complete query to merge
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * builder.mergeQuery({
+     *   modelKey: 'Product',
+     *   groupType: 'and',
+     *   queries: [
+     *     { operator: 'eq', attribute: 'status', value: 'active' },
+     *     { operator: 'gte', attribute: 'price', value: 100 }
+     *   ]
+     * });
+     * ```
+     */
+    mergeQuery(query: DcuplGlobalQueryOptions<any>): DcuplGlobalQueryOptions<any>;
+    /**
+     * Replace the entire current query with a new query.
+     * Completely replaces all conditions, groups, and options.
+     *
+     * @param query - Complete query to replace with
+     * @returns Updated query
+     *
+     * @example
+     * ```typescript
+     * builder.replaceQuery({
+     *   modelKey: 'Product',
+     *   groupType: 'or',
+     *   queries: [
+     *     { operator: 'eq', attribute: 'featured', value: true },
+     *     { operator: 'gte', attribute: 'rating', value: 4.5 }
+     *   ]
+     * });
+     * ```
+     */
+    replaceQuery(query: DcuplGlobalQueryOptions<any>): DcuplGlobalQueryOptions<any>;
+    /**
+     * Clear all query conditions and reset to initial state.
+     * Alias for {@link reset} with clearer intent.
+     *
+     * @returns Empty query
+     *
+     * @example
+     * ```typescript
+     * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+     * builder.clear(); // Removes all conditions
+     * ```
+     */
+    clear(): DcuplGlobalQueryOptions<any>;
+    /**
+     * Remove all query conditions but keep query structure.
+     * Alias for {@link removeAllQueries} with clearer intent.
+     *
+     * @returns Query with no conditions
+     *
+     * @example
+     * ```typescript
+     * builder.clearConditions(); // Remove all conditions but keep modelKey, etc.
+     * ```
+     */
+    clearConditions(): DcuplGlobalQueryOptions<any>;
+    /**
+     * Get an immutable copy of the current query state.
+     * Alias for {@link getQuery} with clearer intent.
+     *
+     * @returns Deep clone of current query
+     *
+     * @example
+     * ```typescript
+     * const snapshot = builder.getCurrentQuery();
+     * ```
+     */
+    getCurrentQuery(): DcuplGlobalQueryOptions<any>;
+    /**
+     * Check if the query has any conditions.
+     *
+     * @returns true if query has no conditions, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (builder.isEmpty()) {
+     *   console.log('No filters applied');
+     * }
+     * ```
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if a specific condition exists in the query.
+     *
+     * @param condition - Condition to check for (partial match)
+     * @returns true if condition exists
+     *
+     * @example
+     * ```typescript
+     * const hasStatus = builder.hasCondition({ attribute: 'status', value: 'active' });
+     * ```
+     */
+    hasCondition(condition: Partial<DcuplQuery>): boolean;
+    /**
+     * Check if a query group with the given key exists.
+     * Alias for {@link hasQueryGroup} with consistent naming.
+     *
+     * @param groupKey - Group key to check
+     * @returns true if group exists
+     *
+     * @example
+     * ```typescript
+     * if (builder.hasGroup('priceRange')) {
+     *   console.log('Price range filter is active');
+     * }
+     * ```
+     */
+    hasGroup(groupKey: string): boolean;
+    /**
+     * Get all unique attribute names used in the query.
+     * Convenience alias for {@link getAttributeNames}.
+     *
+     * @returns Array of attribute names
+     *
+     * @example
+     * ```typescript
+     * const attrs = builder.getUsedAttributes(); // ['status', 'price', 'customer.name']
+     * ```
+     */
+    getUsedAttributes(): string[];
+    /**
+     * Get only deep query attributes (e.g., 'customer.name', 'items[0].price').
+     * Filters out simple attributes and returns only those with references.
+     *
+     * @returns Array of deep query attribute details
+     *
+     * @example
+     * ```typescript
+     * const deepAttrs = builder.getDeepQueryAttributes();
+     * // [{ attribute: 'customer.name', isDeepQuery: true, reference: 'customer', referenceAttribute: 'name' }]
+     * ```
+     */
+    getDeepQueryAttributes(): QueryAttributeEntry[];
+    /**
+     * Get all query groups in the current query.
+     *
+     * @returns Array of query groups
+     *
+     * @example
+     * ```typescript
+     * const groups = builder.getGroups();
+     * // [{ groupKey: 'priceRange', groupType: 'and', queries: [...] }]
+     * ```
+     */
+    getGroups(): DcuplQueryGroup[];
+    /**
+     * Get top-level conditions (queries not inside groups).
+     *
+     * @returns Array of top-level query conditions
+     *
+     * @example
+     * ```typescript
+     * const topLevel = builder.getTopLevelConditions();
+     * ```
+     */
+    getTopLevelConditions(): DcuplQuery[];
+    /**
+     * Get a specific query group by its key.
+     * Alias for {@link getQueryGroup} with consistent naming.
+     *
+     * @param groupKey - Key of the group to retrieve
+     * @returns Query group or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const group = builder.getGroup('priceRange');
+     * if (group) {
+     *   console.log('Price range:', group.queries);
+     * }
+     * ```
+     */
+    getGroup(groupKey?: string): DcuplQueryGroup | undefined;
+    /**
+     * Count total number of conditions in the query (including nested).
+     *
+     * @returns Total count of query conditions
+     *
+     * @example
+     * ```typescript
+     * const count = builder.getConditionCount(); // 5
+     * ```
+     */
+    getConditionCount(): number;
 }