@ggui-ai/protocol 0.16.0 → 0.18.0

package/dist/schemas/app-generation-profile.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+/**
+ * The generator PROFILE slot on an app's `generation` section (ggui#991;
+ * the D7 mechanism of ggui#987 — "chosen at generation time, like layout").
+ *
+ * Four members of free text the app's operator writes and the generator
+ * reads when it composes a component: `styling` is the brief (voice,
+ * mood, references), `density` and `layout` are one line each, and
+ * `direction` (2026-09-11, ggui#1027 follower) is the COMPOSITION
+ * direction of one variant — what leads (a hero panel, rows with arrows,
+ * a compact row of chips, a split panel), what is left out (icons,
+ * helper text, status lines), motion or none — one short paragraph, so
+ * a family of variants is one draft under one judge with the direction
+ * as the only arm. The slot
+ * is a GENERATION-TIME input: it is not a theme-document field, not a
+ * consumed token, and MUST never be projected into the `--ggui-*`
+ * vocabulary the card reads. An absent or empty profile MUST leave the
+ * generator's prompts byte-identical to today's.
+ *
+ * Parties and obligations:
+ *   - WRITERS (an operator console, `ggui deploy`) send the object below
+ *     through the app-config write door; the door trims, bounds each
+ *     member at {@link APP_GENERATION_PROFILE_BOUNDS} and refuses control
+ *     characters other than tab, newline and carriage return, answering
+ *     `invalid_app_config` with {@link appGenerationProfileRefusalBodySchema}
+ *     in the transport's refusal slot (REST 422 body, AppSync `errorInfo`,
+ *     MCP `structuredContent`).
+ *   - READERS (`@ggui-ai/ui-gen` behind the server's render path) cap
+ *     defensively at the SAME numbers — a value over the bound is a door
+ *     defect, never a second rule — and treat absent and empty alike.
+ *
+ * Observable violation: a profile that reaches the generator unbounded, or
+ * a profile name surfacing as a `--ggui-*` token, is non-conformant.
+ */
+export const APP_GENERATION_PROFILE_BOUNDS = {
+    styling: 2000,
+    density: 200,
+    layout: 200,
+    direction: 600,
+};
+/**
+ * True when the text carries a C0 control character other than tab (0x09),
+ * newline (0x0A) or carriage return (0x0D), or DEL (0x7F). Written as a
+ * code-point walk on purpose: the intent is explicit, and no control
+ * character has to appear in source.
+ */
+function hasForbiddenControlChars(text) {
+    for (const ch of text) {
+        const c = ch.codePointAt(0) ?? 0;
+        if (c === 0x7f)
+            return true;
+        if (c < 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d)
+            return true;
+    }
+    return false;
+}
+function profileText(member) {
+    const max = APP_GENERATION_PROFILE_BOUNDS[member];
+    return z
+        .string()
+        .trim()
+        .max(max, `generation.profile.${member} exceeds ${max} characters`)
+        .refine((s) => !hasForbiddenControlChars(s), `generation.profile.${member} contains control characters`);
+}
+/**
+ * The effort level (ggui#1058, founder's A2): ONE name over the reader's
+ * dials (model tier × turn cap × eval rounds × visual bar × judge model).
+ * The wire carries only the name; the name → dials table is the reader's
+ * (versioned by it), so a price line can move without a wire change.
+ * Absent ⇒ the deployment's default level, which MUST equal today's fixed
+ * options. A level the deployment has not enabled is REFUSED at the write
+ * door (`{ profile: { effort: 'unavailable' } }`) — never downgraded.
+ */
+export const APP_GENERATION_PROFILE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'ultra'];
+/** Catalogue entry ids are slugs: trace-line and path safe, 2–64 chars. */
+export const APP_GENERATION_AESTHETIC_ID_RE = /^[a-z0-9][a-z0-9-]{1,63}$/;
+/** A preset content version: no whitespace, ≤ 32 chars. */
+export const APP_GENERATION_AESTHETIC_VERSION_RE = /^[A-Za-z0-9._-]{1,32}$/;
+/**
+ * A reference INTO the aesthetic/variance catalogue (data, kept by the
+ * deployment, never inside the generator): `id` is the catalogue entry — the
+ * same slug a draft carries as its variance `aesthetic` when both are
+ * present — and `version` pins the preset's content so a preset can be
+ * re-authored without re-keying served takes. The door validates GRAMMAR
+ * only; resolution happens at read, and an unresolvable reference is
+ * NON-FATAL: the generator proceeds without the aesthetic section and
+ * reports `profile_aesthetic_unresolved`.
+ */
+export const appGenerationAestheticRefSchema = z
+    .object({
+    id: z.string().regex(APP_GENERATION_AESTHETIC_ID_RE, 'aesthetic id must be a slug (2–64 chars, lowercase, digits, dashes)'),
+    version: z.string().regex(APP_GENERATION_AESTHETIC_VERSION_RE, 'aesthetic version: 1–32 chars, no whitespace').optional(),
+})
+    .strict();
+export const appGenerationProfileSchema = z
+    .object({
+    styling: profileText('styling').optional(),
+    density: profileText('density').optional(),
+    layout: profileText('layout').optional(),
+    direction: profileText('direction').optional(),
+    effort: z.enum(APP_GENERATION_PROFILE_EFFORTS).optional(),
+    aesthetic: appGenerationAestheticRefSchema.optional(),
+})
+    .strict();
+/**
+ * The READ-door variant of {@link appGenerationProfileSchema} (ggui#1105).
+ *
+ * The write door is strict and MUST stay so — it is what bounds each member
+ * and refuses control characters before a profile is stored. A READ door has
+ * the opposite job: a stored profile written by a LATER release carries a
+ * member this one cannot name, and refusing it there does not protect
+ * anything — it destroys a mint. Today the same stored profile is read two
+ * ways: the mint parses it strictly and THROWS (the mint dies), while the
+ * judge hand-rolls a `.strip()`. One document, two postures, diverging on
+ * exactly the member a later release adds.
+ *
+ * Third instance of one posture — see `schemas/app-theme.ts`
+ * (`parseAppThemeAtReadDoor`) and `schemas/data-contract.ts`
+ * (`parseDataContractAtReadDoor`). The rule they share:
+ *
+ *   **a read whose purpose is to INTERPRET state strips unknown members and
+ *   names what it stripped; a read whose purpose is to REPRODUCE state must
+ *   not strip at all.**
+ *
+ * This is an INTERPRET door. Only members this release does not NAME are
+ * stripped — never members it finds INVALID: a bound, a control character or
+ * a level outside the vocabulary is refused exactly as the write door refuses
+ * it.
+ */
+export const appGenerationProfileReadSchema = z.object(appGenerationProfileSchema.shape);
+/**
+ * Parse a stored generation profile at a READ door: `ok` with the profile and
+ * the top-level members that were stripped (payload order, `[]` when none), or
+ * the issues in `path: message` form when the profile is refused for a reason
+ * the write door would also refuse.
+ *
+ * Every reader of a STORED profile should use this — the mint and the judge
+ * reading one document two ways is the defect ggui#1105 exists for, and one
+ * exported door is how that stops being possible rather than being noticed.
+ */
+export function parseAppGenerationProfileAtReadDoor(input) {
+    const parsed = appGenerationProfileReadSchema.safeParse(input);
+    if (!parsed.success) {
+        return { ok: false, issues: parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`) };
+    }
+    const known = new Set(Object.keys(appGenerationProfileSchema.shape));
+    const stripped = typeof input === 'object' && input !== null && !Array.isArray(input)
+        ? Object.keys(input).filter((k) => !known.has(k))
+        : [];
+    return { ok: true, profile: parsed.data, stripped };
+}
+/** Why the door refused one member — one reason per member, at least one member named. */
+export const appGenerationProfileRefusalReasonSchema = z.enum(['too-long', 'not-text', 'control-chars', 'unavailable']);
+export const appGenerationProfileRefusalBodySchema = z
+    .object({
+    profile: z
+        .object({
+        styling: appGenerationProfileRefusalReasonSchema.optional(),
+        density: appGenerationProfileRefusalReasonSchema.optional(),
+        layout: appGenerationProfileRefusalReasonSchema.optional(),
+        direction: appGenerationProfileRefusalReasonSchema.optional(),
+        effort: appGenerationProfileRefusalReasonSchema.optional(),
+        aesthetic: appGenerationProfileRefusalReasonSchema.optional(),
+    })
+        .strict()
+        .refine((p) => Object.keys(p).length > 0, 'a profile refusal names at least one member'),
+})
+    .strict();

package/dist/schemas/app-theme.d.ts

@@ -40,6 +40,76 @@ export declare const CSS_VALUE_SAFE_RE: RegExp;
  */
 export declare const KEYFRAMES_NAME_RE: RegExp;
 export declare function isKeyframesText(text: string): boolean;
+/**
+ * One declared font face (ggui#987 §5; lifted here for ggui#1093 / #990 so the
+ * theme DOCUMENT's `typography.faces` and the AppTheme WIRE's `fonts` share
+ * ONE grammar — `@ggui-ai/project-config` imports this schema for the
+ * document door). `src` MUST be `https:` with a well-formed host; the face is
+ * DECLARED, never fetched by any door: the render host unions the origin into
+ * its `font-src`, the shell renders the `@font-face` rule, and a face that
+ * fails to load in the browser falls back down the family's stack.
+ */
+export declare const fontFaceDeclarationSchema: z.ZodObject<{
+    family: z.ZodString;
+    src: z.ZodString;
+    weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    style: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FontFaceDeclaration = z.infer<typeof fontFaceDeclarationSchema>;
+/** The most faces one theme may declare on the wire — a CSP and a `<style>` block stay bounded. */
+export declare const APP_THEME_FONTS_MAX = 16;
+/** The imagery slots a theme may fill (ggui#1093): a brand mark, a hero image, a repeating pattern. */
+export declare const APP_THEME_IMAGERY_KINDS: readonly ["mark", "hero", "pattern"];
+export type AppThemeImageryKind = (typeof APP_THEME_IMAGERY_KINDS)[number];
+/**
+ * One image asset: https-only `src` (never fetched by a door), an optional
+ * `alt` (≤ 200) and an optional `tone` — the image's own tonality (`light` /
+ * `dark`), so a composer can place ink over it without sampling pixels.
+ */
+export declare const appThemeImageAssetSchema: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+    }>>;
+}, z.core.$strict>;
+export type AppThemeImageAsset = z.infer<typeof appThemeImageAssetSchema>;
+/**
+ * The host's imagery, by slot (ggui#1093, #1075 Track C (a)). Parties: a
+ * WRITER (an operator's design tooling, or a harvest of the host page) declares; the WRITE door
+ * validates this grammar and nothing more; the render host unions every
+ * `src` origin into its `img-src`; the composer reads the slots through
+ * the design primitives. Absent ⇒ no imagery, today's card.
+ */
+export declare const appThemeImagerySchema: z.ZodObject<{
+    mark: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>>;
+    }, z.core.$strict>>;
+    hero: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>>;
+    }, z.core.$strict>>;
+    pattern: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AppThemeImagery = z.infer<typeof appThemeImagerySchema>;
 export declare const appThemeSchema: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
         light: "light";
@@ -57,14 +127,216 @@ export declare const appThemeSchema: z.ZodObject<{
         dark: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     frameless: z.ZodOptional<z.ZodBoolean>;
+    fonts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        family: z.ZodString;
+        src: z.ZodString;
+        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodString>;
+        display: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    imagery: z.ZodOptional<z.ZodObject<{
+        mark: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+        hero: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+        pattern: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type AppTheme = z.infer<typeof appThemeSchema>;
+/**
+ * The READ-door posture (ggui#1093 belt, 2026-09-15; VERSION-POLICY §3.6).
+ *
+ * `appThemeSchema` is the WRITE door: strict, an unknown top-level member is
+ * refused (`invalid_app_config`). A READ door — a stored row turned into
+ * paint, a carried `_meta["ai.ggui/render"].theme` slice — parses with THIS
+ * schema instead: an unknown TOP-LEVEL member is stripped, the overlays are
+ * kept, and the caller reports what it stripped (one line per read, keys
+ * only, never theme content). Everything below the top level is unchanged —
+ * nested objects stay strict, token grammar and value safety still refuse,
+ * the v1 shape still refuses — and the attestation is untouched because
+ * `overlayHash` covers `{ overlays, cssVariables, keyframes }` only.
+ *
+ * Why: a reader on release N−1 meeting a member release N added would
+ * otherwise drop the WHOLE theme — colours and all — until it rolled
+ * (guuey#1266's class). Parties: every read door of an `AppTheme` MUST use
+ * this variant (or {@link parseAppThemeAtReadDoor}); every write door MUST
+ * stay on `appThemeSchema`. Observable violation: a read door dropping a
+ * theme whose overlays are valid because of an unknown top-level member —
+ * the kit's `n1-compat` forward case grades it.
+ */
+export declare const appThemeReadSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    overlayHash: z.ZodString;
+    overlays: z.ZodObject<{
+        light: z.ZodRecord<z.ZodString, z.ZodString>;
+        dark: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    cssVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    keyframes: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodString>;
+        dark: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    frameless: z.ZodOptional<z.ZodBoolean>;
+    fonts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        family: z.ZodString;
+        src: z.ZodString;
+        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodString>;
+        display: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    imagery: z.ZodOptional<z.ZodObject<{
+        mark: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+        hero: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+        pattern: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type AppThemeReadDoorResult = {
+    readonly ok: true;
+    readonly theme: AppTheme;
+    readonly stripped: readonly string[];
+} | {
+    readonly ok: false;
+    readonly issues: readonly string[];
+};
+/**
+ * Parse a stored or carried theme at a READ door: `ok` with the theme and
+ * the top-level members that were stripped (payload order, `[]` when none),
+ * or the issues in `path: message` form when the theme is refused for a
+ * reason the write door would also refuse.
+ *
+ * TWO READ PATHS, OPPOSITE OBLIGATIONS — they sit next to each other and
+ * they are NOT the same door (ggui#1124; do not "tidy" them into one):
+ *
+ *   **a read whose purpose is to INTERPRET state strips unknown members
+ *   and names what it stripped; a read whose purpose is to REPRODUCE
+ *   state must not strip at all.**
+ *
+ * This function is the INTERPRET side — a server painting a theme, an
+ * operator surface rendering one — and a reader must not be handed data it
+ * cannot validate.
+ * The REPRODUCE side is a writer's CARRY path, which receives the stored
+ * document VERBATIM, including members this release does not name: its job
+ * is fidelity, not interpretation. Applying THIS strip to a carry path is
+ * the ggui#1124 defect exactly — the writer carries a stripped document,
+ * writes it back, and destroys the members the belt exists to protect.
+ */
+export declare function parseAppThemeAtReadDoor(input: unknown): AppThemeReadDoorResult;
 /**
  * The ONE refusal body every write door returns for an overlay it will not
  * store (ggui#987 §3.4): REST 422 `invalid_app_config`, the AppSync
  * `errorInfo`, the MCP ops door's `{ ok: false }` structured content. A
  * discriminated union by key — exactly one of the four.
  */
+/**
+ * The top-level members the STORED theme holds that an incoming write does
+ * not carry — i.e. exactly what the write would destroy (ggui#1124).
+ *
+ * `putAppTheme` REPLACES the whole `theme` attribute (the shared writer's
+ * `SET theme = :theme`), so a writer that composes fewer members than the
+ * stored document silently deletes the rest. On 2026-09-10, 26 rows lost
+ * their theme outright and ~20 more lost members nobody can now name,
+ * because a writer believed the door merged. **The rule lives here because
+ * what makes a write destructive is a fact about the wire shape, not about
+ * a storage engine** — the shared writer enforces it at the choke point, so
+ * safety does not depend on each door remembering.
+ *
+ * Deliberately total and deliberately dumb: it compares TOP-LEVEL keys and
+ * nothing else. A changed VALUE is not a drop. An explicit `undefined` IS a
+ * drop, because absent and undefined are the same wire fact. A member this
+ * release does not name still counts — that is the whole point, since a
+ * strict schema cannot see the member a later release wrote, and a
+ * whole-column write is exactly what destroys it. Given anything that is not
+ * a plain object on either side it reports nothing rather than inventing a
+ * drop: a guard that guesses is worse than one that abstains.
+ *
+ * Parties: the SHARED WRITER calls this before writing and refuses a
+ * non-empty result with {@link appThemeRefusalBodySchema}'s `wouldDrop` arm,
+ * naming the members; the WRITER retries carrying them (read the stored
+ * document, carry what it does not own by REST OMISSION — never by
+ * enumerating what it knows — and hash after the carry). Observable
+ * violation: a stored member absent after a write that did not name it.
+ */
+export declare function appThemeDroppedMembers(stored: unknown, incoming: unknown): readonly string[];
+/**
+ * The ONE wording for a `wouldDrop` refusal (ggui#1124, founder's ruling
+ * 2026-09-16: *"the refusal names the clear-then-set path"*). Exported so
+ * every door that refuses a destructive theme write carries the SAME words
+ * rather than paraphrasing them — a writer meeting two different
+ * explanations of one rule learns neither.
+ *
+ * Why the wording is part of the contract and not decoration: **a refusal
+ * with no compliance path converts "we protected your data" into "we broke
+ * your write", and the writer cannot tell which happened to them.** Naming
+ * the path collapses that ambiguity — it turns the refusal from a VERDICT
+ * into an INSTRUCTION. So the text MUST do three things, and the tests pin
+ * each: name the members that would have been dropped (so a writer can see
+ * whether they meant it), give the carry path for a writer who did not, and
+ * give the clear-then-set path for a writer who did — stating plainly that
+ * the app has no theme between those two writes, because that is the kind
+ * of fact a caller must not discover in production.
+ *
+ * The CLEAR half names an OUTCOME, not a mechanism, and that is deliberate
+ * (ggui#1124, from cloud's per-door measurement): `theme: null` clears on
+ * exactly ONE of the four doors that write a theme — the provisioning theme
+ * door. On the other three a writer following a universal `theme: null`
+ * instruction gets a SECOND refusal, which is the verdict-without-a-path
+ * this ruling exists to prevent, reintroduced by the text meant to prevent
+ * it. The CARRY half needs no such hedge: it is implementable on every
+ * door, which is why it is stated first and unconditionally.
+ *
+ * The better end state is uniform — `theme: null` clearing at the shared
+ * writer so all four doors honour one mechanism — but that is a change to
+ * three doors' semantics and belongs to its own decision with cloud, not to
+ * a wording fix.
+ *
+ * Throws on an empty list: a refusal that names nothing is not an
+ * instruction.
+ */
+export declare function appThemeWouldDropRefusalText(wouldDrop: readonly string[]): string;
 export declare const appThemeRefusalBodySchema: z.ZodUnion<readonly [z.ZodObject<{
     uncovered: z.ZodObject<{
         light: z.ZodArray<z.ZodString>;
@@ -79,6 +351,8 @@ export declare const appThemeRefusalBodySchema: z.ZodUnion<readonly [z.ZodObject
     overlayHash: z.ZodLiteral<"mismatch">;
 }, z.core.$strict>, z.ZodObject<{
     refused: z.ZodLiteral<"v1 shape">;
+}, z.core.$strict>, z.ZodObject<{
+    wouldDrop: z.ZodArray<z.ZodString>;
 }, z.core.$strict>]>;
 export type AppThemeRefusalBody = z.infer<typeof appThemeRefusalBodySchema>;
 //# sourceMappingURL=app-theme.d.ts.map

package/dist/schemas/app-theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-theme.d.ts","sourceRoot":"","sources":["../../src/schemas/app-theme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,QAA2B,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,QAAiB,CAAC;AAahD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,QAA+B,CAAC;AAE9D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoCrD;AAQD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;kBAuChB,CAAC;AAEZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;oBAKpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"app-theme.d.ts","sourceRoot":"","sources":["../../src/schemas/app-theme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,QAA2B,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,QAAiB,CAAC;AAahD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,QAA+B,CAAC;AAE9D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoCrD;AAwBD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB;;;;;;kBAMpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,mGAAmG;AACnG,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,uGAAuG;AACvG,eAAO,MAAM,uBAAuB,sCAAuC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;kBAInC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;kBAIhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoDhB,CAAC;AAEZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiC,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAW9E;AAED;;;;;GAKG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,GAChB,SAAS,MAAM,EAAE,CAGnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAcjF;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;oBAapC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}