@contentful/experience-design-system-types 2.42.1-dev-build-f69db6bf.0 → 2.43.0-alpha.0

package/dist/src/cdf/schema.js

@@ -1,5 +1,8 @@
+import { allowedResourcesJsonSchema, targetDefinitionMetadataJsonProperties, } from '../property-contract/resource-link-schema.js';
+import { TARGET_PROPERTY_TYPES } from '../property-contract/target-definition.js';
 import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
 import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
+import { modelComponentExplorationJsonSchema } from '../property-contract/model-exploration.js';
 export const CDF_SCHEMA_URL = 'https://contentful.com/schemas/cdf';
 /**
  * Components and design tokens live in one recursive tree. A leaf's `$type`
@@ -8,6 +11,33 @@ export const CDF_SCHEMA_URL = 'https://contentful.com/schemas/cdf';
  * separate manifest envelope — this document is the single file/wire
  * payload sent to preview/apply.
  */
+const finiteValuesSchema = {
+    if: { required: ['$values'] },
+    then: {
+        anyOf: ['string', 'number', 'boolean'].map((type) => ({
+            properties: {
+                $type: { const: type },
+                $values: { type: 'array', minItems: 1, uniqueItems: true, items: { type } },
+            },
+        })),
+    },
+};
+const fieldMetadataJsonProperties = {
+    $description: { type: 'string' },
+    $required: { type: 'boolean' },
+    $default: {},
+    $values: { type: 'array', minItems: 1 },
+    $items: { $ref: '#/definitions/field' },
+    $fields: { type: 'object', minProperties: 1, additionalProperties: { $ref: '#/definitions/field' } },
+};
+const fieldStructureJsonProperties = {
+    '$token.allowed': { type: 'array', items: { type: 'string' } },
+    value: {},
+    valueType: { $ref: '#/definitions/field' },
+    discriminator: { type: 'string', minLength: 1 },
+    members: { type: 'array', minItems: 2, items: { $ref: '#/definitions/field' } },
+    allowedResources: { $ref: '#/definitions/allowedResources' },
+};
 export const cdfJsonSchema = {
     $schema: 'http://json-schema.org/draft-07/schema#',
     $id: CDF_SCHEMA_URL,
@@ -32,6 +62,8 @@ export const cdfJsonSchema = {
                     type: 'object',
                     additionalProperties: { $ref: '#/definitions/property' },
                 },
+                $model: { $ref: '#/definitions/modelBinding' },
+                $representationPlans: { type: 'object', additionalProperties: { $ref: '#/definitions/representationPlan' } },
                 $slots: {
                     type: 'object',
                     additionalProperties: { $ref: '#/definitions/slot' },
@@ -41,25 +73,350 @@ export const cdfJsonSchema = {
         },
         property: {
             type: 'object',
+            allOf: [finiteValuesSchema],
             required: ['$type', '$category'],
             properties: {
                 $type: { type: 'string', enum: [...CDF_PROPERTY_TYPES] },
                 $category: { type: 'string', enum: [...CDF_PROPERTY_CATEGORIES] },
-                $description: { type: 'string' },
-                $required: { type: 'boolean' },
-                $default: {},
-                $values: { type: 'array', items: { type: 'string' } },
+                ...fieldMetadataJsonProperties,
+                $sourceInput: { $ref: '#/definitions/sourceInput' },
                 '$token.kind': { type: 'string', minLength: 1 },
-                '$token.allowed': { type: 'array', items: { type: 'string' } },
+                ...fieldStructureJsonProperties,
             },
             // The API rejects a token property that does not say which kind of token it takes.
             if: { type: 'object', properties: { $type: { const: 'token' } }, required: ['$type'] },
             then: { type: 'object', required: ['$token.kind'] },
             additionalProperties: false,
         },
+        field: {
+            type: 'object',
+            allOf: [finiteValuesSchema],
+            required: ['$type'],
+            properties: {
+                $type: { enum: [...CDF_PROPERTY_TYPES] },
+                $category: { enum: [...CDF_PROPERTY_CATEGORIES] },
+                ...fieldMetadataJsonProperties,
+                '$token.kind': { type: 'string' },
+                ...fieldStructureJsonProperties,
+            },
+            additionalProperties: false,
+        },
+        allowedResources: allowedResourcesJsonSchema,
+        sourceInput: {
+            type: 'object',
+            required: ['schemaVersion', 'componentId', 'componentDeclarationId', 'rootSymbolId', 'inputName', 'inputPath'],
+            properties: {
+                schemaVersion: { const: 1 },
+                componentId: { type: 'string', minLength: 1 },
+                componentDeclarationId: { type: 'string', minLength: 1 },
+                rootSymbolId: { type: 'string', minLength: 1 },
+                inputName: { type: 'string', minLength: 1 },
+                inputPath: { type: 'array', minItems: 1, items: { type: 'string', minLength: 1 } },
+            },
+            additionalProperties: false,
+        },
+        modelBinding: {
+            type: 'object',
+            required: ['planId', 'componentId', 'propertyId', 'nodeId'],
+            properties: {
+                planId: { type: 'string' },
+                componentId: { type: 'string' },
+                propertyId: { type: 'string' },
+                nodeId: { type: 'string' },
+                sourceNodeId: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
+        modelCardinality: {
+            type: 'object',
+            required: ['min', 'max', 'ordered'],
+            properties: {
+                min: { type: 'integer', minimum: 0 },
+                max: { type: ['integer', 'null'], minimum: 0 },
+                ordered: { type: 'boolean' },
+                tuplePosition: { type: 'integer', minimum: 0 },
+                rest: { type: 'boolean' },
+            },
+            additionalProperties: false,
+        },
+        targetDefinition: {
+            type: 'object',
+            required: ['type'],
+            properties: {
+                type: { enum: [...TARGET_PROPERTY_TYPES] },
+                ...targetDefinitionMetadataJsonProperties,
+                values: { type: 'array', items: {} },
+                defaultValue: {},
+                items: { $ref: '#/definitions/targetDefinition' },
+                fields: { type: 'object', additionalProperties: { $ref: '#/definitions/targetDefinition' } },
+                allowedResources: { $ref: '#/definitions/allowedResources' },
+                value: {},
+                valueType: { $ref: '#/definitions/targetDefinition' },
+                discriminator: { type: 'string', minLength: 1 },
+                members: { type: 'array', minItems: 2, items: { $ref: '#/definitions/targetDefinition' } },
+            },
+            additionalProperties: false,
+        },
+        representationProposal: {
+            type: 'object',
+            required: [
+                'componentId',
+                'propertyId',
+                'key',
+                'name',
+                'sourceRevision',
+                'sourceNodeIds',
+                'declaredConstraints',
+                'provenConstraints',
+                'observations',
+                'judgment',
+                'desiredType',
+                'desiredDefinition',
+            ],
+            properties: {
+                componentId: { type: 'string' },
+                propertyId: { type: 'string' },
+                key: { type: 'string' },
+                name: { type: 'string' },
+                sourceRevision: { type: 'string' },
+                sourceNodeIds: { type: 'array', items: { type: 'string' } },
+                declaredConstraints: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['nodeId', 'statement'],
+                        properties: { nodeId: { type: 'string' }, statement: { type: 'string' } },
+                        additionalProperties: false,
+                    },
+                },
+                provenConstraints: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['nodeId', 'statement'],
+                        properties: { nodeId: { type: 'string' }, statement: { type: 'string' } },
+                        additionalProperties: false,
+                    },
+                },
+                observations: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['nodeId', 'value'],
+                        properties: { nodeId: { type: 'string' }, value: {} },
+                        additionalProperties: false,
+                    },
+                },
+                judgment: { type: 'string' },
+                desiredType: { enum: [...TARGET_PROPERTY_TYPES] },
+                desiredDefinition: { $ref: '#/definitions/targetDefinition' },
+                compatibility: {
+                    type: 'object',
+                    required: ['status', 'sourceUseRefs', 'unresolvedRequirements'],
+                    properties: {
+                        status: { enum: ['judged-compatible', 'unresolved', 'contradicted'] },
+                        sourceUseRefs: { type: 'array', uniqueItems: true, items: { type: 'string', minLength: 1 } },
+                        unresolvedRequirements: { type: 'array', items: { type: 'string', minLength: 1 } },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+        },
+        representationPlan: {
+            type: 'object',
+            required: [
+                'schemaVersion',
+                'id',
+                'kind',
+                'identity',
+                'sourceModel',
+                'sourceDigest',
+                'contextDigest',
+                'logicalGraph',
+                'category',
+                'defaultIntent',
+                'models',
+                'mappings',
+                'issues',
+                'sdkValid',
+                'requirements',
+            ],
+            properties: {
+                proposal: { $ref: '#/definitions/representationProposal' },
+                schemaVersion: { const: 1 },
+                id: { type: 'string' },
+                kind: { enum: ['native', 'component-model'] },
+                identity: {
+                    type: 'object',
+                    required: ['componentId', 'propertyId', 'key', 'sourceRevision', 'nodeId'],
+                    properties: {
+                        componentId: { type: 'string' },
+                        propertyId: { type: 'string' },
+                        key: { type: 'string' },
+                        sourceRevision: { type: 'string' },
+                        nodeId: { type: 'string' },
+                    },
+                    additionalProperties: false,
+                },
+                logicalGraph: { type: 'object' },
+                sourceModel: { type: 'object' },
+                contextSnapshot: {},
+                sourceDigest: { type: 'string' },
+                contextDigest: { type: 'string' },
+                category: { enum: [...CDF_PROPERTY_CATEGORIES] },
+                defaultIntent: {
+                    oneOf: [
+                        {
+                            type: 'object',
+                            required: ['action'],
+                            properties: { action: { enum: ['absent', 'clear'] } },
+                            additionalProperties: false,
+                        },
+                        {
+                            type: 'object',
+                            required: ['action', 'value'],
+                            properties: { action: { const: 'set' }, value: {} },
+                            additionalProperties: false,
+                        },
+                    ],
+                },
+                sourceDefault: { type: 'object' },
+                nativeDefinition: { $ref: '#/definitions/property' },
+                models: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['key', 'originalKey', 'nodeId', 'entry'],
+                        properties: {
+                            key: { type: 'string' },
+                            originalKey: { type: 'string' },
+                            nodeId: { type: 'string' },
+                            entry: { $ref: '#/definitions/component' },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                modelExplorations: { type: 'array', items: modelComponentExplorationJsonSchema },
+                attachment: {
+                    type: 'object',
+                    required: ['slot', 'definition'],
+                    properties: { slot: { type: 'string' }, definition: { $ref: '#/definitions/slot' } },
+                    additionalProperties: false,
+                },
+                mappings: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['nodeId', 'path', 'required', 'nullable', 'undefinable', 'disposition'],
+                        properties: {
+                            nodeId: { type: 'string' },
+                            sourceNodeId: { type: 'string' },
+                            readonly: { type: 'boolean' },
+                            occurrenceReadonly: { type: 'boolean' },
+                            intrinsicReadonly: { type: 'boolean' },
+                            defaultIntent: { type: 'object' },
+                            path: { type: 'array', items: { type: 'object' } },
+                            required: { type: 'boolean' },
+                            nullable: { type: ['boolean', 'null'] },
+                            undefinable: { type: ['boolean', 'null'] },
+                            disposition: { enum: ['native-field', 'model', 'slot', 'reference', 'reconstruction', 'held'] },
+                            reconstruction: {
+                                oneOf: [
+                                    {
+                                        type: 'object',
+                                        required: ['kind', 'value'],
+                                        properties: { kind: { const: 'fixed-value' }, value: {} },
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: ['kind', 'valueNodeId'],
+                                        properties: { kind: { const: 'optional-value' }, valueNodeId: { type: 'string' } },
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: ['kind', 'field', 'valueNodeId'],
+                                        properties: {
+                                            kind: { const: 'object-envelope' },
+                                            field: { type: 'string' },
+                                            valueNodeId: { type: 'string' },
+                                        },
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: ['kind', 'itemNodeId'],
+                                        properties: { kind: { const: 'ordered-array' }, itemNodeId: { type: 'string' } },
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: ['kind', 'state'],
+                                        properties: {
+                                            kind: { const: 'empty-value' },
+                                            state: { enum: ['null', 'undefined', 'never'] },
+                                        },
+                                        additionalProperties: false,
+                                    },
+                                ],
+                            },
+                            componentKey: { type: 'string' },
+                            field: { type: 'string' },
+                            slot: { type: 'string' },
+                            targetNodeId: { type: 'string' },
+                            reason: { type: 'string' },
+                            withinValue: {
+                                type: 'object',
+                                required: ['ownerNodeId', 'path'],
+                                properties: { ownerNodeId: { type: 'string' }, path: { type: 'array', items: { type: 'object' } } },
+                                additionalProperties: false,
+                            },
+                            branchConditions: { type: 'array', items: { type: 'object' } },
+                            variant: {
+                                type: 'object',
+                                required: ['wrapperKey', 'slot', 'componentKey'],
+                                properties: {
+                                    wrapperKey: { type: 'string' },
+                                    slot: { type: 'string' },
+                                    componentKey: { type: 'string' },
+                                },
+                                additionalProperties: false,
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                issues: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['path', 'message'],
+                        properties: { path: { type: 'string' }, message: { type: 'string' } },
+                        additionalProperties: false,
+                    },
+                },
+                sdkValid: { type: 'boolean' },
+                branchSelections: { type: 'array', items: { type: 'object' } },
+                requirements: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['path', 'capability'],
+                        properties: { path: { type: 'string' }, capability: { type: 'string' } },
+                        additionalProperties: false,
+                    },
+                },
+            },
+            additionalProperties: false,
+        },
         slot: {
             type: 'object',
             properties: {
+                $sourceInput: { $ref: '#/definitions/sourceInput' },
+                $modelBinding: { $ref: '#/definitions/modelBinding' },
+                $cardinality: { $ref: '#/definitions/modelCardinality' },
                 $description: { type: 'string' },
                 $required: { type: 'boolean' },
                 $allowedComponents: { type: 'array', items: { type: 'string' } },

package/dist/src/cdf/types.d.ts

@@ -1,69 +1,67 @@
 import * as z from 'zod/mini';
-export declare const CDFPropertySchema: z.ZodMiniObject<{
-    $type: z.ZodMiniEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        richtext: "richtext";
-        media: "media";
-        link: "link";
-        enum: "enum";
-        token: "token";
-    }>;
-    $category: z.ZodMiniEnum<{
-        content: "content";
-        design: "design";
-        state: "state";
-        unattached: "unattached";
-    }>;
-    $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    $required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    $default: z.ZodMiniOptional<z.ZodMiniAny>;
-    $values: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    '$token.kind': z.ZodMiniOptional<z.ZodMiniString<string>>;
-    '$token.allowed': z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-}, z.core.$strict>;
-export type CDFPropertyDefinition = z.infer<typeof CDFPropertySchema>;
+import type { RepresentationPlan, ModelBinding } from '../property-contract/representation-plan.js';
+import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
+import { type SourceInputAssociation } from '../source-input-association.js';
+export interface CDFFieldDefinition {
+    $type: (typeof CDF_PROPERTY_TYPES)[number];
+    $category?: (typeof CDF_PROPERTY_CATEGORIES)[number];
+    $description?: string;
+    $required?: boolean;
+    $default?: import('../property-contract/json-value.js').JsonValue;
+    $values?: import('../property-contract/json-value.js').JsonValue[];
+    $items?: CDFFieldDefinition;
+    $fields?: Record<string, CDFFieldDefinition>;
+    value?: import('../property-contract/json-value.js').JsonValue;
+    valueType?: CDFFieldDefinition;
+    discriminator?: string;
+    members?: CDFFieldDefinition[];
+    allowedResources?: import('../property-contract/target-definition.js').TargetDefinition['allowedResources'];
+    '$token.kind'?: string;
+    '$token.allowed'?: string[];
+}
+export interface CDFPropertyDefinition extends CDFFieldDefinition {
+    $category: (typeof CDF_PROPERTY_CATEGORIES)[number];
+    $sourceInput?: SourceInputAssociation;
+}
+export declare const CDFPropertySchema: z.ZodMiniCustom<CDFPropertyDefinition, CDFPropertyDefinition>;
 export declare const CDFSlotSchema: z.ZodMiniObject<{
+    $modelBinding: z.ZodMiniOptional<z.ZodMiniObject<{
+        planId: z.ZodMiniString<string>;
+        componentId: z.ZodMiniString<string>;
+        propertyId: z.ZodMiniString<string>;
+        nodeId: z.ZodMiniString<string>;
+        sourceNodeId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strict>>;
+    $cardinality: z.ZodMiniOptional<z.ZodMiniObject<{
+        min: z.ZodMiniNumber<number>;
+        max: z.ZodMiniNullable<z.ZodMiniNumber<number>>;
+        ordered: z.ZodMiniBoolean<boolean>;
+        tuplePosition: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        rest: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strict>>;
+    $sourceInput: z.ZodMiniOptional<z.ZodMiniObject<{
+        schemaVersion: z.ZodMiniLiteral<1>;
+        componentId: z.ZodMiniString<string>;
+        componentDeclarationId: z.ZodMiniString<string>;
+        rootSymbolId: z.ZodMiniString<string>;
+        inputName: z.ZodMiniString<string>;
+        inputPath: z.ZodMiniArray<z.ZodMiniString<string>>;
+    }, z.core.$strict>>;
     $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
     $allowedComponents: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     $required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
 }, z.core.$strict>;
 export type CDFSlotDefinition = z.infer<typeof CDFSlotSchema>;
-export declare const CDFComponentSchema: z.ZodMiniObject<{
-    $type: z.ZodMiniLiteral<"component">;
-    $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    $properties: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
-        $type: z.ZodMiniEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            richtext: "richtext";
-            media: "media";
-            link: "link";
-            enum: "enum";
-            token: "token";
-        }>;
-        $category: z.ZodMiniEnum<{
-            content: "content";
-            design: "design";
-            state: "state";
-            unattached: "unattached";
-        }>;
-        $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        $required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        $default: z.ZodMiniOptional<z.ZodMiniAny>;
-        $values: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-        '$token.kind': z.ZodMiniOptional<z.ZodMiniString<string>>;
-        '$token.allowed': z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    }, z.core.$strict>>;
-    $slots: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
-        $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        $allowedComponents: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-        $required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type CDFComponentEntry = z.infer<typeof CDFComponentSchema>;
+export interface CDFComponentEntry {
+    $type: 'component';
+    $description?: string;
+    $properties: Record<string, CDFPropertyDefinition>;
+    $slots?: Record<string, CDFSlotDefinition>;
+    $model?: ModelBinding;
+    $representationPlans?: Record<string, RepresentationPlan>;
+}
+/** Custom admission keeps own dictionary keys intact instead of rebuilding a record. */
+export declare const CDFComponentSchema: z.ZodMiniCustom<CDFComponentEntry, CDFComponentEntry>;
 export interface CDFFile {
     $schema: string;
     [key: string]: unknown;

package/dist/src/cdf/types.js

@@ -1,26 +1,83 @@
+import { Ajv } from 'ajv';
+import { cdfJsonSchema } from './schema.js';
 import * as z from 'zod/mini';
-import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
+import { jsonValueIssue } from '../property-contract/json-value.js';
+import { validateCDFProperty } from './property-validation.js';
 import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
-export const CDFPropertySchema = z.strictObject({
-    $type: z.enum(CDF_PROPERTY_TYPES),
-    $category: z.enum(CDF_PROPERTY_CATEGORIES),
-    $description: z.optional(z.string()),
-    $required: z.optional(z.boolean()),
-    $default: z.optional(z.any()),
-    $values: z.optional(z.array(z.string())),
-    '$token.kind': z.optional(z.string()),
-    '$token.allowed': z.optional(z.array(z.string())),
+import { SourceInputAssociationSchema, validateCDFSourceOwnerContract, } from '../source-input-association.js';
+export const CDFPropertySchema = z.custom((value) => validateCDFProperty(value).valid);
+const ModelBindingSchema = z.strictObject({
+    planId: z.string(),
+    componentId: z.string(),
+    propertyId: z.string(),
+    nodeId: z.string(),
+    sourceNodeId: z.optional(z.string()),
 });
+const ModelCardinalitySchema = z
+    .strictObject({
+    min: z.number().check(z.int(), z.minimum(0)),
+    max: z.nullable(z.number().check(z.int(), z.minimum(0))),
+    ordered: z.boolean(),
+    tuplePosition: z.optional(z.number().check(z.int(), z.minimum(0))),
+    rest: z.optional(z.boolean()),
+})
+    .check(z.refine((value) => value.max === null || value.max >= value.min));
 export const CDFSlotSchema = z.strictObject({
+    $modelBinding: z.optional(ModelBindingSchema),
+    $cardinality: z.optional(ModelCardinalitySchema),
+    $sourceInput: z.optional(SourceInputAssociationSchema),
     $description: z.optional(z.string()),
     $allowedComponents: z.optional(z.array(z.string())),
     $required: z.optional(z.boolean()),
 });
-export const CDFComponentSchema = z.strictObject({
-    $type: z.literal('component'),
-    $description: z.optional(z.string()),
-    $properties: z.record(z.string(), CDFPropertySchema),
-    $slots: z.optional(z.record(z.string(), CDFSlotSchema)),
+const admitComponent = new Ajv({ allErrors: true }).compile({
+    $ref: '#/definitions/component',
+    definitions: cdfJsonSchema.definitions,
+});
+/** Custom admission keeps own dictionary keys intact instead of rebuilding a record. */
+export const CDFComponentSchema = z.custom((value) => {
+    if (jsonValueIssue(value) || !value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    if (!admitComponent(value))
+        return false;
+    const entry = value;
+    if (entry.$type !== 'component' ||
+        !entry.$properties ||
+        typeof entry.$properties !== 'object' ||
+        Array.isArray(entry.$properties))
+        return false;
+    if (Object.keys(entry).some((key) => !['$type', '$description', '$properties', '$slots', '$model', '$representationPlans'].includes(key)))
+        return false;
+    if (entry.$description !== undefined && typeof entry.$description !== 'string')
+        return false;
+    if (Object.values(entry.$properties).some((property) => !validateCDFProperty(property).valid))
+        return false;
+    if (entry.$slots !== undefined &&
+        (!entry.$slots ||
+            typeof entry.$slots !== 'object' ||
+            Array.isArray(entry.$slots) ||
+            Object.entries(entry.$slots).some(([key, slot]) => !key.trim() || !CDFSlotSchema.safeParse(slot).success)))
+        return false;
+    if (entry.$model !== undefined && !ModelBindingSchema.safeParse(entry.$model).success)
+        return false;
+    if (entry.$representationPlans !== undefined &&
+        (!entry.$representationPlans ||
+            typeof entry.$representationPlans !== 'object' ||
+            Array.isArray(entry.$representationPlans) ||
+            Object.entries(entry.$representationPlans).some(([key, plan]) => !plan ||
+                plan.identity?.key !== key ||
+                plan.schemaVersion !== 1 ||
+                typeof plan.id !== 'string' ||
+                !Array.isArray(plan.models) ||
+                !Array.isArray(plan.mappings))))
+        return false;
+    try {
+        validateCDFSourceOwnerContract(entry);
+        return true;
+    }
+    catch {
+        return false;
+    }
 });
 /** A token leaf — same shape as a DTCG token entry, but discovered inside
  * the CDF tree rather than a standalone DTCG document. */