@synergy-design-system/metadata 1.0.0 → 3.0.0

package/dist/public/domains/setup.js

@@ -0,0 +1,144 @@
+import { createMetadataStore } from '../store.js';
+import { layerExistsForEntity, readLayerFilesForEntity, sortByEntityId, } from '../utils.js';
+const ANGULAR_ENTITY_IDS = new Set([
+    'setup:angular-package',
+    'setup:angular-components-module',
+    'setup:angular-forms-module',
+    'setup:angular-validators-module',
+]);
+const shouldExcludeSetupPath = (path, includeLimitations) => {
+    const normalized = path.toLowerCase();
+    // Only include markdown files
+    if (!normalized.endsWith('.md')) {
+        return true;
+    }
+    if (normalized.endsWith('/changelog.md') || normalized.endsWith('/breaking_changes.md')) {
+        return true;
+    }
+    if (!includeLimitations && normalized.endsWith('/limitations.md')) {
+        return true;
+    }
+    return false;
+};
+const selectSetupEntities = (entities, options) => {
+    if (options.package === 'components') {
+        return entities.filter((entity) => entity.id === 'setup:components-package');
+    }
+    // Framework packages always include base components
+    if (options.package === 'react') {
+        const selectedIds = new Set(['setup:components-package', 'setup:react-package']);
+        return entities.filter((entity) => selectedIds.has(entity.id));
+    }
+    if (options.package === 'vue') {
+        const selectedIds = new Set(['setup:components-package', 'setup:vue-package']);
+        return entities.filter((entity) => selectedIds.has(entity.id));
+    }
+    if (options.package === 'angular') {
+        const selectedIds = new Set(['setup:components-package', ...ANGULAR_ENTITY_IDS]);
+        return entities.filter((entity) => selectedIds.has(entity.id));
+    }
+    if (options.package === 'migrations') {
+        return entities.filter((entity) => entity.id === 'setup:synergy-migrations');
+    }
+    return entities.filter((entity) => entity.package === options.package);
+};
+/**
+ * Get setup data for a specific package, with options for layer inclusion and verbosity.
+ * @param options Options for querying setup data, including the package to query for, whether to include limitation documents, layer preferences, and strict layer enforcement.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the setup data for the specified package, or null if not found.
+ */
+export const getDataForSetup = async (options, storeOptions = {}) => {
+    const store = createMetadataStore(storeOptions);
+    const index = await store.getIndex();
+    const requestedLayer = options.layer ?? 'full';
+    const includeLimitations = options.includeLimitations ?? true;
+    const requestedVerbosity = 'readable';
+    const entities = sortByEntityId((await store.findEntities({
+        kind: 'setup',
+    })));
+    const selected = selectSetupEntities(entities, options);
+    if (selected.length === 0) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'NOT_FOUND',
+                    details: {
+                        package: options.package,
+                    },
+                    message: `No setup data found for package "${options.package}".`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: selected.length,
+            },
+        };
+    }
+    const hasRequestedLayer = selected.every((entity) => layerExistsForEntity(entity, requestedLayer));
+    if (options.strictLayer && !hasRequestedLayer) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'LAYER_NOT_AVAILABLE',
+                    details: {
+                        requestedLayer,
+                    },
+                    message: `Requested layer "${requestedLayer}" is not available for all selected setup entities.`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: selected.length,
+                warnings: ['strictLayer=true and requested layer is unavailable for part of result set'],
+            },
+        };
+    }
+    const resolvedLayer = hasRequestedLayer ? requestedLayer : 'full';
+    const setups = await Promise.all(selected.map(async (entity) => {
+        const layerFiles = await readLayerFilesForEntity(store, entity, resolvedLayer);
+        const text = layerFiles
+            .filter(({ ref }) => !shouldExcludeSetupPath(ref.path, includeLimitations))
+            .map(({ content, ref }) => ({
+            content,
+            path: ref.path,
+        }))
+            .toSorted((a, b) => a.path.localeCompare(b.path));
+        return {
+            custom: entity.custom,
+            id: entity.id,
+            name: entity.name,
+            package: entity.package,
+            sources: entity.sources.filter((source) => !shouldExcludeSetupPath(source, includeLimitations)),
+            tags: entity.tags,
+            text,
+        };
+    }));
+    return {
+        data: {
+            layer: resolvedLayer,
+            package: options.package,
+            setups,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "full".`,
+            ],
+        },
+        meta: {
+            builtAt: index.builtAt,
+            requestedLayer,
+            requestedVerbosity,
+            resolvedLayer,
+            schemaVersion: index.version,
+            total: selected.length,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "full".`,
+            ],
+        },
+    };
+};

package/dist/public/domains/styles.d.ts

@@ -0,0 +1,47 @@
+import { type LayerName, type MetadataEntity, type MetadataStoreOptions, type PublicRequestOptions, type PublicResponse, type StyleCustom } from '../types.js';
+/** Query options for listing or resolving style entities. */
+export type StyleQueryOptions = PublicRequestOptions & {
+    status?: string;
+    tags?: string[];
+};
+/** Supported style data layer selector. */
+export type StyleDataLayer = 'examples';
+/** Options for retrieving style data payloads. */
+export type StyleDataQueryOptions = {
+    layer?: StyleDataLayer;
+};
+/** One textual style example file with source path. */
+export type StyleTextLayerContent = {
+    content: string;
+    path: string;
+};
+/** High-level style data payload returned by getDataForStyle. */
+export type StyleDataPayload = {
+    examples?: StyleTextLayerContent[];
+    layer: LayerName;
+    style: string;
+    warnings?: string[];
+};
+/**
+ * List all styles, with options for filtering by status, tags, layer inclusion, and verbosity.
+ * @param options Options for querying styles, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the list of styles.
+ */
+export declare const listStyles: (options?: StyleQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<MetadataEntity<StyleCustom>[]>>;
+/**
+ * Get metadata for a specific style by name or ID, with options for layer inclusion and verbosity.
+ * @param nameOrId The name or ID of the style to retrieve metadata for.
+ * @param options Options for querying the style, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the style metadata, or null if not found.
+ */
+export declare const getStyleMetadata: (nameOrId: string, options?: StyleQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<MetadataEntity<StyleCustom> | null>>;
+/**
+ * High-level helper for style usage payloads grouped by layer semantics.
+ * @param nameOrId The name or ID of the style to retrieve usage data for.
+ * @param options Options for querying the style usage data, including layer preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the style usage data, or null if not found.
+ */
+export declare const getDataForStyle: (nameOrId: string, options?: StyleDataQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<StyleDataPayload | null>>;

package/dist/public/domains/styles.js

@@ -0,0 +1,182 @@
+import { createMetadataStore } from '../store.js';
+import { layerExistsForEntity, mapEntityForResponse, matchesEntityNameOrId, paginate, readLayerFilesForEntity, sortByEntityId, } from '../utils.js';
+const matchesNameOrId = (entity, nameOrId) => matchesEntityNameOrId(entity, nameOrId, {
+    extraCandidates: [typeof entity.custom?.moduleName === 'string' ? entity.custom.moduleName : undefined],
+    prefix: 'style',
+    // eslint-disable-next-line no-confusing-arrow
+    prefixedCandidates: (input) => !input.startsWith('syn-') ? [`style:syn-${input}`] : [],
+});
+/**
+ * List all styles, with options for filtering by status, tags, layer inclusion, and verbosity.
+ * @param options Options for querying styles, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the list of styles.
+ */
+export const listStyles = async (options = {}, storeOptions = {}) => {
+    const store = createMetadataStore(storeOptions);
+    const index = await store.getIndex();
+    const requestedLayer = options.layer ?? 'full';
+    const requestedVerbosity = options.verbosity ?? 'readable';
+    const entities = await store.findEntities({
+        kind: 'style',
+        status: options.status,
+        tags: options.tags,
+    });
+    const sorted = sortByEntityId(entities);
+    const hasRequestedLayer = sorted.every((entity) => layerExistsForEntity(entity, requestedLayer));
+    if (options.strictLayer && !hasRequestedLayer) {
+        return {
+            data: [],
+            errors: [{
+                    code: 'LAYER_NOT_AVAILABLE',
+                    details: {
+                        requestedLayer,
+                    },
+                    message: `Requested layer "${requestedLayer}" is not available for all style entities.`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+                warnings: ['strictLayer=true and requested layer is unavailable for part of result set'],
+            },
+        };
+    }
+    const resolvedLayer = hasRequestedLayer ? requestedLayer : 'full';
+    const paged = paginate(sorted, options.limit, options.offset);
+    return {
+        data: paged.map((entity) => mapEntityForResponse(entity, options)),
+        meta: {
+            builtAt: index.builtAt,
+            requestedLayer,
+            requestedVerbosity,
+            resolvedLayer,
+            schemaVersion: index.version,
+            total: sorted.length,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "full".`,
+            ],
+        },
+    };
+};
+/**
+ * Get metadata for a specific style by name or ID, with options for layer inclusion and verbosity.
+ * @param nameOrId The name or ID of the style to retrieve metadata for.
+ * @param options Options for querying the style, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the style metadata, or null if not found.
+ */
+export const getStyleMetadata = async (nameOrId, options = {}, storeOptions = {}) => {
+    const store = createMetadataStore(storeOptions);
+    const index = await store.getIndex();
+    const requestedLayer = options.layer ?? 'full';
+    const requestedVerbosity = options.verbosity ?? 'readable';
+    const entities = (await store.findEntities({
+        kind: 'style',
+        status: options.status,
+        tags: options.tags,
+    }));
+    const sorted = sortByEntityId(entities);
+    const entity = sorted.find((candidate) => matchesNameOrId(candidate, nameOrId));
+    if (!entity) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'NOT_FOUND',
+                    details: {
+                        nameOrId,
+                    },
+                    message: `Style "${nameOrId}" was not found.`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+            },
+        };
+    }
+    const hasRequestedLayer = layerExistsForEntity(entity, requestedLayer);
+    if (options.strictLayer && !hasRequestedLayer) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'LAYER_NOT_AVAILABLE',
+                    details: {
+                        id: entity.id,
+                        requestedLayer,
+                    },
+                    message: `Requested layer "${requestedLayer}" is not available for style "${entity.id}".`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+                warnings: ['strictLayer=true and requested layer is unavailable for the selected entity'],
+            },
+        };
+    }
+    const resolvedLayer = hasRequestedLayer ? requestedLayer : 'full';
+    return {
+        data: mapEntityForResponse(entity, options),
+        meta: {
+            builtAt: index.builtAt,
+            requestedLayer,
+            requestedVerbosity,
+            resolvedLayer,
+            schemaVersion: index.version,
+            total: sorted.length,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "full".`,
+            ],
+        },
+    };
+};
+/**
+ * High-level helper for style usage payloads grouped by layer semantics.
+ * @param nameOrId The name or ID of the style to retrieve usage data for.
+ * @param options Options for querying the style usage data, including layer preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the style usage data, or null if not found.
+ */
+export const getDataForStyle = async (nameOrId, options = {}, storeOptions = {}) => {
+    const requestedLayer = options.layer ?? 'examples';
+    const metadata = await getStyleMetadata(nameOrId, {
+        includeLayerRefs: true,
+        includeSources: false,
+        layer: requestedLayer,
+    }, storeOptions);
+    if (!metadata.data) {
+        return {
+            ...metadata,
+            data: null,
+        };
+    }
+    const store = createMetadataStore(storeOptions);
+    const layerFiles = await readLayerFilesForEntity(store, metadata.data, metadata.meta.resolvedLayer);
+    const textLayerContent = layerFiles
+        .filter(({ ref }) => ref.path.endsWith('.md'))
+        .map(({ content, ref }) => ({
+        content,
+        path: ref.path,
+    }))
+        .toSorted((a, b) => a.path.localeCompare(b.path));
+    const data = {
+        examples: textLayerContent,
+        layer: metadata.meta.resolvedLayer,
+        style: metadata.data.id,
+        warnings: metadata.meta.warnings,
+    };
+    return {
+        ...metadata,
+        data,
+    };
+};

package/dist/public/domains/templates.d.ts

@@ -0,0 +1,47 @@
+import { type LayerName, type MetadataEntity, type MetadataStoreOptions, type PublicRequestOptions, type PublicResponse } from '../types.js';
+/** Query options for listing or resolving template entities. */
+export type TemplateQueryOptions = PublicRequestOptions & {
+    status?: string;
+    tags?: string[];
+};
+/** Supported template data layer selector. */
+export type TemplateDataLayer = 'examples';
+/** Options for retrieving template data payloads. */
+export type TemplateDataQueryOptions = {
+    layer?: TemplateDataLayer;
+};
+/** One textual template example file with source path. */
+export type TemplateTextLayerContent = {
+    content: string;
+    path: string;
+};
+/** High-level template data payload returned by getDataForTemplate. */
+export type TemplateDataPayload = {
+    examples?: TemplateTextLayerContent[];
+    layer: LayerName;
+    template: string;
+    warnings?: string[];
+};
+/**
+ * List all templates, with options for filtering by status, tags, layer inclusion, and verbosity.
+ * @param options Options for querying templates, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the list of templates.
+ */
+export declare const listTemplates: (options?: TemplateQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<MetadataEntity[]>>;
+/**
+ * Get metadata for a specific template by name or ID, with options for layer inclusion and verbosity.
+ * @param nameOrId The name or ID of the template to retrieve metadata for.
+ * @param options Options for querying the template, including filtering by status and tags, layer/verbosity preferences, and whether to include layer references and sources.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the template metadata and related information, or null if not found.
+ */
+export declare const getTemplateMetadata: (nameOrId: string, options?: TemplateQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<MetadataEntity | null>>;
+/**
+ * High-level helper for template usage payloads grouped by layer semantics.
+ * @param nameOrId The name or ID of the template to retrieve usage data for.
+ * @param options Options for querying the template usage data, including layer preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the template usage data, or null if not found.
+ */
+export declare const getDataForTemplate: (nameOrId: string, options?: TemplateDataQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<TemplateDataPayload | null>>;

package/dist/public/domains/templates.js

@@ -0,0 +1,182 @@
+import { createMetadataStore } from '../store.js';
+import { layerExistsForEntity, mapEntityForResponse, matchesEntityNameOrId, paginate, readLayerFilesForEntity, sortByEntityId, } from '../utils.js';
+const matchesNameOrId = (entity, nameOrId) => matchesEntityNameOrId(entity, nameOrId, {
+    prefix: 'template',
+});
+/**
+ * List all templates, with options for filtering by status, tags, layer inclusion, and verbosity.
+ * @param options Options for querying templates, including filtering by status and tags, layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the list of templates.
+ */
+export const listTemplates = async (options = {}, storeOptions = {}) => {
+    const store = createMetadataStore(storeOptions);
+    const index = await store.getIndex();
+    const requestedLayer = options.layer ?? 'examples';
+    const requestedVerbosity = options.verbosity ?? 'readable';
+    const entities = await store.findEntities({
+        kind: 'template',
+        status: options.status,
+        tags: options.tags,
+    });
+    const sorted = sortByEntityId(entities);
+    const hasRequestedLayer = sorted.every((entity) => layerExistsForEntity(entity, requestedLayer));
+    if (options.strictLayer && !hasRequestedLayer) {
+        return {
+            data: [],
+            errors: [{
+                    code: 'LAYER_NOT_AVAILABLE',
+                    details: {
+                        requestedLayer,
+                    },
+                    message: `Requested layer "${requestedLayer}" is not available for all template entities.`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+                warnings: ['strictLayer=true and requested layer is unavailable for part of result set'],
+            },
+        };
+    }
+    const resolvedLayer = hasRequestedLayer ? requestedLayer : 'examples';
+    const paged = paginate(sorted, options.limit, options.offset);
+    return {
+        data: paged.map((entity) => mapEntityForResponse(entity, options)),
+        meta: {
+            builtAt: index.builtAt,
+            requestedLayer,
+            requestedVerbosity,
+            resolvedLayer,
+            schemaVersion: index.version,
+            total: sorted.length,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "examples".`,
+            ],
+        },
+    };
+};
+/**
+ * Get metadata for a specific template by name or ID, with options for layer inclusion and verbosity.
+ * @param nameOrId The name or ID of the template to retrieve metadata for.
+ * @param options Options for querying the template, including filtering by status and tags, layer/verbosity preferences, and whether to include layer references and sources.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the template metadata and related information, or null if not found.
+ */
+export const getTemplateMetadata = async (nameOrId, options = {}, storeOptions = {}) => {
+    const store = createMetadataStore(storeOptions);
+    const index = await store.getIndex();
+    const requestedLayer = options.layer ?? 'examples';
+    const requestedVerbosity = options.verbosity ?? 'readable';
+    const entities = await store.findEntities({
+        kind: 'template',
+        status: options.status,
+        tags: options.tags,
+    });
+    const sorted = sortByEntityId(entities);
+    const entity = sorted.find((candidate) => matchesNameOrId(candidate, nameOrId));
+    if (!entity) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'NOT_FOUND',
+                    details: {
+                        nameOrId,
+                    },
+                    message: `Template "${nameOrId}" was not found.`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+            },
+        };
+    }
+    const hasRequestedLayer = layerExistsForEntity(entity, requestedLayer);
+    if (options.strictLayer && !hasRequestedLayer) {
+        return {
+            data: null,
+            errors: [{
+                    code: 'LAYER_NOT_AVAILABLE',
+                    details: {
+                        id: entity.id,
+                        requestedLayer,
+                    },
+                    message: `Requested layer "${requestedLayer}" is not available for template "${entity.id}".`,
+                }],
+            meta: {
+                builtAt: index.builtAt,
+                requestedLayer,
+                requestedVerbosity,
+                resolvedLayer: requestedLayer,
+                schemaVersion: index.version,
+                total: sorted.length,
+                warnings: ['strictLayer=true and requested layer is unavailable for the selected entity'],
+            },
+        };
+    }
+    const resolvedLayer = hasRequestedLayer ? requestedLayer : 'examples';
+    return {
+        data: mapEntityForResponse(entity, options),
+        meta: {
+            builtAt: index.builtAt,
+            requestedLayer,
+            requestedVerbosity,
+            resolvedLayer,
+            schemaVersion: index.version,
+            total: sorted.length,
+            warnings: hasRequestedLayer ? undefined : [
+                `Requested layer "${requestedLayer}" was unavailable; falling back to "examples".`,
+            ],
+        },
+    };
+};
+/**
+ * High-level helper for template usage payloads grouped by layer semantics.
+ * @param nameOrId The name or ID of the template to retrieve usage data for.
+ * @param options Options for querying the template usage data, including layer preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the template usage data, or null if not found.
+ */
+export const getDataForTemplate = async (nameOrId, options = {}, storeOptions = {}) => {
+    const requestedLayer = options.layer ?? 'examples';
+    const metadata = await getTemplateMetadata(nameOrId, {
+        includeLayerRefs: true,
+        includeSources: false,
+        layer: requestedLayer,
+    }, storeOptions);
+    if (!metadata.data) {
+        return {
+            ...metadata,
+            data: null,
+        };
+    }
+    const store = createMetadataStore(storeOptions);
+    const layerFiles = await readLayerFilesForEntity(store, metadata.data, metadata.meta.resolvedLayer);
+    const textLayerContent = layerFiles
+        .filter(({ ref }) => ref.path.endsWith('.md'))
+        .map(({ content, ref }) => ({
+        content,
+        path: ref.path,
+    }))
+        .toSorted((a, b) => a.path.localeCompare(b.path));
+    const basePayload = {
+        layer: metadata.meta.resolvedLayer,
+        template: metadata.data.id,
+        warnings: metadata.meta.warnings,
+    };
+    const data = {
+        ...basePayload,
+        examples: textLayerContent,
+    };
+    return {
+        ...metadata,
+        data,
+    };
+};

package/dist/public/domains/tokens.d.ts

@@ -0,0 +1,46 @@
+import { type MetadataEntity, type MetadataStoreOptions, type PublicRequestOptions, type PublicResponse, type TokenCustom } from '../types.js';
+/** Query options for listing token entities. */
+export type TokenQueryOptions = PublicRequestOptions & {
+    status?: string;
+    tags?: string[];
+};
+/** Supported output formats for token artifacts. */
+export type TokenFormat = 'css' | 'figma' | 'javascript' | 'sass';
+/** Supported theme variants for CSS token artifacts. */
+export type TokenTheme = 'sick2018-dark' | 'sick2018-light' | 'sick2025-dark' | 'sick2025-light';
+/** Query options for retrieving concrete token file contents. */
+export type TokenDataQueryOptions = {
+    format?: TokenFormat;
+    limit?: number;
+    offset?: number;
+    theme?: TokenTheme;
+};
+/** One resolved token artifact file plus metadata context. */
+export type TokenDataContent = {
+    content: string;
+    format?: TokenFormat;
+    path: string;
+    theme?: TokenTheme;
+    token: string;
+};
+/** High-level token payload returned by getDataForTokens. */
+export type TokenDataPayload = {
+    format: TokenFormat;
+    theme?: TokenTheme;
+    tokens: TokenDataContent[];
+    warnings?: string[];
+};
+/**
+ * List tokens with optional filtering and pagination.
+ * @param options Options for querying tokens, including filtering by status and tags, pagination, and layer/verbosity preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the list of tokens and metadata.
+ */
+export declare const getTokens: (options?: TokenQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<MetadataEntity<TokenCustom>[]>>;
+/**
+ * Get token data for a specific format and theme, with options for pagination.
+ * @param options Options for querying token data, including format, theme, pagination preferences.
+ * @param storeOptions Options for configuring the metadata store.
+ * @returns A promise that resolves to a public response containing the token data payload, or null if not found.
+ */
+export declare const getDataForTokens: (options?: TokenDataQueryOptions, storeOptions?: MetadataStoreOptions) => Promise<PublicResponse<TokenDataPayload>>;