@objectstack/service-analytics 17.0.0-rc.3 → 17.0.0-rc.4

package/dist/index.d.cts

@@ -96,7 +96,46 @@ interface RelationshipTarget {
  * namespaced objects).
  */
 type RelationshipResolver = (baseObject: string, relationshipName: string) => string | RelationshipTarget | undefined;
-declare function compileDataset(dataset: Dataset, resolver?: RelationshipResolver): CompiledDataset;
+/**
+ * Optional probes the compiler consults to reject metadata that is decidable
+ * BEFORE any query runs. Every probe is optional and every one of them is
+ * tiered "cannot answer, do not block" (the same stand-down as
+ * `isRegisteredObject` / `getObjectFieldNames` on `AnalyticsServiceConfig`):
+ * a host without a data engine compiles exactly as it did before.
+ */
+interface DatasetCompileOptions {
+    /**
+     * [#5115] The datasource `objectName` DECLARES (`object.datasource`), or
+     * `undefined` when nothing authoritative can answer (no data engine, unknown
+     * object).
+     *
+     * With it the compiler can settle at COMPILE time what #5033 could only
+     * report at QUERY time: a dataset whose join crosses datasources declares a
+     * statement no driver can execute, because the analytics engine lowers the
+     * whole dataset into ONE SQL statement on the base object's datasource.
+     *
+     * IMPORTANT — `'default'` is not an answer. In `ObjectQL.getDriver`'s
+     * resolution order an explicit `object.datasource` other than `'default'`
+     * wins outright (step 1); `'default'` is the schema's DEFAULT value and means
+     * only "no explicit binding", after which routing is decided by
+     * `datasourceMapping` rules, the ADR-0057 §3.6 lifecycle split, and the
+     * owning package's `defaultDatasource` — none of which are visible from here.
+     * The compiler therefore treats `'default'`/`undefined` as UNANSWERED. See
+     * {@link compileDataset}.
+     */
+    getObjectDatasource?: (objectName: string) => string | undefined;
+    /**
+     * ADR-0062 D6 — is `objectName` federated (bound to an external datasource)?
+     *
+     * A federated participant is EXEMPT from the cross-datasource rejection:
+     * `NativeSQLStrategy.canHandle` already declines a cube whose base or joined
+     * object is external, so such a dataset is served by the ObjectQL FK-expand
+     * path (two reads, joined in memory) — which crosses datasources by
+     * construction. Rejecting it here would break a path that works today.
+     */
+    isExternalObject?: (objectName: string) => boolean;
+}
+declare function compileDataset(dataset: Dataset, resolver?: RelationshipResolver, options?: DatasetCompileOptions): CompiledDataset;
 
 /**
  * Dimension display-label resolution (ADR-0021).
@@ -352,6 +391,24 @@ interface AnalyticsServiceConfig {
      * `StrategyContext.isExternalObject`.
      */
     isExternalObject?: (objectName: string) => boolean;
+    /**
+     * [#5033] The datasource `objectName` is bound to, or `undefined` when it
+     * rides the default one (or nothing authoritative can answer).
+     *
+     * It never selects a driver (that is `engine.execute`'s `object` key, which
+     * the `plugin.ts` bridge now passes). It exists so that when a dataset's SQL
+     * references a table that is NOT on the datasource its base object routed to,
+     * the failure can name the actual cause — *table X is not on datasource Y* —
+     * instead of the misleading "backing object … is unavailable" that a
+     * cross-datasource join used to produce.
+     *
+     * [#5115] The same probe now also gates COMPILATION: `registerDataset` hands
+     * it to `compileDataset`, which rejects a dataset whose join crosses
+     * datasources before any query is ever built. Absence keeps the pre-#5115
+     * behaviour exactly ("cannot answer, do not block") — the query-time
+     * diagnostic above stays as the backstop.
+     */
+    getObjectDatasource?: (objectName: string) => string | undefined;
     /**
      * [#3867] Is `name` a registered object in this kernel's schema registry?
      *
@@ -383,6 +440,18 @@ interface AnalyticsServiceConfig {
      * the same mistake with a `400 INVALID_FIELD` naming the field (#4315/#4254);
      * this hook is what lets the ANALYTICS route give the same answer.
      *
+     * [#5520] The same probe now answers for DIMENSIONS too
+     * ({@link AnalyticsService.assertDimensionFields}). #4437 gated only the
+     * measure half, so the identical typo one key over — `dimensions:
+     * ['bogus_dim']` — still reached the driver as a `GROUP BY` column and came
+     * back as the same 500. One probe, one answer, both member kinds.
+     *
+     * [#5669] …and for the `where` members ({@link AnalyticsService.assertWhereFields}),
+     * the third and last request key that carries a field name. `where:
+     * {bogus_col: 'x'}` compiled straight into `WHERE bogus_col = $1` for exactly
+     * as long as #4437 and #5520 had each closed only their own key. One probe now
+     * answers for all three.
+     *
      * Same tiering as {@link isRegisteredObject}: absence means "skip the check"
      * (registry-less hosts, engine doubles, external datasources whose columns
      * are not mirrored locally). The production bridge in `plugin.ts` wires it
@@ -473,6 +542,13 @@ declare class AnalyticsService implements IAnalyticsService {
     private readonly isRegisteredObject?;
     /** [#4437] Field-name probe gating measure source-field resolution. */
     private readonly getObjectFieldNames?;
+    /**
+     * [#5033] Datasource probe for the missing-source triage — and, since #5115,
+     * for the compile-time cross-datasource join gate in `compileDataset`.
+     */
+    private readonly getObjectDatasource?;
+    /** ADR-0062 D6 — federated-object probe (strategy routing + #5115's gate). */
+    private readonly isExternalObject?;
     /** [#3867] One-shot flag for the {@link assertInferableCube} stand-down warning. */
     private warnedNoObjectRegistry;
     readonly cubeRegistry: CubeRegistry;
@@ -547,6 +623,19 @@ declare class AnalyticsService implements IAnalyticsService {
      *   `cube.measures` (e.g. `amount_sum`, `amount_avg` emitted by dashboard
      *   widget translators), inject suffix-inferred Metric entries so the
      *   strategies pick the right aggregation function and field.
+     *
+     * It is also where the three SOURCE-FIELD gates run, on every path out of this
+     * method and always BEFORE the (possibly augmented) cube is registered:
+     * {@link assertMeasureFields} (#4437), {@link assertDimensionFields} (#5520)
+     * and {@link assertWhereFields} (#5669) — one per request key that can carry a
+     * field name. All three answer the same question — does the object actually
+     * have the column this member resolves to — and all three must answer it here,
+     * because from the strategy onwards the answer is the driver's `no such
+     * column`.
+     *
+     * They run in request-key order (measures → dimensions/timeDimensions →
+     * where), so a query that gets several wrong is answered about one at a time,
+     * naming a real mistake either way.
      */
     private ensureCube;
     /**
@@ -578,6 +667,132 @@ declare class AnalyticsService implements IAnalyticsService {
      *   queries that used to work.
      */
     private assertMeasureFields;
+    /**
+     * [#5520] Reject a DIMENSION whose source field the backing object does not
+     * have, BEFORE the strategy compiles it into `GROUP BY`.
+     *
+     * The symmetric half of {@link assertMeasureFields}. #4437 closed the measure
+     * side and stopped there, so the identical mistake one request key over still
+     * reached the driver:
+     *
+     * ```
+     * POST /analytics/query {"cube":"crm_account","measures":["account_count"],"dimensions":["bogus_dim"]}
+     * → 500 {"code":"SQLITE_ERROR","message":"Internal server error"}
+     *
+     * POST /analytics/dataset/query {"selection":{"dimensions":["bogus_dim"],…}}
+     * → 500 {"code":"ANALYTICS_QUERY_FAILED",
+     *        "error":"SELECT bogus_dim AS \"bogus_dim\", … GROUP BY bogus_dim - no such column: bogus_dim"}
+     * ```
+     *
+     * A driver error class as the caller's `error.code` is the ADR-0112 violation
+     * #4437 named, and the dataset face additionally echoed the generated
+     * statement — physical table and column names — back to the caller. The
+     * envelope here is deliberately the SAME as the measure gate's
+     * (`INVALID_FIELD`/400 + `field`/`object`/`param`), because "the query names a
+     * field the object does not have" is ONE mistake and must have one wire shape
+     * whichever member kind carried it.
+     *
+     * What it checks, and what it deliberately does not:
+     *
+     * - **Both dimension keys.** `query.dimensions` and `query.timeDimensions`
+     *   land in the same `cube.dimensions` bag, are resolved by the same
+     *   `lookupMember`, and produced the same 500 (a bogus time dimension became
+     *   `date_trunc('month', bogus_at)`); `param` reports which key carried it.
+     * - **An UNDECLARED but real field stays legal.** `dimensions: ['phone']` on a
+     *   cube that never declared `phone` groups by `phone` today — the dimension
+     *   twin of measure auto-inference, and an established contract. So the
+     *   question asked is "does the OBJECT have this field", never "did the cube
+     *   declare this dimension". An undeclared member is checked against the
+     *   object under the name the strategies would use as the column (their own
+     *   `resolveDimensionSql`/`resolveFieldName` fallback: the member itself).
+     * - Only when the cube's `sql` is a bare OBJECT NAME, only when
+     *   {@link AnalyticsServiceConfig.getObjectFieldNames} answers, and only for
+     *   sources that are BARE COLUMNS — same three stand-downs as the measure
+     *   gate, for the same reasons (no field list to check against; nothing
+     *   authoritative to consult; a dotted reference resolves through a join whose
+     *   target this gate cannot see, so it belongs to the join allowlist).
+     * - `id` / `created_at` / `updated_at` are admitted unconditionally, matching
+     *   the data path's `resolveQueryFields`.
+     *
+     * Runs after the measure gate and before the `where` gate on each `ensureCube`
+     * path, so a query that gets several wrong is answered about its measure
+     * first — one rejection at a time, naming a real mistake either way.
+     */
+    private assertDimensionFields;
+    /**
+     * [#5669] Reject a `where` member whose source field the backing object does
+     * not have, BEFORE the strategy compiles it into `WHERE`.
+     *
+     * The third and last param of one defect. #4437 gated `measures`, #5520 gated
+     * `dimensions`/`timeDimensions`, and the filter face — the request key that
+     * most often carries a hand-typed field name — had no gate at all:
+     *
+     * ```
+     * POST /analytics/query {"cube":"crm_account","measures":["count"],"where":{"bogus_col":"x"}}
+     * → SELECT COUNT(*) AS "count" FROM "crm_account" WHERE bogus_col = $1
+     * → 500 {"code":"SQLITE_ERROR","message":"Internal server error"}
+     * ```
+     *
+     * Same envelope as its two siblings (`INVALID_FIELD`/400 + `field`/`object`/
+     * `param`), because "the query names a field the object does not have" is ONE
+     * mistake whichever request key carried it, and the DATA route has answered it
+     * that way since #4315/#4254 (`resolveQueryFields`).
+     *
+     * # Where the field names come from: the SQL producer's own reader
+     *
+     * The members are collected through `normalizeAnalyticsFilterTree` +
+     * `collectFilterLeaves` — the SAME pair both strategies call to build the
+     * predicate. This is deliberate and is the whole reason this gate is not a
+     * second filter-tree walker: a hand-rolled walk would have to re-derive
+     * `$and`/`$or`/`$not` recursion, `$`-prefixed operator keys, `$between`
+     * lowering, the nested-relation dot flattening (`{owner: {region: 'NA'}}` →
+     * member `owner.region`) and the #5334 array lowering, and every divergence
+     * would show up as "the field the gate saw" not being "the column that reached
+     * SQL" — in either direction (a phantom rejection, or a hole).
+     * `collectFilterLeaves` discards structure, which is exactly right here:
+     * whether a predicate sits under an `$or` changes nothing about whether its
+     * column exists. (Its doc's warning — never rebuild a predicate from this list
+     * — does not apply; this gate builds nothing.)
+     *
+     * # Three stand-downs at query level, plus the per-member ones
+     *
+     * - No {@link AnalyticsServiceConfig.getObjectFieldNames}, cube `sql` that is
+     *   not a bare object name, or a probe that cannot answer for the object — the
+     *   same three tiers as the measure and dimension gates, for the same reasons.
+     * - A `where` the normalizer REFUSES (an unknown operator, a non-array
+     *   `$and`, an unlowerable filter array) is not judged here: this gate stands
+     *   down and lets the refusal happen where it already does. Those inputs
+     *   already answer `INVALID_FILTER`/400 from the strategy (#5352/#5367's
+     *   geography, not this gate's), and pulling them forward into `ensureCube`
+     *   would newly refuse them on the draft-preview path too, whose
+     *   `matchesWhere` never consults the normalizer at all. A field gate that
+     *   cannot read the tree has nothing to say about it.
+     * - Per member, {@link resolveMemberSource} stands down on an expression `sql`
+     *   and on a dotted relation traversal — for the dimension gate's reasons.
+     *
+     * # Array `where` IS gated, and #5353's fix did not change that
+     *
+     * Since #5334 an array `where` is lowered by `normalizeAnalyticsFilterTree`
+     * and compiles to the identical predicate — a measured fact,
+     * `where: [['bogus_col','=','x']]` and `where: {bogus_col: 'x'}` both produce
+     * `WHERE bogus_col = $1` and hand `executeAggregate` the same
+     * `{bogus_col: 'x'}`. Gating one spelling and not the other would answer one
+     * mistake two ways, which is the split this whole gate family exists to close.
+     *
+     * `inferCubeFromQuery` used to skip an array `where` when minting the ad-hoc
+     * cube's `dimensions` — a separate question (the cube's dimension VOCABULARY,
+     * not which columns reach the driver), fixed by #5353 by lowering before
+     * reading keys. Because this gate reads filter LEAVES rather than
+     * `cube.dimensions`, that fix could not change its verdicts, and measurement
+     * confirms it did not: the array where's keys now reach `cube.dimensions`, so
+     * {@link resolveMemberSource} takes the DECLARED-dimension branch for those
+     * members instead of the undeclared-bare-column one — and both branches yield
+     * the same `source` for the same member, since the minted dimension's `sql` IS
+     * the member name. What did change is the rejection's suggestion list, in the
+     * direction that closes the split: `Valid filter members:` now reads the same
+     * for both spellings of one filter.
+     */
+    private assertWhereFields;
     /**
      * [#3867] Gate on the cube auto-inference path: a name with no registered
      * Cube may only be inferred into one if it is a registered object.
@@ -833,6 +1048,10 @@ declare class DatasetExecutor {
  * Left-merge `extra` rows onto `base` rows by their dimension-key tuple,
  * copying the listed value columns. Rows in `extra` with no base match are
  * appended (outer-ish merge so comparison-only buckets still surface).
+ *
+ * Rows are matched by {@link dimensionKeyOf} — read its notes before changing
+ * how the key is built. Both the ambiguity it removes and the type coercion it
+ * keeps are load-bearing, and both fail silently when got wrong.
  */
 declare function mergeByDimensions(base: Record<string, unknown>[], extra: Record<string, unknown>[], dimensions: string[], valueColumns: string[]): Record<string, unknown>[];
 
@@ -934,9 +1153,17 @@ declare class NativeSQLStrategy implements AnalyticsStrategy {
      * driver-backed `coerceTemporalFilterValue` hook (single source of truth for
      * the date/datetime storage convention — see StrategyContext); when the hook
      * is absent, or returns the value unchanged (the field is not a temporal
-     * column, or the dialect stores it as a native timestamp), falls back to the
-     * generic boolean/number recovery so non-temporal typed columns still bind
-     * correctly.
+     * column, or the dialect stores it as a native timestamp), falls back to
+     * {@link toSqlBindValue} so an unbindable JS type still reaches the driver as
+     * something it can bind.
+     *
+     * [#5526] `value` is `unknown`, not `string`, because a leaf now carries the
+     * author's comparand at its own type. Both halves of this method were already
+     * `unknown`-typed for it: the hook's contract is
+     * `coerceTemporalFilterValue(object, field, value: unknown)` and the fallback
+     * converts only what a driver cannot bind. What CHANGED is that a string is no
+     * longer re-typed on the way out — the fallback used to be
+     * `coerceFilterValueForSql`, which read `'007'` as the integer `7`.
      */
     private coerceTemporal;
     /**
@@ -965,6 +1192,25 @@ declare class NativeSQLStrategy implements AnalyticsStrategy {
      * does bind tighter than `OR`, so `a AND b OR c` happens to be right, but
      * being right by construction is what keeps a future edit from making it
      * wrong.
+     *
+     * # `null` is the constant TRUE, and TRUE absorbs a disjunction (#5325)
+     *
+     * A `null` return means "constrains nothing", which is the boolean TRUE — the
+     * AND identity, so it drops out of an `and`, but the OR ABSORBER, so one TRUE
+     * disjunct makes the whole `or` TRUE. Filtering it out of an `or` narrowed the
+     * query to the surviving branches. `NOT TRUE ≡ FALSE`, so a negation whose
+     * operand constrains nothing compiles to the FALSE constant rather than
+     * disappearing (which added no `WHERE` and charted every row).
+     *
+     * # The invariant that keeps `params` aligned
+     *
+     * **A call that returns `null` leaves `params` exactly as it found it.** It
+     * has to: a value bound with no `$n` to consume it shifts every later
+     * placeholder onto the wrong value, and a filter that binds the WRONG comparand
+     * is worse than one that is merely too wide (#5297). Leaves decide emptiness
+     * before they bind, and the absorbing `or` — the one place a clause that HAS
+     * bound is discarded — truncates back to the length it started at, so the
+     * invariant holds inductively for every node kind.
      */
     private compileFilterNode;
     private buildFilterClause;
@@ -1035,6 +1281,17 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
      * cannot be merged). A loud error beats the silent mis-bucket #3654 kills.
      * `generateSql()` calls this too, so the preview accepts/rejects the same set.
      *
+     * [#5716] All four refusals below are `invalidMemberError` — `INVALID_FIELD` /
+     * 400, naming the member — and the MESSAGES are unchanged (they are good
+     * diagnostics, and #5923's tests read them). Each is decided by two caller-side
+     * facts and nothing else: a member the query named, and whether that member
+     * resolves across a join. Neither is an internal invariant — a cube where the
+     * member exists and a driver that could serve it are both perfectly ordinary,
+     * which is exactly what the "run this on a native-SQL driver" half of each
+     * message says. They are member-level rather than dataset-level (hence not
+     * `datasetInvalidError`) because the fix is always to change or drop ONE named
+     * member, and because they fire on `/analytics/query` where no dataset exists.
+     *
      * Detection is on RESOLVED field names, so a dotted dimension the cube
      * flattens to a real column is treated as base, not cross-object.
      */
@@ -1055,10 +1312,21 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
      * Render one normalized filter as a display SQL predicate for `generateSql`.
      *
      * Mirrors `NativeSQLStrategy.buildFilterClause`'s operator vocabulary so the
-     * two previews read alike, but binds through `coerceFilterValueForObjectQL`:
-     * the comparand shown is the one THIS path actually hands the engine (a real
-     * boolean, not SQL's 1/0). Returns null for an operator/value combination
-     * that carries no predicate, matching `execute()`, which drops it too.
+     * two previews read alike, but binds the comparand VERBATIM: the value shown is
+     * the one THIS path actually hands the engine (a real boolean, not SQL's 1/0).
+     *
+     * [#5526] "Verbatim" is now literal. This used to bind through
+     * `coerceFilterValueForObjectQL`, which decoded the string a `string[]` leaf
+     * carried back into a type — so an echo could show `7` for a filter the author
+     * wrote as `'007'`. A leaf carries the author's value at its own type, so the
+     * echo needs no conversion at all to stay honest about execution. The LIKE
+     * family is still the one exception, for the reason `filter.zod.ts` gives: its
+     * comparand is declared a `string`, and what binds is the PATTERN.
+     *
+     * `null` means "this leaf carries no predicate" — a value-less scalar leaf,
+     * which `execute()` and `NativeSQLStrategy` drop too. It does NOT mean "I could
+     * not render that operator": #5333 was exactly that conflation, and an
+     * unrenderable operator now THROWS (see the exit below).
      */
     private buildFilterClauseSql;
     /**
@@ -1107,12 +1375,29 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
      * path hands them over rather than lowering them.
      */
     private applyFilterNode;
-    /** A node as a standalone `FilterCondition` the engine can consume. */
+    /**
+     * A node as a standalone `FilterCondition` the engine can consume.
+     *
+     * `null` = no constraint, which is the boolean TRUE — the AND identity but the
+     * OR ABSORBER, so a `null` branch makes the whole disjunction unconstrained
+     * instead of collapsing it to its surviving branches (#5325). FALSE is handed
+     * to the engine as `{$not: {}}`, the spelling `driver-sql`, `formula` and
+     * `driver-memory`'s matcher all already pin as the zero-row filter (#5134) —
+     * this strategy invents no second one.
+     */
     private filterNodeToCondition;
     /**
      * Render a normalized filter node as the display SQL `/analytics/sql`
      * echoes. Values still bind as `$n` placeholders — the echo travels to the
      * browser, so a comparand is never inlined.
+     *
+     * The boolean identities render too (#5325). This string exists to REPRODUCE
+     * execution: a `{$not: {}}` filter that runs as zero rows but echoes SQL with
+     * no `WHERE` hands whoever is debugging "why is this chart empty" a statement
+     * that returns the whole table. Same reason the absorbed `$or` branch and the
+     * `params` truncation below match {@link NativeSQLStrategy.compileFilterNode}
+     * exactly — including the invariant that a `null` return leaves `params`
+     * untouched, so no comparand is left with no placeholder to consume it.
      */
     private renderFilterNodeSql;
     private mergeFilterOperand;
@@ -1135,9 +1420,16 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
      * performs the same half-open translation itself because it binds into raw
      * SQL, so one dashboard reads the same on every driver.
      *
-     * Comparands are coerced by the SAME helper the `where` path uses, so an
-     * epoch-ms bound recovers as a number and an ISO string stays a string. No
-     * STORAGE coercion happens here, deliberately: `NativeSQLStrategy` needs
+     * [#5526] Bounds are forwarded at the type `dateRange` is DECLARED with —
+     * `string` (`AnalyticsQuerySchema`'s `timeDimensions[].dateRange: string[]`) —
+     * and nothing re-types them. They used to pass through
+     * `coerceFilterValueForObjectQL`, whose TSDoc advertised that "an epoch-ms
+     * bound recovers as a number"; that was a lenient CONSUMER rescuing a shape the
+     * contract does not declare, and the same guess is what read a `'007'` filter
+     * comparand as `7` (Prime Directive #12 — the producer or the spec is where an
+     * epoch-ms window would have to be declared, not here). An author who wants an
+     * instant window writes it as one; a declared `string` binds as a string. No
+     * STORAGE coercion happens here either, deliberately: `NativeSQLStrategy` needs
      * `coerceTemporal` because it binds into raw SQL and had to learn that a
      * SQLite `Field.datetime` is an INTEGER epoch (#2034); this path goes through
      * `engine.aggregate()`, where the driver's own CRUD filter coercion applies —
@@ -1156,6 +1448,23 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
      * fallback here errs toward the narrower query instead.
      */
     private dateRangeBounds;
+    /**
+     * One leaf as the operand the engine's `FilterCondition` expects.
+     *
+     * [#5526] The comparand is passed through UNCONVERTED. That is the whole of
+     * this path's share of the fix: the engine compares against the value as
+     * STORED, and a leaf now carries the value the author wrote, so `'007'` stays
+     * `'007'`, `true` stays `true` and `7` stays `7` with nothing in between to
+     * re-type them. The two `coerceFilterValueForObjectQL` calls this replaced
+     * existed only to undo `stringifyForCube`, and undoing it required guessing.
+     *
+     * The four LIKE-family arms are the exception, and a contract one:
+     * `filter.zod.ts` declares `$contains` / `$notContains` / `$startsWith` /
+     * `$endsWith` as `z.string()`, so this PRODUCER must hand the engine a real
+     * string — `String(…)`, the same normalisation `like-pattern.ts` applies at the
+     * two SQL emitters and `driver-sql`'s `applyLike` applies at the driver, so one
+     * `$contains` means one thing on every face (#5567's invariant).
+     */
     private convertFilter;
     private extractObjectName;
     /**
@@ -1180,4 +1489,4 @@ declare class ObjectQLStrategy implements AnalyticsStrategy {
     private buildFieldMeta;
 }
 
-export { AnalyticsService, type AnalyticsServiceConfig, AnalyticsServicePlugin, type AnalyticsServicePluginOptions, type CompareTo, type CompiledDataset, CubeRegistry, DatasetExecutor, type DerivedMeasureSpec, type DimensionLabelDeps, type FieldMetaLite, NativeSQLStrategy, ObjectQLStrategy, type OrderLabelResolver, type RelationshipResolver, type RelationshipTarget, combineFilters, compileDataset, compileScopedFilterToSql, createOrderLabelResolver, evaluateDerivedMeasures, fillEmptyGroups, mergeByDimensions, pickDisplayField, resolveDimensionLabels, shiftRange, withLabelFetchCache };
+export { AnalyticsService, type AnalyticsServiceConfig, AnalyticsServicePlugin, type AnalyticsServicePluginOptions, type CompareTo, type CompiledDataset, CubeRegistry, type DatasetCompileOptions, DatasetExecutor, type DerivedMeasureSpec, type DimensionLabelDeps, type FieldMetaLite, NativeSQLStrategy, ObjectQLStrategy, type OrderLabelResolver, type RelationshipResolver, type RelationshipTarget, combineFilters, compileDataset, compileScopedFilterToSql, createOrderLabelResolver, evaluateDerivedMeasures, fillEmptyGroups, mergeByDimensions, pickDisplayField, resolveDimensionLabels, shiftRange, withLabelFetchCache };