@tricoteuses/senat 2.22.16 → 3.0.0

package/lib/src/scripts/shared/prefixed_tables.d.ts

@@ -0,0 +1,10 @@
+export declare const senatSchemaName = "senat";
+export declare const rawTypesDir: string;
+export declare function prefixedName(datasetName: string, relationName: string): string;
+export declare function stagingSchemaName(datasetName: string): string;
+export declare function escapeRegExp(text: string): string;
+export declare function stripDatasetPrefix(relationName: string, datasetName: string): string;
+export declare function getGeneratedDefinitionPath(datasetName: string): string;
+export declare function getGeneratedTableManifestPath(datasetName: string): string;
+export declare function buildGeneratedTableManifest(datasetName: string, prefixedTables: string[]): string;
+export declare function extractPrefixedTableNamesFromGeneratedManifest(manifest: string, datasetName: string): string[];

package/lib/src/scripts/shared/prefixed_tables.js

@@ -0,0 +1,36 @@
+import path from "path";
+export const senatSchemaName = "senat";
+export const rawTypesDir = path.resolve("src", "raw_types");
+export function prefixedName(datasetName, relationName) {
+    return `${datasetName}_${relationName}`;
+}
+export function stagingSchemaName(datasetName) {
+    return `${datasetName}_staging`;
+}
+export function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function stripDatasetPrefix(relationName, datasetName) {
+    const datasetPrefix = `${datasetName}_`;
+    return relationName.startsWith(datasetPrefix) ? relationName.slice(datasetPrefix.length) : relationName;
+}
+export function getGeneratedDefinitionPath(datasetName) {
+    return path.join(rawTypesDir, `${datasetName}.ts`);
+}
+export function getGeneratedTableManifestPath(datasetName) {
+    return path.join(rawTypesDir, `${datasetName}.tables.json`);
+}
+export function buildGeneratedTableManifest(datasetName, prefixedTables) {
+    const manifest = {
+        dataset: datasetName,
+        prefixedTables: [...new Set(prefixedTables)],
+    };
+    return JSON.stringify(manifest, null, 2) + "\n";
+}
+export function extractPrefixedTableNamesFromGeneratedManifest(manifest, datasetName) {
+    const parsed = JSON.parse(manifest);
+    if (parsed.dataset !== datasetName || !Array.isArray(parsed.prefixedTables)) {
+        return [];
+    }
+    return [...new Set(parsed.prefixedTables.filter((tableName) => typeof tableName === "string"))];
+}

package/lib/src/scripts/shared/schema_version.d.ts

@@ -0,0 +1,3 @@
+export declare function buildEnsureSchemaVersionTableSql(schemaName: string): string;
+export declare function buildSchemaStructureFingerprintQuery(schemaName: string): string;
+export declare function buildIncrementSchemaVersionSql(schemaName: string): string;

package/lib/src/scripts/shared/schema_version.js

@@ -0,0 +1,97 @@
+function escapeSqlLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+export function buildEnsureSchemaVersionTableSql(schemaName) {
+    return `
+CREATE TABLE IF NOT EXISTS ${schemaName}.version(
+  number integer PRIMARY KEY
+);
+COMMENT ON TABLE ${schemaName}.version IS 'version of database';
+COMMENT ON COLUMN ${schemaName}.version.number IS 'version number of database schema';
+INSERT INTO ${schemaName}.version(number)
+SELECT 0
+WHERE NOT EXISTS (SELECT 1 FROM ${schemaName}.version);
+`;
+}
+export function buildSchemaStructureFingerprintQuery(schemaName) {
+    const escapedSchemaName = escapeSqlLiteral(schemaName);
+    return `
+WITH objects AS (
+  SELECT format('table:%s', table_class.relname) AS entry
+  FROM pg_class table_class
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  WHERE table_namespace.nspname = '${escapedSchemaName}'
+    AND table_class.relkind IN ('r', 'p')
+    AND table_class.relname <> 'version'
+
+  UNION ALL
+
+  SELECT format(
+    'column:%s:%s:%s:%s:%s:%s:%s:%s',
+    columns.table_name,
+    columns.ordinal_position,
+    columns.column_name,
+    columns.udt_schema,
+    columns.udt_name,
+    columns.is_nullable,
+    coalesce(columns.column_default, ''),
+    columns.is_identity
+  ) AS entry
+  FROM information_schema.columns columns
+  WHERE columns.table_schema = '${escapedSchemaName}'
+    AND columns.table_name <> 'version'
+
+  UNION ALL
+
+  SELECT format(
+    'constraint:%s:%s:%s:%s',
+    table_class.relname,
+    constraint_data.contype,
+    constraint_data.conname,
+    pg_get_constraintdef(constraint_data.oid, true)
+  ) AS entry
+  FROM pg_constraint constraint_data
+  JOIN pg_class table_class ON table_class.oid = constraint_data.conrelid
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  WHERE table_namespace.nspname = '${escapedSchemaName}'
+    AND table_class.relname <> 'version'
+    AND constraint_data.contype <> 'n'
+
+  UNION ALL
+
+  SELECT format(
+    'index:%s:%s',
+    table_class.relname,
+    pg_get_indexdef(idx.indexrelid)
+  ) AS entry
+  FROM pg_index idx
+  JOIN pg_class table_class ON table_class.oid = idx.indrelid
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  LEFT JOIN pg_constraint constraint_data ON constraint_data.conindid = idx.indexrelid
+  WHERE table_namespace.nspname = '${escapedSchemaName}'
+    AND table_class.relname <> 'version'
+    AND constraint_data.oid IS NULL
+
+  UNION ALL
+
+  SELECT format(
+    'sequence:%s:%s:%s:%s:%s:%s:%s:%s',
+    sequences.sequencename,
+    sequences.data_type,
+    sequences.start_value,
+    sequences.min_value,
+    sequences.max_value,
+    sequences.increment_by,
+    sequences.cycle,
+    sequences.cache_size
+  ) AS entry
+  FROM pg_sequences sequences
+  WHERE sequences.schemaname = '${escapedSchemaName}'
+)
+SELECT coalesce(md5(string_agg(entry, E'\\n' ORDER BY entry)), '')
+FROM objects
+`;
+}
+export function buildIncrementSchemaVersionSql(schemaName) {
+    return `UPDATE ${schemaName}.version SET number = number + 1`;
+}

package/lib/src/scripts/shared/staging_import.d.ts

@@ -0,0 +1,3 @@
+import type { Dataset } from "../../datasets";
+export declare function isCopyFromStdinLine(line: string): boolean;
+export declare function rewriteLineForStagingImport(line: string, dataset: Dataset, stagingSchema: string, inCopyData?: boolean): string;

package/lib/src/scripts/shared/staging_import.js

@@ -0,0 +1,80 @@
+function sourceSchemaNames(dataset) {
+    if (dataset.database === "sens") {
+        return ["sens", "senat"];
+    }
+    return [dataset.database];
+}
+function sourceSchemaAlternation(dataset) {
+    return sourceSchemaNames(dataset).join("|");
+}
+export function isCopyFromStdinLine(line) {
+    return /^COPY .* FROM stdin;$/i.test(line);
+}
+export function rewriteLineForStagingImport(line, dataset, stagingSchema, inCopyData = false) {
+    if (inCopyData) {
+        return line;
+    }
+    const sourceSchemas = sourceSchemaNames(dataset);
+    const sourceSchemaPattern = sourceSchemaAlternation(dataset);
+    const searchPathRegex = new RegExp(`^SET search_path = (public|${sourceSchemaPattern}), pg_catalog;$`, "i");
+    if (searchPathRegex.test(line)) {
+        return `SET search_path = ${stagingSchema}, pg_catalog;`;
+    }
+    const alterOwnerRegex = /^ALTER (SCHEMA|TABLE|SEQUENCE|INDEX|VIEW) .* OWNER TO /i;
+    if (alterOwnerRegex.test(line)) {
+        return "-- skipped OWNER TO during staging import";
+    }
+    if (/^(GRANT|REVOKE) /i.test(line)) {
+        return "-- skipped GRANT/REVOKE during staging import";
+    }
+    if (/^ALTER TABLE ONLY .* DROP CONSTRAINT /i.test(line)) {
+        return "-- skipped redundant DROP CONSTRAINT during staging import";
+    }
+    if (/^DROP INDEX /i.test(line)) {
+        return "-- skipped redundant DROP INDEX during staging import";
+    }
+    if (/^DROP TABLE /i.test(line)) {
+        return "-- skipped redundant DROP TABLE during staging import";
+    }
+    if (/^DROP SCHEMA public;$/i.test(line)) {
+        return "-- skipped redundant DROP SCHEMA public during staging import";
+    }
+    if (/^CREATE SCHEMA public;$/i.test(line)) {
+        return "-- skipped redundant CREATE SCHEMA public during staging import";
+    }
+    if (/^COMMENT ON SCHEMA public IS /i.test(line)) {
+        return "-- skipped redundant COMMENT ON SCHEMA public during staging import";
+    }
+    if (/^CREATE TABLE /i.test(line)) {
+        line = line.replace(/^CREATE TABLE /i, "CREATE UNLOGGED TABLE ");
+    }
+    if (/^CREATE SEQUENCE /i.test(line)) {
+        line = line.replace(/^CREATE SEQUENCE /i, "CREATE UNLOGGED SEQUENCE ");
+    }
+    const createSchemaRegex = new RegExp(`^CREATE SCHEMA (${sourceSchemaPattern});$`, "i");
+    if (createSchemaRegex.test(line)) {
+        return `CREATE SCHEMA IF NOT EXISTS ${stagingSchema};`;
+    }
+    // In dumps like debats, "COMMENT ON COLUMN debats.datsea" means table.column,
+    // not schema.table.column. Keep these statements untouched and let search_path resolve them.
+    const commentOnColumnRegex = /^COMMENT ON COLUMN ([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*) IS /i;
+    const commentOnColumnMatch = line.match(commentOnColumnRegex);
+    if (commentOnColumnMatch && sourceSchemas.includes(commentOnColumnMatch[1])) {
+        return line;
+    }
+    const parts = line.split(/(')/);
+    let inString = false;
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "'") {
+            inString = !inString;
+        }
+        else if (!inString) {
+            let rewrittenPart = parts[i].replace(/\bpublic\./g, `${stagingSchema}.`);
+            for (const sourceSchema of sourceSchemas) {
+                rewrittenPart = rewrittenPart.replace(new RegExp(`\\b${sourceSchema}\\.`, "g"), `${stagingSchema}.`);
+            }
+            parts[i] = rewrittenPart;
+        }
+    }
+    return parts.join("");
+}

package/lib/src/scripts/shared/staging_metadata_sql.d.ts

@@ -0,0 +1 @@
+export declare function buildExportStagingMetadataStatementsQuery(stagingSchema: string, targetSchema: string): string;

package/lib/src/scripts/shared/staging_metadata_sql.js

@@ -0,0 +1,221 @@
+function escapeSqlLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+export function buildExportStagingMetadataStatementsQuery(stagingSchema, targetSchema) {
+    const escapedStagingSchema = escapeSqlLiteral(stagingSchema);
+    return `
+WITH ordered_statements AS (
+  SELECT
+    10 AS group_no,
+    0 AS order_no,
+    sequences.sequencename AS object_name,
+    format('CREATE SEQUENCE IF NOT EXISTS %I.%I', '${targetSchema}', sequences.sequencename) AS statement
+  FROM pg_sequences sequences
+  WHERE sequences.schemaname = '${escapedStagingSchema}'
+
+  UNION ALL
+
+  SELECT
+    20 AS group_no,
+    0 AS order_no,
+    sequences.sequencename AS object_name,
+    format(
+      'ALTER SEQUENCE %I.%I AS %s INCREMENT BY %s MINVALUE %s MAXVALUE %s START WITH %s CACHE %s %s',
+      '${targetSchema}',
+      sequences.sequencename,
+      sequences.data_type,
+      sequences.increment_by,
+      sequences.min_value,
+      sequences.max_value,
+      sequences.start_value,
+      sequences.cache_size,
+      CASE WHEN sequences.cycle THEN 'CYCLE' ELSE 'NO CYCLE' END
+    ) AS statement
+  FROM pg_sequences sequences
+  WHERE sequences.schemaname = '${escapedStagingSchema}'
+
+  UNION ALL
+
+  SELECT
+    30 AS group_no,
+    0 AS order_no,
+    sequence_class.relname AS object_name,
+    CASE
+      WHEN dependent_table.relname IS NULL THEN format(
+        'ALTER SEQUENCE %I.%I OWNED BY NONE',
+        '${targetSchema}',
+        sequence_class.relname
+      )
+      ELSE format(
+        'ALTER SEQUENCE %I.%I OWNED BY %I.%I.%I',
+        '${targetSchema}',
+        sequence_class.relname,
+        '${targetSchema}',
+        dependent_table.relname,
+        dependent_column.attname
+      )
+    END AS statement
+  FROM pg_class sequence_class
+  JOIN pg_namespace sequence_namespace ON sequence_namespace.oid = sequence_class.relnamespace
+  LEFT JOIN pg_depend dependency
+    ON dependency.objid = sequence_class.oid
+   AND dependency.deptype = 'a'
+  LEFT JOIN pg_class dependent_table ON dependent_table.oid = dependency.refobjid
+  LEFT JOIN pg_namespace dependent_namespace ON dependent_namespace.oid = dependent_table.relnamespace
+  LEFT JOIN pg_attribute dependent_column
+    ON dependent_column.attrelid = dependent_table.oid
+   AND dependent_column.attnum = dependency.refobjsubid
+  WHERE sequence_namespace.nspname = '${escapedStagingSchema}'
+    AND sequence_class.relkind = 'S'
+    AND (
+      dependent_namespace.nspname IS NULL
+      OR dependent_namespace.nspname = '${escapedStagingSchema}'
+    )
+
+  UNION ALL
+
+  SELECT
+    40 AS group_no,
+    0 AS order_no,
+    format('%s.%s', table_class.relname, attribute.attname) AS object_name,
+    CASE
+      WHEN default_expr.expression IS NULL THEN format(
+        'ALTER TABLE %I.%I ALTER COLUMN %I DROP DEFAULT',
+        '${targetSchema}',
+        table_class.relname,
+        attribute.attname
+      )
+      ELSE format(
+        'ALTER TABLE %I.%I ALTER COLUMN %I SET DEFAULT %s',
+        '${targetSchema}',
+        table_class.relname,
+        attribute.attname,
+        replace(default_expr.expression, '${stagingSchema}.', '${targetSchema}.')
+      )
+    END AS statement
+  FROM pg_class table_class
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  JOIN pg_attribute attribute ON attribute.attrelid = table_class.oid
+  LEFT JOIN LATERAL (
+    SELECT pg_get_expr(attr_def.adbin, attr_def.adrelid) AS expression
+    FROM pg_attrdef attr_def
+    WHERE attr_def.adrelid = attribute.attrelid
+      AND attr_def.adnum = attribute.attnum
+  ) default_expr ON true
+  WHERE table_namespace.nspname = '${escapedStagingSchema}'
+    AND table_class.relkind IN ('r', 'p')
+    AND attribute.attnum > 0
+    AND NOT attribute.attisdropped
+    AND attribute.attgenerated = ''
+    AND attribute.attidentity = ''
+
+  UNION ALL
+
+  SELECT
+    50 AS group_no,
+    0 AS order_no,
+    table_class.relname AS object_name,
+    format(
+      'COMMENT ON TABLE %I.%I IS %L',
+      '${targetSchema}',
+      table_class.relname,
+      obj_description(table_class.oid, 'pg_class')
+    ) AS statement
+  FROM pg_class table_class
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  WHERE table_namespace.nspname = '${escapedStagingSchema}'
+    AND table_class.relkind IN ('r', 'p')
+
+  UNION ALL
+
+  SELECT
+    60 AS group_no,
+    0 AS order_no,
+    format('%s.%s', table_class.relname, attribute.attname) AS object_name,
+    format(
+      'COMMENT ON COLUMN %I.%I.%I IS %L',
+      '${targetSchema}',
+      table_class.relname,
+      attribute.attname,
+      col_description(table_class.oid, attribute.attnum)
+    ) AS statement
+  FROM pg_class table_class
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  JOIN pg_attribute attribute ON attribute.attrelid = table_class.oid
+  WHERE table_namespace.nspname = '${escapedStagingSchema}'
+    AND table_class.relkind IN ('r', 'p')
+    AND attribute.attnum > 0
+    AND NOT attribute.attisdropped
+
+  UNION ALL
+
+  SELECT
+    70 AS group_no,
+    CASE constraint_data.contype
+      WHEN 'p' THEN 1
+      WHEN 'u' THEN 2
+      WHEN 'c' THEN 3
+      WHEN 'f' THEN 4
+      ELSE 5
+    END AS order_no,
+    format('%s.%s', table_class.relname, constraint_data.conname) AS object_name,
+    format(
+      'ALTER TABLE %I.%I ADD CONSTRAINT %I %s',
+      '${targetSchema}',
+      table_class.relname,
+      constraint_data.conname,
+      replace(
+        replace(
+          pg_get_constraintdef(constraint_data.oid, true),
+          ' REFERENCES ' || '${stagingSchema}' || '.',
+          ' REFERENCES ${targetSchema}.'
+        ),
+        ' REFERENCES ONLY ' || '${stagingSchema}' || '.',
+        ' REFERENCES ONLY ${targetSchema}.'
+      )
+    ) AS statement
+  FROM pg_constraint constraint_data
+  JOIN pg_class table_class ON table_class.oid = constraint_data.conrelid
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  WHERE table_namespace.nspname = '${escapedStagingSchema}'
+    AND constraint_data.contype <> 'n'
+
+  UNION ALL
+
+  SELECT
+    80 AS group_no,
+    0 AS order_no,
+    format('%s.%s', table_class.relname, index_class.relname) AS object_name,
+    replace(
+      pg_get_indexdef(index_data.indexrelid),
+      ' ON ${stagingSchema}.',
+      ' ON ${targetSchema}.'
+    ) AS statement
+  FROM pg_index index_data
+  JOIN pg_class table_class ON table_class.oid = index_data.indrelid
+  JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+  JOIN pg_class index_class ON index_class.oid = index_data.indexrelid
+  LEFT JOIN pg_constraint constraint_data ON constraint_data.conindid = index_data.indexrelid
+  WHERE table_namespace.nspname = '${escapedStagingSchema}'
+    AND constraint_data.oid IS NULL
+
+  UNION ALL
+
+  SELECT
+    90 AS group_no,
+    0 AS order_no,
+    sequences.sequencename AS object_name,
+    format(
+      'SELECT setval(%L, %s, %s)',
+      '${targetSchema}.' || sequences.sequencename,
+      coalesce(sequences.last_value, sequences.start_value),
+      CASE WHEN sequences.last_value IS NULL THEN 'false' ELSE 'true' END
+    ) AS statement
+  FROM pg_sequences sequences
+  WHERE sequences.schemaname = '${escapedStagingSchema}'
+)
+SELECT encode(convert_to(statement, 'UTF8'), 'hex')
+FROM ordered_statements
+ORDER BY group_no, order_no, object_name;
+`;
+}

package/lib/src/scripts/validate_prefixed_tables.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/src/scripts/validate_prefixed_tables.js

@@ -0,0 +1,101 @@
+import commandLineArgs from "command-line-args";
+import fs from "fs-extra";
+import { sql } from "../databases_postgres";
+import { getChosenDatasets, getEnabledDatasets } from "../datasets";
+import { categoriesOption, silentOption } from "./shared/cli_helpers";
+import { extractPrefixedTableNamesFromGeneratedManifest, getGeneratedTableManifestPath, senatSchemaName, } from "./shared/prefixed_tables";
+const optionsDefinitions = [categoriesOption, silentOption];
+const options = commandLineArgs(optionsDefinitions);
+async function listPrefixedSenatTables(dataset) {
+    const prefix = `${dataset.database}_`;
+    const rows = await sql `
+    select tablename as relation_name
+    from pg_tables
+    where schemaname = ${senatSchemaName}
+      and tablename like ${prefix + "%"}
+    order by tablename
+  `;
+    return rows.map(({ relation_name }) => relation_name);
+}
+function getGeneratedDefinitionPath(dataset) {
+    return getGeneratedTableManifestPath(dataset.database);
+}
+function listExpectedPrefixedSenatTables(dataset) {
+    const manifestFilePath = getGeneratedDefinitionPath(dataset);
+    const manifest = fs.readFileSync(manifestFilePath, { encoding: "utf8" });
+    return extractPrefixedTableNamesFromGeneratedManifest(manifest, dataset.database);
+}
+async function listColumns(schema, relationName) {
+    const rows = await sql `
+    select column_name
+    from information_schema.columns
+    where table_schema = ${schema}
+      and table_name = ${relationName}
+    order by ordinal_position
+  `;
+    return rows.map(({ column_name }) => column_name);
+}
+async function validateDataset(dataset) {
+    const issues = [];
+    const expectedTables = listExpectedPrefixedSenatTables(dataset);
+    const prefixedTables = await listPrefixedSenatTables(dataset);
+    const expectedTableSet = new Set(expectedTables);
+    const senatTableSet = new Set(prefixedTables);
+    for (const tableName of expectedTables) {
+        if (!senatTableSet.has(tableName)) {
+            issues.push(`${senatSchemaName}.${tableName}: missing prefixed senat table`);
+        }
+    }
+    for (const tableName of prefixedTables) {
+        if (!expectedTableSet.has(tableName)) {
+            issues.push(`${senatSchemaName}.${tableName}: unexpected prefixed senat table`);
+        }
+    }
+    for (const tableName of expectedTables) {
+        if (!senatTableSet.has(tableName)) {
+            continue;
+        }
+        const senatColumns = await listColumns(senatSchemaName, tableName);
+        if (senatColumns.length === 0) {
+            issues.push(`${senatSchemaName}.${tableName}: no columns found for prefixed senat table`);
+        }
+    }
+    if (expectedTables.length === 0) {
+        issues.push(`${dataset.database}: no expected prefixed tables found in generated definitions`);
+    }
+    if (prefixedTables.length === 0) {
+        issues.push(`${dataset.database}: no prefixed senat tables found`);
+    }
+    return issues;
+}
+async function validatePrefixedTables() {
+    const enabledDatasets = getEnabledDatasets(options.categories);
+    const chosenDatasets = getChosenDatasets(enabledDatasets);
+    let hasErrors = false;
+    for (const dataset of chosenDatasets) {
+        const issues = await validateDataset(dataset);
+        if (issues.length === 0) {
+            if (!options.silent) {
+                console.log(`OK ${dataset.database}`);
+            }
+            continue;
+        }
+        hasErrors = true;
+        console.error(`Validation failed for ${dataset.database}:`);
+        for (const issue of issues) {
+            console.error(`- ${issue}`);
+        }
+    }
+    await sql.end();
+    if (hasErrors) {
+        process.exit(1);
+    }
+    if (!options.silent) {
+        console.log("All selected datasets passed prefixed-table validation.");
+    }
+}
+validatePrefixedTables().catch(async (error) => {
+    await sql.end();
+    console.error(error);
+    process.exit(1);
+});

package/lib/src/types/ameli.d.ts

@@ -1,5 +1,5 @@
-import { ses as Ses, sub as Sub, subFields, txt_ameli } from "../raw_types_schemats/ameli";
-export type { Ses, Sub };
-export interface TxtAmeli extends txt_ameli {
-    subids?: subFields.id[];
+import { TxtAmeli } from "../raw_types/ameli";
+import { Sub } from "../raw_types/ameli";
+export interface TxtAmeliCustom extends TxtAmeli {
+    subids?: Sub["id"][];
 }

package/lib/src/types/debats.d.ts

@@ -1,2 +1,2 @@
-import { debats as Debat, lecassdeb as LecAssDeb } from "../raw_types_schemats/debats";
-export type { Debat, LecAssDeb };
+import { Debats, Lecassdeb } from "../raw_types/debats";
+export type { Debats as Debat, Lecassdeb as LecAssDeb };