@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/semantic/sandbox.d.ts

@@ -0,0 +1,132 @@
+/**
+ * L'isolation par ligne et par colonne (« sandbox »).
+ *
+ * Le concept vient de Metabase (`enterprise/backend/src/metabase_enterprise/sandbox`) :
+ * un acteur n'est pas autorisé à lire toutes les lignes ni toutes les colonnes
+ * d'une ressource. Aucun code de l'amont n'est repris ici — l'adaptation porte
+ * sur le vocabulaire du noyau sémantique : une restriction porte sur une
+ * **dimension** du modèle, jamais sur une colonne brute, parce qu'une colonne
+ * brute peut ne pas exister dans le `baseSql` du modèle.
+ *
+ * Le module ne dépend d'aucun autre module du noyau : c'est le compilateur et
+ * l'évaluateur mémoire qui l'utilisent. Un filtre de ligne est converti en
+ * `QueryFilter`, ce qui garantit que la règle d'une ligne est évaluée par la
+ * **même** implémentation que celle d'un filtre de l'utilisateur.
+ */
+import type { FilterFieldType, QueryFilter, QueryValue } from "./filters/types";
+/**
+ * Les opérateurs qu'une restriction de ligne peut employer.
+ *
+ * Sous-ensemble deliberé de `FilterOperator` : une restriction de sécurité
+ * n'a pas besoin de `between` (une plage se décompose en deux bornes) ni des
+ * opérateurs temporels (ils dépendent d'un instant de reference, pas d'une
+ * regle figee).
+ */
+export declare const SANDBOX_OPERATORS: readonly ["equals", "not_equals", "in", "not_in", "contains", "starts_with", "greater_than", "less_than"];
+export type SandboxOperator = (typeof SANDBOX_OPERATORS)[number];
+/**
+ * Un filtre de ligne : une dimension du modèle, un opérateur, et soit des
+ * valeurs **fixes**, soit le nom d'un **attribut de l'acteur**.
+ *
+ * Metabase n'utilise que l'égalité et une valeur venue des attributs de
+ * l'utilisateur (`login_attributes`). On conserve ce cas — c'est le cas
+ * d'usage canonique d'un SaaS multi-tenant (« ne voir que les lignes dont le
+ * client est mon client ») — et on accepte en plus des valeurs fixes et
+ * quelques opérateurs, parce que le noyau sémantique sait déjà les evaluer.
+ */
+export interface SandboxRowFilter {
+    dimension: string;
+    operator: SandboxOperator;
+    /** Valeurs fixes de la regle. */
+    values?: QueryValue[];
+    /**
+     * Nom d'un attribut de l'acteur. Quand il est present, la valeur de la
+     * regle est lue dans les attributs de l'acteur au moment de l'execution.
+     */
+    attribute?: string;
+}
+/** Les attributs d'un acteur (cle -> valeur). */
+export type SandboxAttributes = Record<string, QueryValue>;
+/**
+ * L'ensemble des restrictions qui s'appliquent a un acteur pour un modele.
+ *
+ * `restrictedColumns` = colonnes que l'acteur ne peut **pas** lire.
+ * `obfuscatedColumns` = colonnes dont la valeur doit etre masquee dans le
+ * resultat (la colonne existe, la valeur ne doit pas fuir).
+ */
+export interface SandboxContext {
+    rowFilters: SandboxRowFilter[];
+    restrictedColumns: string[];
+    obfuscatedColumns: string[];
+}
+/** Une sandbox vide : l'acteur voit tout ce que le tenant lui deja. */
+export declare function emptySandbox(): SandboxContext;
+/** La sandbox est-elle vide (aucune restriction) ? */
+export declare function isEmptySandbox(sandbox: SandboxContext): boolean;
+/** La colonne est-elle interdite de lecture ? */
+export declare function sandboxRestrictsColumn(sandbox: SandboxContext, name: string): boolean;
+/** La valeur de la colonne doit-elle etre masquee ? */
+export declare function sandboxObfuscatesColumn(sandbox: SandboxContext, name: string): boolean;
+/**
+ * Verifie que l'acteur peut lire toutes les colonnes demandees.
+ *
+ * Une colonne restreinte fait echouer la requete : la retirer silencieusement
+ * du `SELECT` produirait un resultat trompeur (l'appelant croirait que la
+ * dimension est vide) et laisserait croire que l'acces a ete accorde.
+ */
+export declare function assertSandboxAllowsColumns(sandbox: SandboxContext, names: string[]): void;
+/**
+ * Convertit un filtre de ligne en filtre de l'utilisateur.
+ *
+ * Le filtre produit est evalue par la meme implementation que ceux de
+ * l'utilisateur (`evaluateFilter` en memoire, `compileFilter` en SQL) : une
+ * regle de securite ne peut donc pas diverger de la semantique declaree.
+ */
+export declare function sandboxToQueryFilter(filter: SandboxRowFilter): QueryFilter;
+/**
+ * Valide une sandbox venue de l'appelant.
+ *
+ * Une sandbox malformee est **refusee** (leve), jamais ignoree : l'ignorer
+ * reviendrait a lever une restriction d'acces sans le dire. Seule l'absence
+ * de sandbox (`undefined` / `null`) produit une sandbox vide.
+ */
+export declare function parseSandbox(value: unknown): SandboxContext;
+/**
+ * Resout les filtres de ligne en filtres **executables**.
+ *
+ * Un filtre porte soit des valeurs fixes, soit un attribut de l'acteur. La
+ * valeur d'un attribut est lue dans les attributs fournis ; si l'attribut est
+ * absent, la regle **leve** : une regle d'acces dont la valeur manque ne
+ * peut pas etre remplacee par « pas de filtre », sinon la restriction
+ * disparaitrait silencieusement au moment ou l'evaluation de la requete est
+ * la plus stricte.
+ */
+export declare function resolveSandboxFilters(sandbox: SandboxContext, attributes: SandboxAttributes, resolveType?: (dimension: string) => FilterFieldType | undefined): SandboxRowFilter[];
+/**
+ * Valide les attributs d'un acteur fournis par l'appelant.
+ *
+ * Un attribut mal typé est refuse : une regle qui devrait comparer un nombre
+ * a une chaine ne doit pas se comporter comme si la regle n'existait pas.
+ */
+export declare function parseSandboxAttributes(value: unknown): SandboxAttributes;
+/**
+ * Combine deux sandboxes : la **plus restrictive** l'emporte.
+ *
+ * - Les colonnes restreintes : **union**. Une colonne interdite par l'une des
+ *   deux regles reste interdite : la combinaison la plus restrictive de deux
+ *   listes de refus est leur reunion, pas leur intersection.
+ * - Les colonnes obfusquees : **union** egalement, pour la meme raison.
+ * - Les filtres de ligne : **union**. Une ligne doit satisfaire toutes les
+ *   regles : chaque predicat est ajoute au `WHERE`, donc la ligne est conservee
+ *   seulement si elle passe les deux.
+ */
+export declare function mergeSandboxes(base: SandboxContext, other: SandboxContext): SandboxContext;
+/**
+ * Masque les colonnes obfusquees d'un resultat.
+ *
+ * La valeur d'origine ne doit pas fuiter : elle est remplacee par `null`.
+ * Cette etape est une **defense en profondeur** — la requete SQL ne projetait
+ * deja pas la valeur d'une colonne restreinte — mais elle protege contre un
+ * driver qui renverrait une colonne non demandee.
+ */
+export declare function applySandboxToRows<T extends Record<string, unknown>>(rows: T[], sandbox: SandboxContext): T[];

package/dist/semantic/schema-registry.d.ts

@@ -0,0 +1,65 @@
+export type Schema = {
+    kind: "any";
+} | {
+    kind: "string";
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+} | {
+    kind: "number";
+    min?: number;
+    max?: number;
+    integer?: boolean;
+} | {
+    kind: "boolean";
+} | {
+    kind: "literal";
+    value: unknown;
+} | {
+    kind: "enum";
+    values: unknown[];
+} | {
+    kind: "array";
+    of: Schema;
+    minItems?: number;
+    maxItems?: number;
+} | {
+    kind: "object";
+    properties: Record<string, Schema>;
+    required?: string[];
+    additionalProperties?: boolean;
+} | {
+    kind: "tuple";
+    of: Schema[];
+} | {
+    kind: "map";
+    of: Schema;
+} | {
+    kind: "union";
+    of: Schema[];
+} | {
+    kind: "ref";
+    name: string;
+} | {
+    kind: "function";
+    fn: (value: unknown) => boolean | string;
+};
+export interface SchemaDef {
+    name: string;
+    schema: Schema;
+    version?: number;
+    description?: string;
+    coerce?: (value: unknown) => unknown;
+}
+declare class SchemaRegistry {
+    private schemas;
+    private versions;
+    register(def: SchemaDef): void;
+    unregister(name: string): void;
+    get(name: string): SchemaDef | undefined;
+    has(name: string): boolean;
+    list(): SchemaDef[];
+    getVersions(name: string): SchemaDef[];
+}
+export declare const schemaRegistry: SchemaRegistry;
+export {};

package/dist/semantic/schema-validator.d.ts

@@ -0,0 +1,16 @@
+import type { Schema } from "./schema-registry";
+import "./schemas/index";
+export interface ValidationError {
+    path: string[];
+    message: string;
+    schema?: string;
+    value?: unknown;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    value?: unknown;
+}
+export declare function validate(value: unknown, schemaName: string): ValidationResult;
+export declare function validateSchema(value: unknown, schema: Schema): ValidationResult;
+export declare function explain(schema: Schema | string): string;

package/dist/semantic/schemas/expr.schemas.d.ts

@@ -0,0 +1 @@
+export declare function registerExprSchemas(): void;

package/dist/semantic/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./query.schemas";
+export * from "./expr.schemas";
+export * from "./pipeline.schemas";
+export * from "./semantic-query.schemas";

package/dist/semantic/schemas/pipeline.schemas.d.ts

@@ -0,0 +1 @@
+export declare function registerPipelineSchemas(): void;

package/dist/semantic/schemas/query.schemas.d.ts

@@ -0,0 +1 @@
+export declare function registerQuerySchemas(): void;

package/dist/semantic/schemas/semantic-query.schemas.d.ts

@@ -0,0 +1 @@
+export declare function registerSemanticQuerySchema(): void;

package/dist/semantic/serialization.d.ts

@@ -0,0 +1,356 @@
+/**
+ * Le bundle semantique : l'export portable du catalogue d'un projet.
+ *
+ * Le bundle est un **contenu**, pas un instantane de base : il ne transporte
+ * ni identifiants techniques, ni horodatages, ni numero de version. Les noms
+ * servent de cles naturelles (un nom de modele, de segment, de transformation
+ * ou de question est unique dans un projet), ce qui permet d'importer le meme
+ * bundle dans deux projets sans collision d'identifiants, et de verifier
+ * qu'un aller-retour export/import/export redonne le meme contenu.
+ *
+ * Le format est versionne : une version superieure a celle que cette instance
+ * sait lire est refusee plutot que lue de travers.
+ *
+ * Le concept vient de la serialisation de Metabase
+ * (`enterprise/backend/src/metabase_enterprise/serialization`) : aucun code de
+ * l'amont n'est repris.
+ */
+import { z } from "zod";
+import type { MetricExpr } from "./expr";
+import type { SemanticDimension, SemanticJoin, SemanticMetric, SemanticModel, SemanticSegment, SemanticSource } from "./types";
+import type { SemanticParameter } from "./parameters/types";
+import type { SemanticQuery } from "./types";
+import type { PivotSpec } from "./pivot";
+import type { CachePolicy } from "./cache";
+export declare const SEMANTIC_BUNDLE_FORMAT = "lynxseo.semantic.bundle";
+export declare const SEMANTIC_BUNDLE_VERSION = 1;
+/** Un modele dans sa forme portable : sans identifiant ni horodatage. */
+export interface SemanticBundleModel {
+    name: string;
+    description?: string;
+    source: SemanticSource;
+    baseSql?: string;
+    joins?: SemanticJoin[];
+    parameters?: SemanticParameter[];
+    dimensions: SemanticDimension[];
+    metrics: SemanticMetric[];
+}
+/** Un segment dans sa forme portable : le modele est designe par son nom. */
+export interface SemanticBundleSegment {
+    name: string;
+    description?: string;
+    model: string;
+    filter: SemanticSegment["filter"];
+}
+/** Une transformation dans sa forme portable. */
+export interface SemanticBundleTransform {
+    name: string;
+    description?: string;
+    model?: string;
+    dependsOn: string[];
+    schedule?: string;
+    sql: string;
+}
+/** Une question enregistree dans sa forme portable. */
+export interface SemanticBundleQuestion {
+    name: string;
+    description?: string;
+    model: string;
+    query: SemanticQuery;
+    pivot?: PivotSpec;
+    display: "table" | "chart";
+    cachePolicy?: CachePolicy;
+}
+export interface SemanticBundle {
+    format: typeof SEMANTIC_BUNDLE_FORMAT;
+    version: number;
+    exportedAt: string;
+    models: SemanticBundleModel[];
+    segments: SemanticBundleSegment[];
+    transforms: SemanticBundleTransform[];
+    questions: SemanticBundleQuestion[];
+}
+/** Le schema du bundle, versionne et discrimine par son `format`. */
+export declare const semanticBundleSchema: z.ZodObject<{
+    format: z.ZodLiteral<"lynxseo.semantic.bundle">;
+    version: z.ZodNumber;
+    exportedAt: z.ZodString;
+    models: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                postgres: "postgres";
+                clickhouse: "clickhouse";
+                d1: "d1";
+                inline: "inline";
+            }>;
+            label: z.ZodString;
+            table: z.ZodOptional<z.ZodString>;
+            projectColumn: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        baseSql: z.ZodOptional<z.ZodString>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            model: z.ZodString;
+            on: z.ZodObject<{
+                left: z.ZodCustom<MetricExpr, MetricExpr>;
+                right: z.ZodCustom<MetricExpr, MetricExpr>;
+            }, z.core.$strip>;
+            type: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                inner: "inner";
+            }>>;
+        }, z.core.$strip>>>;
+        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+                category: "category";
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        dimensions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodCustom<MetricExpr, MetricExpr>;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            segmentable: z.ZodOptional<z.ZodBoolean>;
+            timezone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        metrics: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodCustom<MetricExpr, MetricExpr>;
+            type: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+            }>>;
+            unit: z.ZodOptional<z.ZodEnum<{
+                count: "count";
+                ratio: "ratio";
+                currency: "currency";
+                duration: "duration";
+                percent: "percent";
+                position: "position";
+                score: "score";
+            }>>;
+            direction: z.ZodOptional<z.ZodEnum<{
+                neutral: "neutral";
+                up: "up";
+                down: "down";
+            }>>;
+            format: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    segments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodString;
+        filter: z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                starts_with: "starts_with";
+                ends_with: "ends_with";
+                greater_than: "greater_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than: "less_than";
+                less_than_or_equal: "less_than_or_equal";
+                in: "in";
+                not_in: "not_in";
+                is_null: "is_null";
+                is_not_null: "is_not_null";
+                between: "between";
+                on: "on";
+                not_contains: "not_contains";
+                is_empty: "is_empty";
+                is_not_empty: "is_not_empty";
+                before: "before";
+                after: "after";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+            fieldType: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+            }>>;
+            period: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    year: "year";
+                }>;
+                value: z.ZodNumber;
+                offsetUnit: z.ZodOptional<z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    year: "year";
+                }>>;
+                offsetValue: z.ZodOptional<z.ZodNumber>;
+                includeCurrent: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            parameter: z.ZodOptional<z.ZodString>;
+            parameterTo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    transforms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        schedule: z.ZodOptional<z.ZodString>;
+        sql: z.ZodString;
+    }, z.core.$strip>>;
+    questions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodString;
+        query: z.ZodObject<{
+            model: z.ZodString;
+            dimensions: z.ZodArray<z.ZodString>;
+            metrics: z.ZodArray<z.ZodString>;
+            filters: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    starts_with: "starts_with";
+                    ends_with: "ends_with";
+                    greater_than: "greater_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than: "less_than";
+                    less_than_or_equal: "less_than_or_equal";
+                    in: "in";
+                    not_in: "not_in";
+                    is_null: "is_null";
+                    is_not_null: "is_not_null";
+                    between: "between";
+                    on: "on";
+                    not_contains: "not_contains";
+                    is_empty: "is_empty";
+                    is_not_empty: "is_not_empty";
+                    before: "before";
+                    after: "after";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+                fieldType: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                }>>;
+                period: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<{
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                        quarter: "quarter";
+                        year: "year";
+                    }>;
+                    value: z.ZodNumber;
+                    offsetUnit: z.ZodOptional<z.ZodEnum<{
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                        quarter: "quarter";
+                        year: "year";
+                    }>>;
+                    offsetValue: z.ZodOptional<z.ZodNumber>;
+                    includeCurrent: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                parameter: z.ZodOptional<z.ZodString>;
+                parameterTo: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                by: z.ZodString;
+                dir: z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>;
+            }, z.core.$strip>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                    category: "category";
+                }>;
+                label: z.ZodOptional<z.ZodString>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            parameterValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        }, z.core.$strip>;
+        pivot: z.ZodOptional<z.ZodObject<{
+            rowFields: z.ZodArray<z.ZodString>;
+            columnFields: z.ZodArray<z.ZodString>;
+            valueFields: z.ZodArray<z.ZodString>;
+            showRowTotals: z.ZodOptional<z.ZodBoolean>;
+            showColumnTotals: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        display: z.ZodEnum<{
+            table: "table";
+            chart: "chart";
+        }>;
+        cachePolicy: z.ZodOptional<z.ZodObject<{
+            ttlSeconds: z.ZodNumber;
+            earlyRefreshRatio: z.ZodOptional<z.ZodNumber>;
+            maxTtlSeconds: z.ZodOptional<z.ZodNumber>;
+            maxSizeKb: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Lit un bundle et le valide **en entier**.
+ *
+ * Le format et la version sont verifies avant le schema : un bundle ecrit par
+ * une version ulterieure de LynxSEO doit etre refuse avec un message qui
+ * nomme la version, pas avec une erreur de forme sur le premier champ.
+ */
+export declare function parseSemanticBundle(raw: string): SemanticBundle;
+/** Serialise un bundle de facon stable (indentation de deux espaces). */
+export declare function stringifySemanticBundle(bundle: SemanticBundle): string;
+/** Construit un bundle vide, a la version courante. */
+export declare function emptySemanticBundle(exportedAt: string): SemanticBundle;
+/**
+ * Le contenu d'un bundle, sans les enveloppe ni les champs volatils.
+ *
+ * Deux bundles egaux ont le meme contenu : c'est ce que verifie l'aller-retour
+ * export/import/export.
+ */
+export declare function semanticBundleContent(bundle: SemanticBundle): {
+    models: SemanticBundleModel[];
+    segments: SemanticBundleSegment[];
+    transforms: SemanticBundleTransform[];
+    questions: SemanticBundleQuestion[];
+};
+/** Reconvertit un modele de catalogue en modele portable. */
+export declare function toBundleModel(model: SemanticModel): SemanticBundleModel;

package/dist/semantic/sql-ast-builder.d.ts

@@ -0,0 +1,45 @@
+import type { SqlAstNode, SelectStmt, ColumnRef, LiteralExpr, BinaryExpr, UnaryExpr, RawSql, FunctionCall, CastExpr, CaseExpr, SubqueryExpr, CteStmt, OrderByItem, JoinClause, GroupByItem, WindowSpec, ParamRef, StarExpr, InExpr, BetweenExpr, ExistsExpr } from "./sql-ast";
+export declare const sql: {
+    bin: (op: string, left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    select: (cols: SqlAstNode[], from?: SqlAstNode, opts?: Partial<Omit<SelectStmt, "kind" | "columns" | "from">>) => SelectStmt;
+    col: (name: string, alias?: string, table?: string, expr?: SqlAstNode) => ColumnRef;
+    lit: (value: unknown) => LiteralExpr;
+    param: (index: number, type?: string, value?: unknown) => ParamRef;
+    fn: (name: string, args?: SqlAstNode[]) => FunctionCall;
+    count: (expr?: SqlAstNode) => FunctionCall;
+    sum: (expr: SqlAstNode) => FunctionCall;
+    avg: (expr: SqlAstNode) => FunctionCall;
+    min: (expr: SqlAstNode) => FunctionCall;
+    max: (expr: SqlAstNode) => FunctionCall;
+    and: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    or: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    eq: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    ne: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    gt: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    gte: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    lt: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    lte: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    add: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    sub: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    mul: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    div: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    is: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    isNot: (left: SqlAstNode, right: SqlAstNode) => BinaryExpr;
+    not: (expr: SqlAstNode) => UnaryExpr;
+    case: (whens: {
+        when: SqlAstNode;
+        then: SqlAstNode;
+    }[], elseExpr?: SqlAstNode) => CaseExpr;
+    cast: (expr: SqlAstNode, type: string) => CastExpr;
+    subquery: (stmt: SqlAstNode, alias?: string) => SubqueryExpr;
+    cte: (name: string, query: SqlAstNode, columns?: string[]) => CteStmt;
+    join: (table: SqlAstNode, on?: SqlAstNode, type?: JoinClause["type"]) => JoinClause;
+    orderBy: (expr: SqlAstNode, dir?: "asc" | "desc") => OrderByItem;
+    window: (name?: string, partitionBy?: SqlAstNode[], orderBy?: SqlAstNode[], frame?: string) => WindowSpec;
+    star: (table?: string) => StarExpr;
+    in: (expr: SqlAstNode, values: SqlAstNode[]) => InExpr;
+    between: (expr: SqlAstNode, low: SqlAstNode, high: SqlAstNode) => BetweenExpr;
+    exists: (subquery: SelectStmt) => ExistsExpr;
+    groupBy: (expr: SqlAstNode) => GroupByItem;
+    raw: (sql: string, params?: unknown[]) => RawSql;
+};