@nitrogenbuilder/connector-payload 0.1.34 → 0.1.36

package/dist/components/NitrogenNavGroup.js

@@ -0,0 +1,74 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePathname } from 'next/navigation';
+import { useEffect, useMemo, useState } from 'react';
+const items = [
+    {
+        href: '/admin/collections/nitrogen-templates',
+        label: 'Templates',
+    },
+    {
+        href: '/admin/globals/nitrogen-settings',
+        label: 'Settings',
+    },
+    {
+        href: '/admin/nitrogen/components',
+        label: 'Components',
+    },
+];
+export default function NitrogenNavGroup() {
+    const pathname = usePathname();
+    const hasActiveChild = useMemo(() => items.some((item) => pathname === item.href || pathname?.startsWith(`${item.href}/`)), [pathname]);
+    const [collapsed, setCollapsed] = useState(!hasActiveChild);
+    useEffect(() => {
+        if (hasActiveChild) {
+            setCollapsed(false);
+        }
+    }, [hasActiveChild]);
+    useEffect(() => {
+        const styleId = 'nitrogen-custom-nav-group-style';
+        if (document.getElementById(styleId)) {
+            return;
+        }
+        const style = document.createElement('style');
+        style.id = styleId;
+        style.textContent = `
+      #nav-group-Nitrogen {
+        display: none;
+      }
+    `;
+        document.head.appendChild(style);
+        return () => {
+            style.remove();
+        };
+    }, []);
+    return (_jsxs("div", { style: { marginTop: 12 }, children: [_jsxs("button", { type: "button", onClick: () => setCollapsed((current) => !current), style: {
+                    alignItems: 'center',
+                    background: 'transparent',
+                    border: 'none',
+                    color: 'inherit',
+                    cursor: 'pointer',
+                    display: 'flex',
+                    font: 'inherit',
+                    justifyContent: 'space-between',
+                    padding: '6px 0',
+                    width: '100%',
+                }, children: [_jsx("span", { style: { fontSize: 13, fontWeight: 700, letterSpacing: '0.01em' }, children: "Nitrogen" }), _jsx("span", { "aria-hidden": "true", style: {
+                            display: 'inline-block',
+                            fontSize: 12,
+                            opacity: 0.65,
+                            transform: collapsed ? 'rotate(-90deg)' : 'rotate(0deg)',
+                            transition: 'transform 160ms ease',
+                        }, children: "\u25BE" })] }), !collapsed && (_jsx("div", { style: { display: 'grid', gap: 2, paddingBottom: 4, paddingLeft: 12 }, children: items.map((item) => {
+                    const isActive = pathname === item.href || pathname?.startsWith(`${item.href}/`);
+                    return (_jsx("a", { "aria-current": isActive ? 'page' : undefined, href: item.href, style: {
+                            borderLeft: isActive ? '2px solid currentColor' : '2px solid transparent',
+                            display: 'block',
+                            fontSize: 13,
+                            fontWeight: isActive ? 700 : 500,
+                            opacity: isActive ? 1 : 0.82,
+                            padding: '6px 0 6px 10px',
+                            textDecoration: 'none',
+                        }, children: item.label }, item.href));
+                }) }))] }));
+}

package/dist/editor/NitrogenEditorPage.d.ts

@@ -1,4 +1,3 @@
-import type { SanitizedConfig } from "payload";
 interface NitrogenEditorSearchParams {
     pageId?: string;
     collection?: string;
@@ -16,7 +15,7 @@ interface NitrogenEditorSearchParams {
  *
  * Accessible at `/nitrogen-editor?pageId=xxx`.
  */
-export declare function createNitrogenEditorPage(config: Promise<SanitizedConfig>): ({ searchParams, }: {
+export declare function createNitrogenEditorPage(config: Promise<any>): ({ searchParams, }: {
     searchParams: Promise<NitrogenEditorSearchParams>;
 }) => Promise<import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/endpoints/component-inventory.d.ts

@@ -0,0 +1,6 @@
+import type { Endpoint } from 'payload';
+import type { NitrogenComponentManifestInput } from '../inventory/manifest';
+export declare function createComponentInventoryEndpoints(args: {
+    collections: string[];
+    componentManifest?: NitrogenComponentManifestInput;
+}): Endpoint[];

package/dist/endpoints/component-inventory.js

@@ -0,0 +1,20 @@
+import { requireAuth } from './helpers';
+import { reindexAllComponentInventory } from '../inventory/indexing';
+export function createComponentInventoryEndpoints(args) {
+    return [
+        {
+            path: '/nitrogen/v1/component-inventory/reindex',
+            method: 'post',
+            handler: async (req) => {
+                const authError = requireAuth(req);
+                if (authError)
+                    return authError;
+                const result = await reindexAllComponentInventory(req.payload, args.collections, args.componentManifest);
+                return Response.json({
+                    success: true,
+                    ...result,
+                });
+            },
+        },
+    ];
+}

package/dist/frontend/NitrogenWrapper.d.ts

@@ -1,5 +1,4 @@
 import React from 'react';
-import type { SanitizedConfig } from 'payload';
 import type { BuilderModule } from '@nitrogenbuilder/types';
 export interface NitrogenWrapperProps {
     /**
@@ -21,7 +20,7 @@ export interface NitrogenWrapperProps {
     /**
      * The Payload config promise. Import from '@payload-config' in your app and pass it here.
      */
-    config: Promise<SanitizedConfig>;
+    config: Promise<any>;
     /**
      * Regular page content to render when not in Nitrogen mode.
      */

package/dist/globals/NitrogenComponents.d.ts

@@ -0,0 +1,2 @@
+import type { GlobalConfig } from 'payload';
+export declare const NitrogenComponents: GlobalConfig;

package/dist/globals/NitrogenComponents.js

@@ -0,0 +1,22 @@
+export const NitrogenComponents = {
+    slug: 'nitrogen-components',
+    label: 'Nitrogen Components',
+    admin: {
+        group: 'Nitrogen',
+    },
+    access: {
+        read: ({ req }) => !!req.user,
+        update: ({ req }) => !!req.user,
+    },
+    fields: [
+        {
+            name: 'inventory',
+            type: 'ui',
+            admin: {
+                components: {
+                    Field: '@nitrogenbuilder/connector-payload/components/NitrogenComponentInventoryField',
+                },
+            },
+        },
+    ],
+};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "payload";
+import type { NitrogenComponentManifestInput } from './inventory/manifest';
 export interface NitrogenConnectorPluginOptions {
     /** Disable the plugin without removing it from config */
     disabled?: boolean;
@@ -18,8 +18,18 @@ export interface NitrogenConnectorPluginOptions {
      * `collectionRoutes: { posts: '/blog/[slug]', patent: '/patents/[slug]' }`
      */
     collectionRoutes?: Record<string, string>;
+    /**
+     * A static manifest or async loader describing the project's registered
+     * Nitrogen components and their prop schemas.
+     */
+    componentManifest?: NitrogenComponentManifestInput;
+    /**
+     * Collections whose saved `nitrogenData` should be indexed for the component
+     * inventory. These do not need to be editor-enabled.
+     */
+    indexCollections?: string[];
 }
-export declare const nitrogenConnectorPlugin: (options?: NitrogenConnectorPluginOptions) => Plugin;
+export declare const nitrogenConnectorPlugin: (options?: NitrogenConnectorPluginOptions) => any;
 export { NitrogenTemplates } from "./collections/NitrogenTemplates";
 export { NitrogenSettings } from "./globals/NitrogenSettings";
 export { NitrogenEditButton } from "./components/NitrogenEditButton";

package/dist/index.js

@@ -1,5 +1,8 @@
 import { NitrogenTemplates } from "./collections/NitrogenTemplates";
+import { NitrogenComponentCatalog } from './collections/NitrogenComponentCatalog';
+import { NitrogenComponentUsage } from './collections/NitrogenComponentUsage';
 import { NitrogenSettings } from "./globals/NitrogenSettings";
+import { NitrogenComponents } from './globals/NitrogenComponents';
 import { templatesEndpoints } from "./endpoints/templates";
 import { mediaEndpoints } from "./endpoints/media";
 import { nitrogenSettingsEndpoints } from "./endpoints/nitrogen-settings";
@@ -7,8 +10,10 @@ import { allEndpoints } from "./endpoints/all";
 import { collectionsEndpoints } from "./endpoints/collections";
 import { menuEndpoints } from "./endpoints/menu";
 import { createCollectionEndpoints } from "./endpoints/collection-endpoints";
+import { createComponentInventoryEndpoints } from './endpoints/component-inventory';
 import { batchEndpoints } from "./endpoints/batch";
 import { registerCollection } from "./collection-registry";
+import { deleteDocumentUsage, reindexDocumentUsage, syncComponentCatalog, } from './inventory/indexing';
 /** Fields required by Nitrogen that will be injected into collections if missing */
 const nitrogenRequiredFields = [
     {
@@ -37,10 +42,48 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         return incomingConfig;
     }
     const config = { ...incomingConfig };
+    const inventoryCollections = Array.from(new Set([
+        ...(options.collections || []),
+        ...(options.indexCollections || []),
+        'nitrogen-templates',
+    ]));
+    const createAfterChangeHook = (collectionSlug) => {
+        return async ({ doc, req }) => {
+            if (doc) {
+                await reindexDocumentUsage(req.payload, collectionSlug, doc, collectionSlug === 'nitrogen-templates' ? 'template' : 'document');
+            }
+            return doc;
+        };
+    };
+    const createAfterDeleteHook = (collectionSlug) => {
+        return async ({ doc, id, req, }) => {
+            const sourceId = doc?.id ?? id;
+            if (sourceId !== undefined) {
+                await deleteDocumentUsage(req.payload, collectionSlug, sourceId);
+            }
+            return doc;
+        };
+    };
+    const withInventoryHooks = (collection, collectionSlug) => {
+        const hooks = collection.hooks || {};
+        return {
+            ...collection,
+            hooks: {
+                ...hooks,
+                afterChange: [...(hooks.afterChange || []), createAfterChangeHook(collectionSlug)],
+                afterDelete: [...(hooks.afterDelete || []), createAfterDeleteHook(collectionSlug)],
+            },
+        };
+    };
     // Add Nitrogen templates collection
-    config.collections = [...(config.collections || []), NitrogenTemplates];
-    // Add Nitrogen global settings
-    config.globals = [...(config.globals || []), NitrogenSettings];
+    config.collections = [
+        ...(config.collections || []),
+        withInventoryHooks(NitrogenTemplates, 'nitrogen-templates'),
+        NitrogenComponentCatalog,
+        NitrogenComponentUsage,
+    ];
+    // Add Nitrogen globals
+    config.globals = [...(config.globals || []), NitrogenSettings, NitrogenComponents];
     // Add Nitrogen API endpoints
     config.endpoints = [
         ...(config.endpoints || []),
@@ -51,7 +94,45 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         ...collectionsEndpoints,
         ...menuEndpoints,
         ...batchEndpoints,
+        ...createComponentInventoryEndpoints({
+            collections: inventoryCollections,
+            componentManifest: options.componentManifest,
+        }),
     ];
+    const existingOnInit = config.onInit;
+    config.onInit = async (payload) => {
+        if (existingOnInit) {
+            await existingOnInit(payload);
+        }
+        try {
+            await syncComponentCatalog(payload, options.componentManifest);
+        }
+        catch (error) {
+            payload.logger.error(`[@nitrogenbuilder/connector-payload] Failed to sync component catalog: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        for (const slug of ['nitrogen-components']) {
+            try {
+                await payload.findGlobal({
+                    slug,
+                    depth: 0,
+                    overrideAccess: true,
+                });
+            }
+            catch {
+                try {
+                    await payload.updateGlobal({
+                        slug,
+                        data: {},
+                        depth: 0,
+                        overrideAccess: true,
+                    });
+                }
+                catch (error) {
+                    payload.logger.warn(`[@nitrogenbuilder/connector-payload] Could not initialize global "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    };
     // Register templates collection
     registerCollection("nitrogen-templates", "nitrogen-templates", "/nitrogen-templates/[slug]");
     registerCollection("nitrogen_template", "nitrogen-templates", "/nitrogen-templates/[slug]");
@@ -133,6 +214,16 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         // Register in the collection registry for the `all` endpoint
         registerCollection(slug, slug, routePattern);
     }
+    for (const slug of inventoryCollections) {
+        if (slug === 'nitrogen-templates')
+            continue;
+        const existingIndex = (config.collections || []).findIndex((collection) => collection.slug === slug);
+        if (existingIndex === -1) {
+            console.warn(`[@nitrogenbuilder/connector-payload] Index collection "${slug}" not found in config.`);
+            continue;
+        }
+        config.collections[existingIndex] = withInventoryHooks(config.collections[existingIndex], slug);
+    }
     return config;
 };
 // Re-export for consumers who need direct access

package/dist/inventory/indexing.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentManifestEntry } from '@nitrogenbuilder/types';
+import type { Payload, Where } from 'payload';
+import type { NitrogenInventorySourceDoc } from '../types';
+import { type NitrogenComponentManifestInput } from './manifest';
+export declare const NITROGEN_COMPONENT_CATALOG_COLLECTION = "nitrogen-component-catalog";
+export declare const NITROGEN_COMPONENT_USAGE_COLLECTION = "nitrogen-component-usage";
+type ComponentUsageRecord = {
+    componentName: string;
+    depth: number;
+    moduleId: string;
+    modulePath: string;
+    parentComponentName?: string;
+    parentModuleId?: string;
+    parentModulePath?: string;
+};
+type ReindexResult = {
+    catalogCount: number;
+    documentCount: number;
+    usageCount: number;
+};
+export declare function extractComponentUsageRecords(modules: unknown): ComponentUsageRecord[];
+export declare function findAllDocs<T extends object>(payload: Payload, collection: string, options?: {
+    limit?: number;
+    select?: Record<string, true>;
+    where?: Where;
+}): Promise<T[]>;
+export declare function syncComponentCatalog(payload: Payload, manifestInput?: NitrogenComponentManifestInput): Promise<ComponentManifestEntry[]>;
+export declare function reindexDocumentUsage(payload: Payload, sourceCollection: string, doc: NitrogenInventorySourceDoc, sourceType?: 'document' | 'template'): Promise<number>;
+export declare function deleteDocumentUsage(payload: Payload, sourceCollection: string, sourceDocumentId: string | number): Promise<void>;
+export declare function reindexAllComponentInventory(payload: Payload, collections: string[], manifestInput?: NitrogenComponentManifestInput): Promise<ReindexResult>;
+export {};

package/dist/inventory/indexing.js

@@ -0,0 +1,230 @@
+import { resolveComponentManifest, } from './manifest';
+export const NITROGEN_COMPONENT_CATALOG_COLLECTION = 'nitrogen-component-catalog';
+export const NITROGEN_COMPONENT_USAGE_COLLECTION = 'nitrogen-component-usage';
+function moduleNameFromNode(node) {
+    const value = node.module;
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object' && typeof value.name === 'string') {
+        return String(value.name);
+    }
+    return null;
+}
+function collectUsageFromTree(modules, pathPrefix, results, parentContext, depth = 0) {
+    if (!Array.isArray(modules))
+        return;
+    modules.forEach((maybeNode, index) => {
+        if (!maybeNode || typeof maybeNode !== 'object')
+            return;
+        const node = maybeNode;
+        const modulePath = `${pathPrefix}[${index}]`;
+        const componentName = moduleNameFromNode(node);
+        const moduleId = typeof node.id === 'string' || typeof node.id === 'number'
+            ? String(node.id)
+            : modulePath;
+        const currentContext = componentName
+            ? {
+                componentName,
+                moduleId,
+                modulePath,
+            }
+            : parentContext;
+        if (componentName) {
+            results.push({
+                componentName,
+                depth,
+                moduleId,
+                modulePath,
+                parentComponentName: parentContext?.componentName,
+                parentModuleId: parentContext?.moduleId,
+                parentModulePath: parentContext?.modulePath,
+            });
+        }
+        const props = node.props;
+        if (props && typeof props === 'object') {
+            const children = props.children;
+            if (Array.isArray(children)) {
+                collectUsageFromTree(children, `${modulePath}.props.children`, results, currentContext, depth + 1);
+            }
+            else if (children && typeof children === 'object') {
+                for (const [slotName, slotChildren] of Object.entries(children)) {
+                    collectUsageFromTree(slotChildren, `${modulePath}.props.children.${slotName}`, results, currentContext, depth + 1);
+                }
+            }
+        }
+        if (Array.isArray(node.children)) {
+            collectUsageFromTree(node.children, `${modulePath}.children`, results, currentContext, depth + 1);
+        }
+    });
+}
+export function extractComponentUsageRecords(modules) {
+    const results = [];
+    collectUsageFromTree(modules, 'modules', results);
+    return results;
+}
+export async function findAllDocs(payload, collection, options) {
+    const docs = [];
+    let page = 1;
+    let hasNextPage = true;
+    while (hasNextPage) {
+        const result = await payload.find({
+            collection: collection,
+            depth: 0,
+            limit: options?.limit ?? 200,
+            page,
+            overrideAccess: true,
+            pagination: true,
+            select: options?.select,
+            where: options?.where,
+        });
+        docs.push(...result.docs);
+        hasNextPage = Boolean(result.hasNextPage);
+        page += 1;
+    }
+    return docs;
+}
+async function deleteUsageDocs(payload, docs) {
+    for (const doc of docs) {
+        await payload.delete({
+            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+            id: doc.id,
+            overrideAccess: true,
+        });
+    }
+}
+async function findUsageDocsForSource(payload, sourceCollection, sourceDocumentId) {
+    return findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
+        limit: 100,
+        select: {
+            id: true,
+        },
+        where: {
+            and: [
+                {
+                    sourceCollection: {
+                        equals: sourceCollection,
+                    },
+                },
+                {
+                    sourceDocumentId: {
+                        equals: sourceDocumentId,
+                    },
+                },
+            ],
+        },
+    });
+}
+async function createUsageDocs(payload, sourceCollection, sourceType, doc) {
+    const sourceDocumentId = String(doc.id);
+    const usageRecords = extractComponentUsageRecords(doc.nitrogenData);
+    for (const record of usageRecords) {
+        await payload.create({
+            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+            overrideAccess: true,
+            data: {
+                usageKey: `${sourceCollection}:${sourceDocumentId}:${record.moduleId}:${record.modulePath}:${record.componentName}`,
+                componentName: record.componentName,
+                depth: record.depth,
+                sourceCollection,
+                sourceType,
+                sourceDocumentId,
+                sourceTitle: doc.title || '',
+                sourceSlug: doc.slug || '',
+                sourceStatus: doc.status || doc._status || '',
+                moduleId: record.moduleId,
+                modulePath: record.modulePath,
+                parentComponentName: record.parentComponentName || '',
+                parentModuleId: record.parentModuleId || '',
+                parentModulePath: record.parentModulePath || '',
+            },
+        });
+    }
+    return usageRecords.length;
+}
+export async function syncComponentCatalog(payload, manifestInput) {
+    const manifest = await resolveComponentManifest(manifestInput);
+    const entries = manifest.components || [];
+    const existingDocs = await findAllDocs(payload, NITROGEN_COMPONENT_CATALOG_COLLECTION);
+    const existingByName = new Map(existingDocs.map((doc) => [doc.componentName, doc]));
+    const nextNames = new Set(entries.map((entry) => entry.name));
+    for (const entry of entries) {
+        const existing = existingByName.get(entry.name);
+        const data = {
+            componentName: entry.name,
+            scope: entry.scope || '',
+            sidebarCategory: entry.sidebarCategory || '',
+            icon: entry.icon || '',
+            definition: entry,
+            source: manifest.source || '',
+        };
+        if (existing) {
+            await payload.update({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                id: existing.id,
+                data,
+                overrideAccess: true,
+            });
+        }
+        else {
+            await payload.create({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                data,
+                overrideAccess: true,
+            });
+        }
+    }
+    for (const existing of existingDocs) {
+        if (!nextNames.has(existing.componentName)) {
+            await payload.delete({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                id: existing.id,
+                overrideAccess: true,
+            });
+        }
+    }
+    return entries;
+}
+export async function reindexDocumentUsage(payload, sourceCollection, doc, sourceType = 'document') {
+    const sourceDocumentId = String(doc.id);
+    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, sourceDocumentId);
+    await deleteUsageDocs(payload, docsForSource);
+    return createUsageDocs(payload, sourceCollection, sourceType, doc);
+}
+export async function deleteDocumentUsage(payload, sourceCollection, sourceDocumentId) {
+    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, String(sourceDocumentId));
+    await deleteUsageDocs(payload, docsForSource);
+}
+export async function reindexAllComponentInventory(payload, collections, manifestInput) {
+    const entries = await syncComponentCatalog(payload, manifestInput);
+    const usageDocs = await findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
+        limit: 200,
+        select: {
+            id: true,
+        },
+    });
+    await deleteUsageDocs(payload, usageDocs);
+    let documentCount = 0;
+    let usageCount = 0;
+    for (const collection of collections) {
+        const docs = await findAllDocs(payload, collection, {
+            limit: 100,
+            select: {
+                id: true,
+                title: true,
+                slug: true,
+                status: true,
+                _status: true,
+                nitrogenData: true,
+            },
+        });
+        for (const doc of docs) {
+            documentCount += 1;
+            usageCount += await createUsageDocs(payload, collection, collection === 'nitrogen-templates' ? 'template' : 'document', doc);
+        }
+    }
+    return {
+        catalogCount: entries.length,
+        documentCount,
+        usageCount,
+    };
+}

package/dist/inventory/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest, ComponentManifestEntry } from '@nitrogenbuilder/types';
+export type NitrogenComponentManifestInput = ComponentManifest | ComponentManifestEntry[] | (() => Promise<ComponentManifest | ComponentManifestEntry[]> | ComponentManifest | ComponentManifestEntry[]);
+export declare function resolveComponentManifest(input?: NitrogenComponentManifestInput): Promise<ComponentManifest>;

package/dist/inventory/manifest.js

@@ -0,0 +1,22 @@
+export async function resolveComponentManifest(input) {
+    if (!input) {
+        return {
+            components: [],
+            generatedAt: new Date().toISOString(),
+            source: 'empty',
+        };
+    }
+    const resolved = typeof input === 'function' ? await input() : input;
+    if (Array.isArray(resolved)) {
+        return {
+            components: resolved,
+            generatedAt: new Date().toISOString(),
+            source: 'array',
+        };
+    }
+    return {
+        components: resolved.components || [],
+        generatedAt: resolved.generatedAt || new Date().toISOString(),
+        source: resolved.source,
+    };
+}

package/dist/types.d.ts

@@ -4,7 +4,7 @@
  * Document interfaces matching the Payload collection/global schemas,
  * plus request body shapes used by the API endpoints.
  */
-import type { BuilderModule } from '@nitrogenbuilder/types';
+import type { BuilderModule, ComponentManifestEntry } from '@nitrogenbuilder/types';
 export type JsonObject = Record<string, unknown>;
 export type NitrogenModule = BuilderModule;
 interface NitrogenDocBase {
@@ -128,4 +128,38 @@ export interface RenderDataRequestBody {
     /** Which Payload collection to fetch dynamic data from */
     collection?: string;
 }
+export interface NitrogenComponentCatalogDoc {
+    id: string | number;
+    componentName: string;
+    scope?: string;
+    sidebarCategory?: string;
+    icon?: string;
+    definition?: ComponentManifestEntry | JsonObject;
+    source?: string;
+}
+export interface NitrogenComponentUsageDoc {
+    id: string | number;
+    usageKey: string;
+    componentName: string;
+    depth?: number;
+    sourceCollection: string;
+    sourceType: string;
+    sourceDocumentId: string;
+    sourceTitle?: string;
+    sourceSlug?: string;
+    sourceStatus?: string;
+    moduleId?: string;
+    modulePath: string;
+    parentComponentName?: string;
+    parentModuleId?: string;
+    parentModulePath?: string;
+}
+export interface NitrogenInventorySourceDoc {
+    id: string | number;
+    title?: string;
+    slug?: string;
+    status?: string;
+    _status?: string;
+    nitrogenData?: JsonObject | JsonObject[];
+}
 export {};