@contentful/experience-design-system-types 2.39.1 → 2.40.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-types",
-  "version": "2.39.1",
+  "version": "2.40.0",
   "license": "MIT",
   "type": "module",
   "module": "./dist/src/index.js",

package/dist/src/index.d.ts

@@ -2,3 +2,4 @@ export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PRO
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, type DesignTokenType, type DTCGTokenEntry, type DTCGTokenGroup, type DTCGTokenNode, type DTCGTokenGroupNode, type DTCGValidationError, type DTCGValidationResult, } from './dtcg/index.js';
 export type { BreakingChange, ChangeClassification, DownstreamImpact, PropertySummary, ComponentTypeSummary, DesignTokenSummary, TaxonomySummary, ChangedEntity, EntityDiffGroup, ServerPreviewResponse, } from './sources-api/preview/index.js';
 export type { ApplyOperationStatus, ApplyOperationItemError, ApplyOperationItem, ApplyOperationResponse, ApplyGateError, } from './sources-api/apply/index.js';
+export * from './property-contract/index.js';

package/dist/src/index.js

@@ -3,3 +3,7 @@
 export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, } from './cdf/index.js';
 // DTCG (W3C Design Token Community Group)
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, } from './dtcg/index.js';
+// Property contract — pillar #4 foundation (target types + validators).
+// Dormant: no current consumer imports these. Available for forthcoming
+// evidence-aware extractors and generation. See INTEG-5147 / INTEG-4927.
+export * from './property-contract/index.js';

package/dist/src/property-contract/date-time-value.d.ts

@@ -0,0 +1,2 @@
+/** Preserve timezone-qualified ISO datetime strings without coercion or normalization. */
+export declare function isDateTimeValue(value: unknown): value is string;

package/dist/src/property-contract/date-time-value.js

@@ -0,0 +1,6 @@
+import * as z from 'zod/mini';
+const dateTimeValueSchema = z.iso.datetime({ offset: true });
+/** Preserve timezone-qualified ISO datetime strings without coercion or normalization. */
+export function isDateTimeValue(value) {
+    return dateTimeValueSchema.safeParse(value).success;
+}

package/dist/src/property-contract/discriminated-union.d.ts

@@ -0,0 +1,8 @@
+import { type PropertyIssue } from './json-value.js';
+type DefinitionStyle = 'target' | 'cdf';
+type Definition = Record<string, unknown>;
+/** An intrinsic tag belongs to one own field of a complete Record member. */
+export declare function discriminatedUnionTag(member: unknown, discriminator: string, style: DefinitionStyle): Definition | undefined;
+export declare function discriminatedUnionIssues(definition: Definition, style: DefinitionStyle, path?: string): PropertyIssue[];
+export declare function matchingDiscriminatedUnionMember(definition: Definition, value: Definition, style: DefinitionStyle): Definition | undefined;
+export {};

package/dist/src/property-contract/discriminated-union.js

@@ -0,0 +1,52 @@
+import { childPath, jsonEqual, own } from './json-value.js';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** An intrinsic tag belongs to one own field of a complete Record member. */
+export function discriminatedUnionTag(member, discriminator, style) {
+    if (!object(member) || member[style === 'target' ? 'type' : '$type'] !== (style === 'target' ? 'Record' : 'record'))
+        return;
+    const fields = member[style === 'target' ? 'fields' : '$fields'];
+    if (!object(fields) || !own(fields, discriminator))
+        return;
+    const field = fields[discriminator];
+    return object(field) ? field : undefined;
+}
+export function discriminatedUnionIssues(definition, style, path = '') {
+    const issues = [];
+    const discriminator = definition.discriminator;
+    if (typeof discriminator !== 'string' || !discriminator.length)
+        issues.push({ path: childPath(path, 'discriminator'), message: 'Union requires a nonempty discriminator' });
+    if (!Array.isArray(definition.members) || definition.members.length < 2) {
+        issues.push({ path: childPath(path, 'members'), message: 'Union requires at least two complete Record members' });
+        return issues;
+    }
+    const tags = new Set();
+    definition.members.forEach((member, index) => {
+        const at = childPath(childPath(path, 'members'), index);
+        const tag = typeof discriminator === 'string' ? discriminatedUnionTag(member, discriminator, style) : undefined;
+        if (!tag ||
+            tag[style === 'target' ? 'type' : '$type'] !== 'Literal' ||
+            tag[style === 'target' ? 'required' : '$required'] !== true) {
+            issues.push({ path: at, message: 'Each member requires one required intrinsic Literal discriminator' });
+            return;
+        }
+        const value = tag.value;
+        if (!(typeof value === 'string' ||
+            typeof value === 'boolean' ||
+            (typeof value === 'number' && Number.isFinite(value)))) {
+            issues.push({ path: at, message: 'Discriminator must be a finite string, number or boolean literal' });
+            return;
+        }
+        const key = JSON.stringify([typeof value, value]);
+        if (tags.has(key))
+            issues.push({ path: at, message: 'Union tags must be distinct typed values' });
+        tags.add(key);
+    });
+    return issues;
+}
+export function matchingDiscriminatedUnionMember(definition, value, style) {
+    if (discriminatedUnionIssues(definition, style).length || !own(value, definition.discriminator))
+        return;
+    return definition.members.find((member) => jsonEqual(discriminatedUnionTag(member, definition.discriminator, style).value, value[definition.discriminator]));
+}

package/dist/src/property-contract/index.d.ts

@@ -0,0 +1,4 @@
+export * from './json-value.js';
+export * from './date-time-value.js';
+export * from './discriminated-union.js';
+export * from './target-definition.js';

package/dist/src/property-contract/index.js

@@ -0,0 +1,9 @@
+// Pillar #4 foundation — property-contract target types + validators.
+// Dormant on `development` until downstream consumers (new extractors,
+// generation, review UI) activate them. Shape is deliberately verbatim
+// with the upstream work on feat/import-pipeline-evidence-and-reasoning
+// so the two merge without drift. See INTEG-5147 (spike) / INTEG-4927.
+export * from './json-value.js';
+export * from './date-time-value.js';
+export * from './discriminated-union.js';
+export * from './target-definition.js';

package/dist/src/property-contract/json-value.d.ts

@@ -0,0 +1,16 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface PropertyIssue {
+    path: string;
+    message: string;
+}
+export declare const own: (value: object, key: PropertyKey) => boolean;
+export declare const childPath: (path: string, key: string | number) => string;
+/** Inspect descriptors before reading values; aliases are allowed, cycles are not. */
+export declare function jsonValueIssue(value: unknown, path?: string, ancestors?: Set<object>): PropertyIssue | undefined;
+export declare function jsonEqual(left: unknown, right: unknown): boolean;
+export declare function cloneJson<T>(value: T): T;
+export declare function freezeJson<T>(value: T): Readonly<T>;
+/** Parse the entire document and reject duplicate decoded own keys. */
+export declare function parseStrictJson(text: string): unknown;

package/dist/src/property-contract/json-value.js

@@ -0,0 +1,145 @@
+export const own = (value, key) => Object.hasOwn(value, key);
+export const childPath = (path, key) => `${path}/${String(key).replace(/~/g, '~0').replace(/\//g, '~1')}`;
+/** Inspect descriptors before reading values; aliases are allowed, cycles are not. */
+export function jsonValueIssue(value, path = '', ancestors = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number')
+        return Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value))
+            ? undefined
+            : { path, message: 'Expected finite JSON-safe number' };
+    if (typeof value !== 'object')
+        return { path, message: 'Expected JSON value' };
+    if (nodeTypes?.isProxy(value))
+        return { path, message: 'Proxy is not supported JSON data' };
+    if (ancestors.has(value))
+        return { path, message: 'Cyclic JSON value' };
+    const array = Array.isArray(value);
+    const proto = Object.getPrototypeOf(value);
+    if (array && proto !== Array.prototype)
+        return { path, message: 'Custom array prototype' };
+    if (!array && proto !== Object.prototype && proto !== null)
+        return { path, message: 'Custom object prototype' };
+    ancestors.add(value);
+    try {
+        for (const key of Reflect.ownKeys(value)) {
+            if (array && key === 'length')
+                continue;
+            if (typeof key !== 'string')
+                return { path, message: 'Symbol key is not JSON' };
+            if (array && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length))
+                return { path: childPath(path, key), message: 'Extra array member' };
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor.enumerable || !own(descriptor, 'value'))
+                return { path: childPath(path, key), message: 'Expected enumerable data member' };
+            const issue = jsonValueIssue(descriptor.value, childPath(path, key), ancestors);
+            if (issue)
+                return issue;
+        }
+        if (array)
+            for (let i = 0; i < value.length; i++)
+                if (!own(value, i))
+                    return { path: childPath(path, i), message: 'Sparse array' };
+    }
+    finally {
+        ancestors.delete(value);
+    }
+    return undefined;
+}
+export function jsonEqual(left, right) {
+    if (Object.is(left, right) || left === right)
+        return true;
+    if (typeof left !== 'object' || left === null || typeof right !== 'object' || right === null)
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    const keys = Object.keys(left).sort();
+    const other = Object.keys(right).sort();
+    return (keys.length === other.length &&
+        keys.every((key, i) => key === other[i] && jsonEqual(left[key], right[key])));
+}
+export function cloneJson(value) {
+    const issue = jsonValueIssue(value);
+    if (issue)
+        throw new Error(`${issue.path}: ${issue.message}`);
+    return JSON.parse(JSON.stringify(value));
+}
+export function freezeJson(value) {
+    if (value && typeof value === 'object') {
+        for (const item of Object.values(value))
+            freezeJson(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+const nodeTypes = globalThis.process?.getBuiltinModule?.('node:util')?.types;
+/** Parse the entire document and reject duplicate decoded own keys. */
+export function parseStrictJson(text) {
+    const parsed = JSON.parse(text);
+    let cursor = 0;
+    const whitespace = () => {
+        while (/\s/.test(text[cursor] ?? '') && cursor < text.length)
+            cursor++;
+    };
+    const string = () => {
+        const start = cursor++;
+        while (cursor < text.length) {
+            const char = text[cursor++];
+            if (char === '\\')
+                cursor++;
+            else if (char === '"')
+                return JSON.parse(text.slice(start, cursor));
+        }
+        throw new Error('Unterminated JSON string');
+    };
+    const value = () => {
+        whitespace();
+        if (text[cursor] === '{') {
+            cursor++;
+            whitespace();
+            const keys = new Set();
+            if (text[cursor] === '}') {
+                cursor++;
+                return;
+            }
+            while (cursor < text.length) {
+                whitespace();
+                const key = string();
+                if (keys.has(key))
+                    throw new Error('Duplicate JSON object key');
+                keys.add(key);
+                whitespace();
+                cursor++;
+                value();
+                whitespace();
+                if (text[cursor++] === '}')
+                    return;
+            }
+        }
+        else if (text[cursor] === '[') {
+            cursor++;
+            whitespace();
+            if (text[cursor] === ']') {
+                cursor++;
+                return;
+            }
+            while (cursor < text.length) {
+                value();
+                whitespace();
+                if (text[cursor++] === ']')
+                    return;
+            }
+        }
+        else if (text[cursor] === '"')
+            string();
+        else {
+            while (cursor < text.length && !/[\s,}\]]/.test(text[cursor]))
+                cursor++;
+        }
+    };
+    value();
+    const issue = jsonValueIssue(parsed);
+    if (issue)
+        throw new Error(`${issue.path}: ${issue.message}`);
+    return parsed;
+}

package/dist/src/property-contract/target-definition.d.ts

@@ -0,0 +1,166 @@
+import { type JsonValue, type PropertyIssue } from './json-value.js';
+export declare const TARGET_PROPERTY_TYPES: readonly ["String", "Number", "Boolean", "Array", "Record", "Integer", "DateTime", "RichText", "JSON", "ResourceLink", "Literal", "DiscriminatedUnion"];
+export type TargetPropertyType = (typeof TARGET_PROPERTY_TYPES)[number];
+export declare const SAME_SPACE_RESOURCE_SOURCE = "crn:contentful:::content:spaces/$self/environments/$self";
+export type AllowedResourceDefinition = {
+    type: 'Contentful:Entry';
+    source: typeof SAME_SPACE_RESOURCE_SOURCE;
+    allowedTypes: string[];
+} | {
+    type: 'Contentful:Asset';
+    source: typeof SAME_SPACE_RESOURCE_SOURCE;
+};
+export interface TargetDefinition {
+    type: TargetPropertyType;
+    id?: string;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    values?: JsonValue[];
+    defaultValue?: JsonValue;
+    items?: TargetDefinition;
+    fields?: Record<string, TargetDefinition>;
+    allowedResources?: AllowedResourceDefinition[];
+    value?: JsonValue;
+    valueType?: TargetDefinition;
+    discriminator?: string;
+    members?: TargetDefinition[];
+}
+export interface DefinitionValidation {
+    valid: boolean;
+    issues: PropertyIssue[];
+}
+export declare function containsTargetDefinitionType(definition: TargetDefinition, type: TargetPropertyType): boolean;
+export declare function validateTargetValue(definition: TargetDefinition, value: JsonValue, path?: string): PropertyIssue[];
+export declare function validateTargetDefinition(input: unknown): DefinitionValidation;
+/** Portable structure only; runtime validation checks default/domain semantics. */
+export declare const targetDefinitionJsonSchema: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $ref: "#/definitions/target";
+    readonly definitions: {
+        readonly target: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly enum: readonly ["String", "Number", "Boolean", "Array", "Record", "Integer", "DateTime", "RichText", "JSON", "ResourceLink", "Literal", "DiscriminatedUnion"];
+                };
+                readonly id: {
+                    readonly type: "string";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+                readonly required: {
+                    readonly type: "boolean";
+                };
+                readonly values: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                };
+                readonly defaultValue: {};
+                readonly items: {
+                    readonly $ref: "#/definitions/target";
+                };
+                readonly fields: {
+                    readonly type: "object";
+                    readonly minProperties: 1;
+                    readonly additionalProperties: {
+                        readonly $ref: "#/definitions/target";
+                    };
+                };
+                readonly allowedResources: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["type", "source"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly enum: readonly ["Contentful:Entry", "Contentful:Asset"];
+                            };
+                            readonly source: {
+                                readonly const: "crn:contentful:::content:spaces/$self/environments/$self";
+                            };
+                            readonly allowedTypes: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly allOf: readonly [{
+                            readonly if: {
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly const: "Contentful:Entry";
+                                    };
+                                };
+                            };
+                            readonly then: {
+                                readonly required: readonly ["allowedTypes"];
+                            };
+                            readonly else: {
+                                readonly not: {
+                                    readonly required: readonly ["allowedTypes"];
+                                };
+                            };
+                        }];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly value: {};
+                readonly valueType: {
+                    readonly $ref: "#/definitions/target";
+                };
+                readonly discriminator: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly members: {
+                    readonly type: "array";
+                    readonly minItems: 2;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/target";
+                        }, {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly type: {
+                                    readonly const: "Record";
+                                };
+                            };
+                            readonly required: readonly ["type", "fields"];
+                        }];
+                    };
+                };
+            };
+            readonly allOf: readonly [{
+                readonly if: {
+                    readonly properties: {
+                        readonly type: {
+                            readonly const: "DiscriminatedUnion";
+                        };
+                    };
+                };
+                readonly then: {
+                    readonly required: readonly ["discriminator", "members"];
+                };
+                readonly else: {
+                    readonly not: {
+                        readonly anyOf: readonly [{
+                            readonly required: readonly ["discriminator"];
+                        }, {
+                            readonly required: readonly ["members"];
+                        }];
+                    };
+                };
+            }];
+            readonly additionalProperties: false;
+        };
+    };
+};

package/dist/src/property-contract/target-definition.js

@@ -0,0 +1,246 @@
+import { childPath, jsonEqual, jsonValueIssue, own } from './json-value.js';
+import { isDateTimeValue } from './date-time-value.js';
+import { discriminatedUnionIssues, matchingDiscriminatedUnionMember } from './discriminated-union.js';
+export const TARGET_PROPERTY_TYPES = [
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Record',
+    'Integer',
+    'DateTime',
+    'RichText',
+    'JSON',
+    'ResourceLink',
+    'Literal',
+    'DiscriminatedUnion',
+];
+export const SAME_SPACE_RESOURCE_SOURCE = 'crn:contentful:::content:spaces/$self/environments/$self';
+export function containsTargetDefinitionType(definition, type) {
+    return (definition.type === type ||
+        (definition.items !== undefined && containsTargetDefinitionType(definition.items, type)) ||
+        (definition.valueType !== undefined && containsTargetDefinitionType(definition.valueType, type)) ||
+        Object.values(definition.fields ?? {}).some((field) => containsTargetDefinitionType(field, type)) ||
+        (definition.members ?? []).some((member) => containsTargetDefinitionType(member, type)));
+}
+export function validateTargetValue(definition, value, path = '') {
+    const fail = (message) => [{ path, message }];
+    const { type } = definition;
+    if (definition.values && !definition.values.some((allowed) => jsonEqual(allowed, value)))
+        return fail('Value outside declared domain');
+    if (type === 'String' || type === 'DateTime') {
+        if (typeof value !== 'string')
+            return fail('Expected string');
+        if (type === 'DateTime' && !isDateTimeValue(value))
+            return fail('Expected timezone-qualified ISO datetime');
+    }
+    else if (type === 'Number' || type === 'Integer') {
+        if (typeof value !== 'number' || !Number.isFinite(value) || (type === 'Integer' && !Number.isSafeInteger(value)))
+            return fail(type === 'Integer' ? 'Expected safe integer' : 'Expected finite number');
+    }
+    else if (type === 'Boolean') {
+        if (typeof value !== 'boolean')
+            return fail('Expected boolean');
+    }
+    else if (type === 'Array') {
+        if (!Array.isArray(value))
+            return fail('Expected array');
+        return value.flatMap((item, i) => validateTargetValue(definition.items, item, childPath(path, i)));
+    }
+    else if (type === 'Record') {
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            return fail('Expected record');
+        const issues = [];
+        for (const key of Object.keys(value))
+            if (!own(definition.fields, key))
+                issues.push({ path: childPath(path, key), message: 'Unknown field' });
+        for (const [key, field] of Object.entries(definition.fields)) {
+            if (!own(value, key)) {
+                if (field.required)
+                    issues.push({ path: childPath(path, key), message: 'Required field missing' });
+            }
+            else
+                issues.push(...validateTargetValue(field, value[key], childPath(path, key)));
+        }
+        return issues;
+    }
+    else if (type === 'DiscriminatedUnion') {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return fail('Expected union record');
+        const member = matchingDiscriminatedUnionMember(definition, value, 'target');
+        return member
+            ? validateTargetValue(member, value, path)
+            : fail('Union value requires an exact matching discriminator tag');
+    }
+    else if (type === 'Literal') {
+        if (!jsonEqual(value, definition.value))
+            return fail('Default must equal intrinsic literal');
+        return validateTargetValue(definition.valueType, value, path);
+    }
+    if (definition.values && !definition.values.some((allowed) => jsonEqual(allowed, value)))
+        return fail('Value outside declared domain');
+    return [];
+}
+export function validateTargetDefinition(input) {
+    const jsonIssue = jsonValueIssue(input);
+    if (jsonIssue)
+        return { valid: false, issues: [jsonIssue] };
+    const issues = [];
+    const walk = (value, path, depth) => {
+        if (depth > 64) {
+            issues.push({ path, message: 'Definition depth exceeds 64' });
+            return;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            issues.push({ path, message: 'Expected target definition' });
+            return;
+        }
+        const d = value;
+        const add = (key, message) => issues.push({ path: childPath(path, key), message });
+        if (!TARGET_PROPERTY_TYPES.includes(d.type)) {
+            add('type', 'Unknown target type');
+            return;
+        }
+        const allowed = new Set(['type', 'id', 'name', 'description', 'required', 'values', 'defaultValue']);
+        if (d.type === 'Array')
+            allowed.add('items');
+        if (d.type === 'Record')
+            allowed.add('fields');
+        if (d.type === 'DiscriminatedUnion') {
+            allowed.add('discriminator');
+            allowed.add('members');
+        }
+        if (d.type === 'ResourceLink')
+            allowed.add('allowedResources');
+        if (d.type === 'Literal') {
+            allowed.add('value');
+            allowed.add('valueType');
+        }
+        for (const key of Object.keys(d))
+            if (!allowed.has(key))
+                add(key, 'Unexpected target metadata');
+        for (const key of ['id', 'name', 'description'])
+            if (own(d, key) && typeof d[key] !== 'string')
+                add(key, 'Expected string');
+        if (own(d, 'required') && typeof d.required !== 'boolean')
+            add('required', 'Expected boolean');
+        const before = issues.length;
+        if (d.type === 'DiscriminatedUnion') {
+            issues.push(...discriminatedUnionIssues(d, 'target', path));
+            if (Array.isArray(d.members))
+                d.members.forEach((member, index) => walk(member, childPath(childPath(path, 'members'), index), depth + 1));
+        }
+        if (d.type === 'Array')
+            walk(d.items, childPath(path, 'items'), depth + 1);
+        if (d.type === 'Record') {
+            if (!d.fields || typeof d.fields !== 'object' || Array.isArray(d.fields) || Object.keys(d.fields).length === 0)
+                add('fields', 'Expected nonempty field dictionary');
+            else
+                for (const [key, field] of Object.entries(d.fields))
+                    walk(field, childPath(childPath(path, 'fields'), key), depth + 1);
+        }
+        if (d.type === 'ResourceLink') {
+            if (!Array.isArray(d.allowedResources) || d.allowedResources.length === 0)
+                add('allowedResources', 'Expected same-space Entry/Asset resources');
+            else
+                d.allowedResources.forEach((r, i) => {
+                    if (!r ||
+                        !['Contentful:Entry', 'Contentful:Asset'].includes(r.type) ||
+                        r.source !== SAME_SPACE_RESOURCE_SOURCE ||
+                        Object.keys(r).some((key) => !['type', 'source', ...(r.type === 'Contentful:Entry' ? ['allowedTypes'] : [])].includes(key)) ||
+                        (r.type === 'Contentful:Entry' &&
+                            (!Array.isArray(r.allowedTypes) || !r.allowedTypes.every((type) => typeof type === 'string'))))
+                        add(`allowedResources/${i}`, 'Expected same-space Entry/Asset resource');
+                });
+        }
+        if (d.type === 'Literal') {
+            if (!own(d, 'value'))
+                add('value', 'Intrinsic literal missing');
+            walk(d.valueType, childPath(path, 'valueType'), depth + 1);
+        }
+        if (own(d, 'values') && (!Array.isArray(d.values) || d.values.length === 0))
+            add('values', 'Expected nonempty declared domain');
+        if (issues.length !== before)
+            return;
+        if (d.values) {
+            const withoutDomain = { ...d };
+            delete withoutDomain.values;
+            d.values.forEach((v, i) => issues.push(...validateTargetValue(withoutDomain, v, childPath(childPath(path, 'values'), i))));
+        }
+        if (d.type === 'Literal' && own(d, 'value'))
+            issues.push(...validateTargetValue(d.valueType, d.value, childPath(path, 'value')));
+        if (own(d, 'defaultValue')) {
+            if (d.type === 'RichText' || d.type === 'JSON')
+                add('defaultValue', 'Target does not support defaults');
+            else
+                issues.push(...validateTargetValue(d, d.defaultValue, childPath(path, 'defaultValue')));
+        }
+    };
+    walk(input, '', 0);
+    return { valid: issues.length === 0, issues };
+}
+/** Portable structure only; runtime validation checks default/domain semantics. */
+export const targetDefinitionJsonSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $ref: '#/definitions/target',
+    definitions: {
+        target: {
+            type: 'object',
+            required: ['type'],
+            properties: {
+                type: { enum: [...TARGET_PROPERTY_TYPES] },
+                id: { type: 'string' },
+                name: { type: 'string' },
+                description: { type: 'string' },
+                required: { type: 'boolean' },
+                values: { type: 'array', minItems: 1 },
+                defaultValue: {},
+                items: { $ref: '#/definitions/target' },
+                fields: { type: 'object', minProperties: 1, additionalProperties: { $ref: '#/definitions/target' } },
+                allowedResources: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        required: ['type', 'source'],
+                        properties: {
+                            type: { enum: ['Contentful:Entry', 'Contentful:Asset'] },
+                            source: { const: SAME_SPACE_RESOURCE_SOURCE },
+                            allowedTypes: { type: 'array', items: { type: 'string' } },
+                        },
+                        allOf: [
+                            {
+                                if: { properties: { type: { const: 'Contentful:Entry' } } },
+                                then: { required: ['allowedTypes'] },
+                                else: { not: { required: ['allowedTypes'] } },
+                            },
+                        ],
+                        additionalProperties: false,
+                    },
+                },
+                value: {},
+                valueType: { $ref: '#/definitions/target' },
+                discriminator: { type: 'string', minLength: 1 },
+                members: {
+                    type: 'array',
+                    minItems: 2,
+                    uniqueItems: true,
+                    items: {
+                        allOf: [
+                            { $ref: '#/definitions/target' },
+                            { type: 'object', properties: { type: { const: 'Record' } }, required: ['type', 'fields'] },
+                        ],
+                    },
+                },
+            },
+            allOf: [
+                {
+                    if: { properties: { type: { const: 'DiscriminatedUnion' } } },
+                    then: { required: ['discriminator', 'members'] },
+                    else: { not: { anyOf: [{ required: ['discriminator'] }, { required: ['members'] }] } },
+                },
+            ],
+            additionalProperties: false,
+        },
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-types",
-  "version": "2.39.1",
+  "version": "2.40.0",
   "license": "MIT",
   "type": "module",
   "module": "./dist/src/index.js",