@cms0/cms0 0.2.7 → 0.2.9

package/dist/esm/libs/cli/descriptor-builder-alt.js

@@ -2,6 +2,7 @@
 import fs from "fs";
 import path from "path";
 import { Project, SyntaxKind, Node, } from "ts-morph";
+import { computeUnionBranchKeys, } from "@cms0/shared";
 import { findTsConfig } from "./config-loader.js";
 import { customTypeNames, customInlineDescriptors, customInlineTypeNames, customModelDescriptors, customModelTypeNames, resolveCustomTypeDependencies, } from "../../custom-types/registry.js";
 function resolveCustomTypeName(type) {
@@ -121,6 +122,39 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
     const { base, optional, nullable } = unwrapOptional(type);
     const isOptional = !!opts?.optional || optional;
     const isNullable = !!opts?.nullable || nullable;
+    if (base.isUnion()) {
+        const unionDescriptor = descriptorFromUnionType(base, modelNames, warnings, ctx);
+        if (unionDescriptor) {
+            return applyOptionalityToDescriptor(unionDescriptor, isOptional, isNullable);
+        }
+    }
+    if (base.isStringLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "string",
+            values: [String(base.getLiteralValue())],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isNumberLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "number",
+            values: [Number(base.getLiteralValue())],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isBooleanLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "boolean",
+            values: [base.getText() === "true"],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
     if (base.isString()) {
         return {
             kind: "primitive",
@@ -189,6 +223,203 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
         nullable: isNullable,
     };
 }
+function descriptorFromUnionType(unionType, modelNames, warnings, ctx) {
+    const unionTypes = unionType.getUnionTypes();
+    if (!unionTypes.length)
+        return undefined;
+    const hasBroadString = unionTypes.some((entry) => entry.isString());
+    const hasBroadNumber = unionTypes.some((entry) => entry.isNumber());
+    const hasBroadBoolean = unionTypes.some((entry) => entry.isBoolean());
+    const filtered = unionTypes.filter((entry) => {
+        if (entry.isStringLiteral() && hasBroadString)
+            return false;
+        if (entry.isNumberLiteral() && hasBroadNumber)
+            return false;
+        if (entry.isBooleanLiteral() && hasBroadBoolean)
+            return false;
+        return true;
+    });
+    if (!filtered.length) {
+        if (hasBroadString) {
+            return { kind: "primitive", type: "string" };
+        }
+        if (hasBroadNumber) {
+            return { kind: "primitive", type: "number" };
+        }
+        if (hasBroadBoolean) {
+            return { kind: "primitive", type: "boolean" };
+        }
+        return undefined;
+    }
+    const literalEnum = resolveLiteralUnionAsEnum(filtered);
+    if (literalEnum) {
+        return literalEnum;
+    }
+    const branches = filtered
+        .map((entry, index) => descriptorFromType(entry, modelNames, warnings, `${ctx}|${index}`, {
+        optional: false,
+        nullable: false,
+    }))
+        .map((entry) => stripOptionality(entry));
+    const deduped = dedupeDescriptors(branches);
+    if (!deduped.length)
+        return undefined;
+    if (deduped.length === 1)
+        return deduped[0];
+    const discriminator = inferUnionDiscriminator(deduped);
+    const branchKeys = computeUnionBranchKeys(deduped);
+    return {
+        kind: "union",
+        anyOf: deduped,
+        branchKeys,
+        ...(discriminator ? { discriminator: { key: discriminator } } : {}),
+    };
+}
+function stripOptionality(descriptor) {
+    const clone = JSON.parse(JSON.stringify(descriptor));
+    delete clone.optional;
+    delete clone.nullable;
+    return clone;
+}
+function dedupeDescriptors(descriptors) {
+    const seen = new Set();
+    const deduped = [];
+    for (const descriptor of descriptors) {
+        const key = JSON.stringify(descriptor);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(descriptor);
+    }
+    return deduped;
+}
+function resolveLiteralUnionAsEnum(types) {
+    if (!types.length)
+        return undefined;
+    const literals = [];
+    let kind;
+    for (const entry of types) {
+        if (entry.isStringLiteral()) {
+            if (kind && kind !== "string")
+                return undefined;
+            kind = "string";
+            literals.push(String(entry.getLiteralValue()));
+            continue;
+        }
+        if (entry.isNumberLiteral()) {
+            if (kind && kind !== "number")
+                return undefined;
+            kind = "number";
+            literals.push(Number(entry.getLiteralValue()));
+            continue;
+        }
+        if (entry.isBooleanLiteral()) {
+            if (kind && kind !== "boolean")
+                return undefined;
+            kind = "boolean";
+            literals.push(entry.getText() === "true");
+            continue;
+        }
+        return undefined;
+    }
+    if (!kind)
+        return undefined;
+    const unique = Array.from(new Set(literals));
+    return {
+        kind: "enum",
+        valueType: kind,
+        values: unique,
+    };
+}
+function inferUnionDiscriminator(descriptors) {
+    if (!descriptors.length ||
+        descriptors.some((entry) => entry?.type !== "object")) {
+        return undefined;
+    }
+    const objects = descriptors;
+    const sharedKeys = Object.keys(objects[0]?.properties ?? {}).filter((key) => objects.every((obj) => Object.prototype.hasOwnProperty.call(obj.properties ?? {}, key)));
+    for (const key of sharedKeys) {
+        const enumLikeValues = objects.map((obj) => {
+            const prop = (obj.properties ?? {})[key];
+            if (!prop)
+                return undefined;
+            if (prop.kind !== "enum" || !Array.isArray(prop.values) || prop.values.length !== 1) {
+                return undefined;
+            }
+            return prop.values[0];
+        });
+        if (enumLikeValues.some((value) => value === undefined)) {
+            continue;
+        }
+        const unique = new Set(enumLikeValues);
+        if (unique.size === enumLikeValues.length) {
+            return key;
+        }
+    }
+    return undefined;
+}
+function normalizePropertyOrder(keys, explicitOrder) {
+    const normalizedExplicit = Array.isArray(explicitOrder)
+        ? explicitOrder
+            .filter((value) => typeof value === "string")
+            .map((value) => value.trim())
+            .filter(Boolean)
+        : [];
+    const dedupedExplicit = Array.from(new Set(normalizedExplicit)).filter((key) => keys.includes(key));
+    const remaining = keys.filter((key) => !dedupedExplicit.includes(key));
+    return [...dedupedExplicit, ...remaining];
+}
+function applyFieldPropertyOrder(descriptor) {
+    if (!descriptor || typeof descriptor !== "object")
+        return descriptor;
+    if (descriptor.type === "object") {
+        const properties = (descriptor.properties ?? {});
+        const keys = Object.keys(properties);
+        for (const key of keys) {
+            properties[key] = applyFieldPropertyOrder(properties[key]);
+        }
+        descriptor.propertyOrder = normalizePropertyOrder(keys, descriptor.propertyOrder);
+        return descriptor;
+    }
+    if (descriptor.type === "array" && descriptor.items) {
+        descriptor.items = applyFieldPropertyOrder(descriptor.items);
+        return descriptor;
+    }
+    if (descriptor.kind === "union" && Array.isArray(descriptor.anyOf)) {
+        descriptor.anyOf = descriptor.anyOf.map((branch) => applyFieldPropertyOrder(branch));
+        return descriptor;
+    }
+    return descriptor;
+}
+function applyDescriptorOrderingMetadata(descriptor) {
+    const rootsOrder = Object.keys(descriptor.roots ?? {});
+    const modelsOrder = Object.keys(descriptor.models ?? {});
+    for (const modelName of modelsOrder) {
+        const model = descriptor.models?.[modelName];
+        if (!model || typeof model !== "object")
+            continue;
+        const keys = Object.keys(model.properties ?? {});
+        for (const key of keys) {
+            model.properties[key] = applyFieldPropertyOrder(model.properties[key]);
+        }
+        model.propertyOrder = normalizePropertyOrder(keys, model.propertyOrder);
+    }
+    for (const rootName of rootsOrder) {
+        const rootDescriptor = descriptor.roots?.[rootName];
+        if (!rootDescriptor)
+            continue;
+        descriptor.roots[rootName] = applyFieldPropertyOrder(rootDescriptor);
+    }
+    descriptor.metadata = {
+        ...(descriptor.metadata ?? {}),
+        ordering: {
+            ...(descriptor.metadata?.ordering ?? {}),
+            roots: rootsOrder,
+            models: modelsOrder,
+        },
+    };
+    return descriptor;
+}
 function collectModels(sourceFiles, modelNames, modelMap, warnings) {
     const handleShape = (name, type, ctx) => {
         if (modelMap[name])
@@ -290,15 +521,15 @@ function buildDescriptorAlt(resolved) {
     const referencedModelNames = new Set();
     collectReferencedModelNames(rootType, referencedModelNames, new Set(), "root");
     const referencedCustomTypeNames = new Set(Array.from(referencedModelNames).filter((n) => customTypeNames.has(n)));
-    const referencedCustomModelNames = new Set(Array.from(referencedCustomTypeNames).filter((n) => customModelTypeNames.has(n)));
-    const resolvedCustomTypeNames = resolveCustomTypeDependencies(referencedCustomModelNames);
+    const resolvedCustomTypeNames = resolveCustomTypeDependencies(referencedCustomTypeNames);
+    const resolvedCustomModelNames = new Set(Array.from(resolvedCustomTypeNames).filter((n) => customModelTypeNames.has(n)));
     const modelNames = new Set([
         ...Array.from(referencedModelNames).filter((n) => exportedModelNames.has(n)),
-        ...Array.from(resolvedCustomTypeNames),
+        ...Array.from(resolvedCustomModelNames),
     ]);
     const modelMap = {};
     collectModels(sourceFiles, modelNames, modelMap, warnings);
-    resolvedCustomTypeNames.forEach((name) => {
+    resolvedCustomModelNames.forEach((name) => {
         if (modelMap[name]) {
             return;
         }
@@ -335,7 +566,7 @@ function buildDescriptorAlt(resolved) {
         warnings.forEach((w) => console.warn(w));
     const locales = invocation.locales;
     const defaultLocale = invocation.defaultLocale;
-    return {
+    const descriptor = {
         models: modelMap,
         roots,
         metadata: locales || defaultLocale
@@ -345,5 +576,6 @@ function buildDescriptorAlt(resolved) {
             }
             : undefined,
     };
+    return applyDescriptorOrderingMetadata(descriptor);
 }
 export { buildDescriptorAlt };

package/dist/esm/seo.js

@@ -0,0 +1,220 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function uniqueNonEmpty(values) {
+    const result = [];
+    for (const value of values) {
+        const trimmed = normalizeText(value);
+        if (!trimmed || result.includes(trimmed))
+            continue;
+        result.push(trimmed);
+    }
+    return result;
+}
+function isLocalizedLike(value) {
+    if (!isRecord(value))
+        return false;
+    return "locales" in value && isRecord(value.locales);
+}
+function localizedValueForLocale(locales, locale) {
+    const entry = locales[locale];
+    return normalizeText(entry);
+}
+export function resolveLocalized(value, options = {}) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string") {
+        return normalizeText(value);
+    }
+    if (!isLocalizedLike(value)) {
+        return undefined;
+    }
+    const locales = value.locales;
+    const localeKeys = Object.keys(locales);
+    const preferredLocales = uniqueNonEmpty([
+        options.locale,
+        typeof value.defaultLocale === "string" ? value.defaultLocale : undefined,
+        options.defaultLocale,
+        options.fallbackLocale,
+        ...localeKeys,
+    ]);
+    for (const locale of preferredLocales) {
+        const resolved = localizedValueForLocale(locales, locale);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveKeywords(value, options) {
+    if (Array.isArray(value)) {
+        const list = value.map((entry) => normalizeText(entry)).filter(Boolean);
+        return list.length ? list : undefined;
+    }
+    const localized = resolveLocalized(value, options);
+    if (!localized)
+        return undefined;
+    const parts = localized
+        .split(/[;,]/g)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    if (parts.length > 0) {
+        return parts;
+    }
+    return [localized];
+}
+function resolveImageUrl(image) {
+    if (typeof image === "string") {
+        return normalizeText(image);
+    }
+    if (!isRecord(image))
+        return undefined;
+    return normalizeText(image.url);
+}
+function normalizeRobots(robots) {
+    if (typeof robots === "boolean") {
+        return { index: robots, follow: robots };
+    }
+    if (!isRecord(robots))
+        return undefined;
+    const resolved = {};
+    if (typeof robots.index === "boolean")
+        resolved.index = robots.index;
+    if (typeof robots.follow === "boolean")
+        resolved.follow = robots.follow;
+    if (typeof robots.nocache === "boolean")
+        resolved.nocache = robots.nocache;
+    return Object.keys(resolved).length ? resolved : undefined;
+}
+function hasAnyKeys(value) {
+    return Object.keys(value).length > 0;
+}
+export function toOpenGraph(value, options = {}) {
+    if (!isRecord(value))
+        return undefined;
+    const openGraph = {};
+    const type = normalizeText(value.type);
+    if (type)
+        openGraph.type = type;
+    const url = normalizeText(value.url);
+    if (url)
+        openGraph.url = url;
+    const siteName = normalizeText(value.siteName);
+    if (siteName)
+        openGraph.siteName = siteName;
+    const title = resolveLocalized(value.title, options);
+    if (title)
+        openGraph.title = title;
+    const description = resolveLocalized(value.description, options);
+    if (description)
+        openGraph.description = description;
+    if (Array.isArray(value.images)) {
+        const images = value.images
+            .map((image) => resolveImageUrl(image))
+            .filter((entry) => typeof entry === "string" && entry.length > 0);
+        if (images.length) {
+            openGraph.images = images;
+        }
+    }
+    const locale = normalizeText(value.locale);
+    if (locale)
+        openGraph.locale = locale;
+    if (Array.isArray(value.alternateLocale)) {
+        const alternateLocale = value.alternateLocale
+            .map((entry) => normalizeText(entry))
+            .filter((entry) => Boolean(entry));
+        if (alternateLocale.length) {
+            openGraph.alternateLocale = alternateLocale;
+        }
+    }
+    return hasAnyKeys(openGraph) ? openGraph : undefined;
+}
+export function toTwitter(value, options = {}) {
+    if (!isRecord(value))
+        return undefined;
+    const twitter = {};
+    const card = normalizeText(value.card);
+    if (card)
+        twitter.card = card;
+    const site = normalizeText(value.site);
+    if (site)
+        twitter.site = site;
+    const creator = normalizeText(value.creator);
+    if (creator)
+        twitter.creator = creator;
+    const title = resolveLocalized(value.title, options);
+    if (title)
+        twitter.title = title;
+    const description = resolveLocalized(value.description, options);
+    if (description)
+        twitter.description = description;
+    if (Array.isArray(value.images)) {
+        const images = value.images
+            .map((image) => resolveImageUrl(image))
+            .filter((entry) => typeof entry === "string" && entry.length > 0);
+        if (images.length) {
+            twitter.images = images;
+        }
+    }
+    return hasAnyKeys(twitter) ? twitter : undefined;
+}
+function resolveAlternates(seo) {
+    const alternates = {};
+    const canonical = normalizeText(seo.alternates?.canonical) ?? normalizeText(seo.canonical);
+    if (canonical) {
+        alternates.canonical = canonical;
+    }
+    if (isRecord(seo.alternates?.languages)) {
+        const languages = {};
+        for (const [locale, rawValue] of Object.entries(seo.alternates.languages)) {
+            const normalizedLocale = normalizeText(locale);
+            const normalizedUrl = normalizeText(rawValue);
+            if (!normalizedLocale || !normalizedUrl)
+                continue;
+            languages[normalizedLocale] = normalizedUrl;
+        }
+        if (Object.keys(languages).length) {
+            alternates.languages = languages;
+        }
+    }
+    return hasAnyKeys(alternates) ? alternates : undefined;
+}
+/**
+ * Maps a CMS0 `Seo` object to a Next.js-compatible metadata shape.
+ *
+ * The return type is generic so consumers can pass Next's `Metadata` type:
+ * `toNextMetadata<Metadata>(seo, { locale })`.
+ */
+export function toNextMetadata(seo, options = {}) {
+    if (!isRecord(seo)) {
+        return {};
+    }
+    const metadata = {};
+    const title = resolveLocalized(seo.title, options);
+    if (title)
+        metadata.title = title;
+    const description = resolveLocalized(seo.description, options);
+    if (description)
+        metadata.description = description;
+    const keywords = resolveKeywords(seo.keywords, options);
+    if (keywords?.length)
+        metadata.keywords = keywords;
+    const robots = normalizeRobots(seo.robots);
+    if (robots)
+        metadata.robots = robots;
+    const alternates = resolveAlternates(seo);
+    if (alternates)
+        metadata.alternates = alternates;
+    const openGraph = toOpenGraph(seo.openGraph, options);
+    if (openGraph)
+        metadata.openGraph = openGraph;
+    const twitter = toTwitter(seo.twitter, options);
+    if (twitter)
+        metadata.twitter = twitter;
+    return metadata;
+}

package/dist/types/custom-types/index.d.ts

@@ -28,4 +28,42 @@ export type Localized<T> = {
 };
 export type LocalizedString = Localized<string>;
 export type LocalizedRichText = Localized<RichText>;
+export type SeoRobots = boolean | {
+    index?: boolean;
+    follow?: boolean;
+    nocache?: boolean;
+};
+export type SeoAlternates = {
+    canonical?: string;
+    languages?: Record<string, string>;
+};
+export type SeoOpenGraph = {
+    type?: "website" | "article" | "profile";
+    url?: string;
+    siteName?: string;
+    title?: LocalizedString | string;
+    description?: LocalizedString | string;
+    images?: Array<Image | string>;
+    locale?: string;
+    alternateLocale?: string[];
+};
+export type SeoTwitter = {
+    card?: "summary" | "summary_large_image" | "app" | "player";
+    site?: string;
+    creator?: string;
+    title?: LocalizedString | string;
+    description?: LocalizedString | string;
+    images?: Array<Image | string>;
+};
+export type Seo = {
+    title?: LocalizedString | string;
+    description?: LocalizedString | string;
+    keywords?: LocalizedString | string[];
+    canonical?: string;
+    robots?: SeoRobots;
+    alternates?: SeoAlternates;
+    openGraph?: SeoOpenGraph;
+    twitter?: SeoTwitter;
+    jsonLd?: Record<string, unknown>[];
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/types/custom-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/custom-types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC;AAE5B,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/custom-types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/custom-types/registry.d.ts

@@ -1,4 +1,4 @@
-import type { ModelDescriptor, PrimitiveType } from "@cms0/shared";
+import { type FieldDescriptor, type ModelDescriptor, type PrimitiveType } from "@cms0/shared";
 export declare const customModelDescriptors: {
     readonly File: ModelDescriptor;
     readonly Image: ModelDescriptor;
@@ -26,6 +26,15 @@ export declare const customInlineDescriptors: {
         nullable?: boolean;
         customType?: string;
     };
+    readonly Seo: {
+        kind?: "object";
+        type: "object";
+        properties: Record<string, FieldDescriptor>;
+        propertyOrder?: string[];
+        optional?: boolean;
+        nullable?: boolean;
+        customType?: string;
+    };
 };
 export type CustomInlineTypeName = keyof typeof customInlineDescriptors;
 export type CustomInlineTypeMetadata = {
@@ -56,6 +65,15 @@ export declare const customTypeDescriptors: {
         nullable?: boolean;
         customType?: string;
     };
+    readonly Seo: {
+        kind?: "object";
+        type: "object";
+        properties: Record<string, FieldDescriptor>;
+        propertyOrder?: string[];
+        optional?: boolean;
+        nullable?: boolean;
+        customType?: string;
+    };
     readonly File: ModelDescriptor;
     readonly Image: ModelDescriptor;
     readonly Video: ModelDescriptor;

package/dist/types/custom-types/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/custom-types/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AA6DpF,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;CAI1B,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,uBAAuB,CAAC;AAExE,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,CAAC,EAAE;QAEV,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACnC,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,oBAAoB,EACpB,wBAAwB,CASzB,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAGxB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,qBAAqB,CAAC;AAEhE,eAAO,MAAM,eAAe,aAAsD,CAAC;AACnF,eAAO,MAAM,oBAAoB,aAEhC,CAAC;AACF,eAAO,MAAM,qBAAqB,aAEjC,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,GACX,wBAAwB,GAAG,SAAS,CAEtC;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAwBlF"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/custom-types/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AA6StB,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,uBAAuB,CAAC;AAExE,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,CAAC,EAAE;QAEV,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACnC,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,oBAAoB,EACpB,wBAAwB,CAUzB,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,qBAAqB,CAAC;AAEhE,eAAO,MAAM,eAAe,aAAsD,CAAC;AACnF,eAAO,MAAM,oBAAoB,aAEhC,CAAC;AACF,eAAO,MAAM,qBAAqB,aAEjC,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,GACX,wBAAwB,GAAG,SAAS,CAEtC;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAgClF"}