@tricoteuses/assemblee 2.5.31 → 3.0.1

package/lib/questions-DXAzvI1T.js

@@ -0,0 +1,230 @@
+import { z as e } from "zod";
+import { J as n, K as t, L as o, H as l, I as b, F as R, G as m, E as S } from "./amendements-CZHXlq07.js";
+const g = [
+  "",
+  "ADOPTION amendement (main levée) adt",
+  "ADOPTION d’un article (vote à main levée)",
+  "ADOPTION d’un sous-amendement (main levée) ss-adt",
+  "ADOPTION de plusieurs amendements (main levée) adts",
+  "ADOPTION de plusieurs sous-amendements (main levée) ss-adts",
+  "REJET d’un amendement (main levée) adt",
+  "REJET d’un article (vote à main levée)",
+  "REJET d’un sous-amendement (main levée) ss-adt",
+  "REJET de plusieurs amendements (main levée) adts",
+  "REJET de plusieurs sous-amendements (main levée) ss-adts",
+  "REJET motion de rejet préalable (main levée)"
+], h = e.enum(g), i = e.lazy(
+  () => e.object({
+    _: t(),
+    id_syceron: t(),
+    stime: t(),
+    sup: t(),
+    lienAdt: n(i).optional()
+  })
+), j = e.object({
+  nom: t(),
+  id: o(),
+  qualite: t()
+}), O = e.object({
+  orateur: n(j)
+}), a = e.lazy(
+  () => e.object({
+    id_preparation: t(),
+    ordre_absolu_seance: t(),
+    code_grammaire: t(),
+    sommaire: t(),
+    id_syceron: t(),
+    valeur_ptsodj: t(),
+    nivpoint: t(),
+    ordinal_prise: t(),
+    code_style: t(),
+    code_parole: t(),
+    valeur: t(),
+    orateurs: e.union([O, e.string()]).optional(),
+    texte: e.union([i, e.string()]).optional(),
+    paragraphe: n(a).optional(),
+    interExtraction: n(a).optional(),
+    point: n(a).optional(),
+    structure: t(),
+    id_acteur: t(),
+    id_mandat: t(),
+    id_nomination_oe: t(),
+    id_nomination_op: t(),
+    orateur: t(),
+    bibard: t(),
+    art: t(),
+    adt: t(),
+    ssadt: t(),
+    roledebat: t(),
+    changementPresidence: n(a).optional(),
+    type_debat: t(),
+    decision: h.optional(),
+    ouvertureSeance: a.optional(),
+    qualite: t(),
+    nom_orateur: t()
+  })
+), w = e.object({
+  point: a
+}), _ = e.object({
+  journee: e.string(),
+  session: e.string()
+}), y = e.object({
+  quantiemes: _,
+  ouvertureSeance: n(a).optional(),
+  point: n(a),
+  finSeance: w.optional(),
+  paragraphe: n(a).optional()
+}), f = e.object({
+  id_syceron: e.string(),
+  intitule: t(),
+  sousIntitule: t(),
+  type_debat: t()
+}), s = e.lazy(
+  () => e.object({
+    valeur_pts_odj: t(),
+    titreStruct: f,
+    para: n(e.union([i, e.string()])).optional(),
+    sommaire2: n(s).optional(),
+    sommaire3: n(s).optional(),
+    presidentSeance: n(i).optional(),
+    type_debat: t()
+  })
+), v = e.object({
+  presidentSeance: i,
+  sommaire1: n(s),
+  sommaire2: n(s).optional(),
+  sommaire3: n(s).optional(),
+  para: n(i).optional()
+}), T = e.object({
+  dateSeance: e.string(),
+  dateSeanceJour: e.string(),
+  numSeanceJour: e.string(),
+  numSeance: e.string(),
+  typeAssemblee: e.string(),
+  legislature: e.string(),
+  session: e.string(),
+  nomFichierJo: e.string(),
+  validite: e.string(),
+  etat: e.string(),
+  diffusion: e.string(),
+  version: e.string(),
+  environnement: e.string(),
+  heureGeneration: e.iso.datetime({ offset: !0 }),
+  sommaire: v
+}), u = e.object({
+  xmlns: e.string(),
+  uid: l(),
+  seanceRef: e.string(),
+  sessionRef: e.string(),
+  metadonnees: T,
+  contenu: y
+});
+e.object({
+  compteRendu: u
+});
+const J = e.object({
+  compteRendu: n(u)
+});
+e.object({
+  compteRendu: J
+});
+const E = [
+  "QuestionEcrite_Type",
+  "QuestionGouvernement_Type",
+  "QuestionOrale_Type"
+], x = e.enum(E), A = ["QE", "QG", "QOSD"], Q = e.enum(A), I = Q, D = [
+  "JO_QUESTION",
+  "JO_LOI_DECRET",
+  "JO_DEBAT"
+], q = e.enum(D), C = e.object({
+  numero: e.string(),
+  regime: e.string(),
+  legislature: e.string()
+}), c = e.object({
+  organeRef: b().meta({ description: "Référence à l'organe." }),
+  abrege: e.string(),
+  developpe: e.string()
+}), N = e.object({
+  acteurRef: R().meta({ description: "Référence à l'acteur." }),
+  mandatRef: e.string()
+}), P = e.object({
+  identite: N,
+  groupe: c
+}), r = e.object({
+  typeJO: q.nullable(),
+  dateJO: m().describe(
+    "Date de publication au Journal Officiel"
+  ),
+  pageJO: o().nullable(),
+  numJO: o().nullable(),
+  urlLegifrance: o().nullable(),
+  referenceNOR: o().nullable()
+}), G = e.object({
+  analyse: o().nullable()
+}), z = e.object({
+  rubrique: o().nullable(),
+  teteAnalyse: e.null(),
+  analyses: G
+}), F = e.object({
+  infoJO: r,
+  denomination: c
+}), L = e.object({
+  minAttrib: n(F)
+}), d = e.object({
+  infoJO: r,
+  texte: o().nullable(),
+  erratum: e.string().optional()
+}), M = e.object({
+  texteQuestion: n(d)
+}), X = e.object({
+  texteReponse: n(d)
+}), B = e.object({
+  codeCloture: e.string(),
+  libelleCloture: e.string(),
+  dateCloture: S(),
+  infoJO: r.nullable()
+}), H = e.object({
+  dateDepotSignal: m().describe(
+    "Date de dépôt du signalement"
+  ),
+  infoJO: r
+}), K = e.object({
+  infoJO: r
+}), U = e.object({
+  renouvellement: n(K)
+}), p = e.object({
+  "@xmlns": e.string().optional(),
+  "@xmlns:xsi": e.string(),
+  "@xsi:type": x,
+  uid: l().meta({ description: "Identifiant unique de la question." }),
+  identifiant: C,
+  type: I,
+  indexationAN: z,
+  auteur: P,
+  minInt: c,
+  minAttribs: L,
+  textesQuestion: M.nullable().optional(),
+  textesReponse: X.nullable().optional(),
+  cloture: B.nullable().optional(),
+  signalement: H.nullable().optional(),
+  renouvellements: U.nullable().optional()
+});
+e.object({
+  question: p
+});
+const k = e.object({
+  question: e.array(p)
+});
+e.object({
+  questions: k
+});
+export {
+  u as C,
+  h as D,
+  x as Q,
+  Q as T,
+  p as a,
+  g as d,
+  E as q,
+  A as t
+};

package/lib/registries.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/**
+ * Metadata for UIDs (unique identifiers)
+ */
+export interface UidMetadata {
+    /** Type of entity (acteur, organe, etc.) */
+    targetType: "acteur" | "organe" | "document" | "scrutin" | "auto";
+}
+/**
+ * Metadata for acteur/organe references
+ */
+export interface RefMetadata {
+    /** Type of reference */
+    refType: "acteur" | "organe";
+}
+/**
+ * Registry for UIDs (PA*, PO*, etc.)
+ */
+export declare const uidRegistry: z.core.$ZodRegistry<UidMetadata, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Registry for acteur references
+ */
+export declare const acteurRefRegistry: z.core.$ZodRegistry<RefMetadata, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Registry for organe references
+ */
+export declare const organeRefRegistry: z.core.$ZodRegistry<RefMetadata, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Registry for ISO 8601 dates
+ * Uses empty object as marker (presence in registry = true)
+ */
+export declare const dateRegistry: z.core.$ZodRegistry<{}, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Registry for custom summarizers (future UI integration)
+ */
+export declare const summarizerRegistry: z.core.$ZodRegistry<any, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Helper for creating a UID schema
+ *
+ * Validates Assemblée Nationale UID format (e.g., PA123456, PO123456)
+ *
+ * Use `.meta({ description: "..." })` on the returned schema to add documentation.
+ *
+ * @example
+ * ```typescript
+ * const acteurId = uid()  // Validates PA* or PO* format
+ * const withDesc = uid().meta({ description: "Identifiant acteur" })
+ * ```
+ */
+export declare function uid(): z.ZodString;
+/**
+ * Helper for creating an acteur reference schema
+ *
+ * Use `.meta({ description: "..." })` on the returned schema to add documentation.
+ */
+export declare function acteurRef(): z.ZodString;
+/**
+ * Helper for creating an organe reference schema
+ *
+ * Use `.meta({ description: "..." })` on the returned schema to add documentation.
+ */
+export declare function organeRef(): z.ZodString;
+/**
+ * Date parsing for Assemblée Nationale's format quirks
+ * Handles: "2023-01-15", "2023-01-15+01:00", null, undefined
+ *
+ * Integrates with existing date-fns utilities:
+ * - parseISO() for "YYYY-MM-DD"
+ * - dateFromYearMonthDayTimezoneString() for "YYYY-MM-DD+TZ"
+ */
+export declare const dateIso8601Base: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodDate>>;
+/**
+ * Optional date in ISO 8601 format
+ *
+ * Use `.meta({ description: "..." })` on the returned schema to add documentation.
+ */
+export declare const dateIso8601Optional: () => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodDate>>;
+/**
+ * Required date in ISO 8601 format
+ *
+ * Use `.meta({ description: "..." })` on the returned schema to add documentation.
+ */
+export declare const dateIso8601Required: () => z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodDate>> & z.ZodType<Date, unknown, z.core.$ZodTypeInternals<Date, unknown>>, z.ZodTransform<Date, Date>>;
+/**
+ * Trimmed string helper
+ */
+export declare const trimmedStringBase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodString>>;
+export declare const trimmedStringOptional: (description?: string) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodString>>;
+export declare const trimmedStringRequired: (description?: string) => z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodString>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+/**
+ * Ensure array helper
+ * Wraps single objects in arrays (handles XML→JSON single element quirk)
+ *
+ * XML: <item>foo</item> -> JSON: {item: "foo"} should become ["foo"]
+ * XML: <item>foo</item><item>bar</item> -> JSON: {item: ["foo", "bar"]}
+ */
+export declare function ensureArray<T extends z.ZodTypeAny>(itemSchema: T): z.ZodPipe<z.ZodTransform<unknown[], unknown>, z.ZodArray<T>>;
+/**
+ * Nullable helper
+ * Handles XML nil attributes and optional fields
+ *
+ * Handles:
+ * - {@xsi:nil: "true"} -> undefined
+ * - null -> undefined
+ * - undefined -> undefined
+ * - value -> value
+ */
+export declare function nullable<T extends z.ZodTypeAny>(schema: T): z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, T>>>;
+/**
+ * Helper for creating enums from const arrays
+ */
+export declare function enumFromConst<T extends readonly [string, ...string[]]>(values: T): z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>;