@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

package/lib/models/__tests__/Schema.test.js

@@ -0,0 +1,1395 @@
+import { parseYaml } from '@redocly/openapi-core';
+import { outdent } from 'outdent';
+import { getMediaType } from '../mediaType.js';
+import { getField } from '../field.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+import { enumDetailsPrinter, printSchema } from './helpers.js';
+import { getSchema } from '../schema.js';
+// Fixture imports
+import nestedEnumDescriptionSpec from './fixtures/nestedEnumDescroptionSample.json';
+import discriminatorSpec from './fixtures/discriminator.json';
+import discriminatorWithDefaultMappingSpec from './fixtures/discriminator-with-default-mapping.json';
+import discriminatorDefaultOnlySpec from './fixtures/discriminator-default-only.json';
+import discriminatorOrderedWithDefaultSpec from './fixtures/discriminator-ordered-with-default.json';
+import oneOfTitlesSpec from './fixtures/oneOfTitles.json';
+import conditionalSchemaSpec from './fixtures/3.1/conditionalSchema.json';
+import conditionalFieldSpec from './fixtures/3.1/conditionalField.json';
+import patternPropertiesSpec from './fixtures/3.1/patternProperties.json';
+import prefixItemsSpec from './fixtures/3.1/prefixItems.json';
+import arrayItemsSpec from './fixtures/arrayItems.json';
+import fieldsSpec from './fixtures/fields.json';
+// Map for test.each fixtures
+const fixtureMap = {
+    './fixtures/3.1/prefixItems.json': prefixItemsSpec,
+    './fixtures/arrayItems.json': arrayItemsSpec,
+};
+const options = normalizeOptions({});
+const deps = { operation: { pointer: 'testSchema' } };
+describe('Models', () => {
+    describe('Schema', () => {
+        let parser;
+        test('parsing nested x-enumDescription', () => {
+            const spec = nestedEnumDescriptionSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const testSchema = spec.components?.schemas?.Test;
+            const schemaModel = getSchema({
+                parser,
+                schemaOrRef: testSchema,
+                pointer: '',
+                options,
+                deps,
+            });
+            // items with their own description render as a nested row which keeps the enum info
+            expect(schemaModel['x-enumDescriptions']).toBeUndefined();
+            expect(schemaModel.items?.['x-enumDescriptions']).toStrictEqual(testSchema?.items?.['x-enumDescriptions']);
+            expect(schemaModel.items?.enum).toEqual(testSchema?.items?.enum);
+            expect(schemaModel.isPrimitive).toBe(false);
+        });
+        test('discriminator with one field', () => {
+            const spec = discriminatorSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.Foo,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(1);
+            expect(schema.discriminatorProp).toEqual('type');
+        });
+        test('discriminator with defaultMapping adds it as last item', () => {
+            const spec = discriminatorWithDefaultMappingSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.Pet,
+                pointer: '#/components/schemas/Pet',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(3);
+            expect(schema.oneOf?.[0].isDefaultMapping).toBe(false);
+            expect(schema.oneOf?.[0].title).toBe('cat');
+            expect(schema.oneOf?.[1].isDefaultMapping).toBe(false);
+            expect(schema.oneOf?.[1].title).toBe('dog');
+            expect(schema.oneOf?.[2].isDefaultMapping).toBe(true);
+            expect(schema.oneOf?.[2].title).toBe('Default mapping');
+        });
+        test('discriminator with only defaultMapping (no mapping)', () => {
+            const spec = discriminatorDefaultOnlySpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.Animal,
+                pointer: '#/components/schemas/Animal',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(1);
+            expect(schema.oneOf?.[0].isDefaultMapping).toBe(true);
+            expect(schema.oneOf?.[0].title).toBe('Default mapping');
+        });
+        test('discriminator defaultMapping order preserved after sorting', () => {
+            const spec = discriminatorOrderedWithDefaultSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.Vehicle,
+                pointer: '#/components/schemas/Vehicle',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(4);
+            expect(schema.oneOf?.[0].title).toBe('truck');
+            expect(schema.oneOf?.[1].title).toBe('bike');
+            expect(schema.oneOf?.[2].title).toBe('car');
+            expect(schema.oneOf?.[3].title).toBe('Default mapping');
+            expect(schema.oneOf?.[3].isDefaultMapping).toBe(true);
+        });
+        test('oneOf/allOf titles', () => {
+            const spec = oneOfTitlesSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Test,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.fields).toHaveLength(3);
+            const anyOfField = schema.fields?.[0];
+            const oneOfField = schema.fields?.[1];
+            expect(anyOfField?.schema.displayType).toMatchInlineSnapshot(`"Foo (object) or Bar (object) or Base (object) or SpecificBase (object) or SpecificBase2 (object)"`);
+            expect(anyOfField?.schema.oneOf?.[0].title).toBe('Foo');
+            expect(anyOfField?.schema.oneOf?.[1].title).toBe('Bar');
+            expect(anyOfField?.schema.oneOf?.[2].title).toBe('Base');
+            expect(anyOfField?.schema.oneOf?.[3].title).toBe('SpecificBase');
+            expect(anyOfField?.schema.oneOf?.[4].title).toBe('SpecificBase2');
+            expect(oneOfField?.schema.displayType).toMatchInlineSnapshot(`"Foo (object) or Bar (object) or Base (object) or SpecificBase (object) or SpecificBase2 (object)"`);
+            expect(oneOfField?.schema.oneOf?.[0].title).toBe('Foo');
+            expect(oneOfField?.schema.oneOf?.[1].title).toBe('Bar');
+            expect(oneOfField?.schema.oneOf?.[2].title).toBe('Base');
+            expect(oneOfField?.schema.oneOf?.[3].title).toBe('SpecificBase');
+            expect(oneOfField?.schema.oneOf?.[4].title).toBe('SpecificBase2');
+        });
+        test('oneOf/allOf titles with hideSchemaTitles', () => {
+            const spec = oneOfTitlesSpec;
+            const options = normalizeOptions({
+                hideSchemaTitles: true,
+            });
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Test,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.fields).toHaveLength(3);
+            const anyOfField = schema.fields?.[0];
+            const oneOfField = schema.fields?.[1];
+            expect(anyOfField?.schema.displayType).toMatchInlineSnapshot(`"object"`);
+            expect(anyOfField?.schema.oneOf?.[0].title).toBe('Foo');
+            expect(anyOfField?.schema.oneOf?.[1].title).toBe('Bar');
+            expect(anyOfField?.schema.oneOf?.[2].title).toBe('Base');
+            expect(anyOfField?.schema.oneOf?.[3].title).toBe('SpecificBase');
+            expect(anyOfField?.schema.oneOf?.[4].title).toBe('SpecificBase2');
+            expect(oneOfField?.schema.displayType).toMatchInlineSnapshot(`"object"`);
+            expect(oneOfField?.schema.oneOf?.[0].title).toBe('Foo');
+            expect(oneOfField?.schema.oneOf?.[1].title).toBe('Bar');
+            expect(oneOfField?.schema.oneOf?.[2].title).toBe('Base');
+            expect(oneOfField?.schema.oneOf?.[3].title).toBe('SpecificBase');
+            expect(oneOfField?.schema.oneOf?.[4].title).toBe('SpecificBase2');
+        });
+        test('oneOf/allOf schema complex displayType', () => {
+            const spec = oneOfTitlesSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.WithArray,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(2);
+            expect(schema.displayType).toBe('(Array of strings or numbers) or string');
+        });
+        test('oneOf/anyOf with pure $ref should NOT be marked as circular', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.1.0
+        components:
+          schemas:
+            ContactObject:
+              type: object
+              properties:
+                firstName:
+                  type: string
+                lastName:
+                  type: string
+            Customer:
+              type: object
+              properties:
+                primaryAddressOneOf:
+                  description: Customer's primary address
+                  oneOf:
+                    - $ref: '#/components/schemas/ContactObject'
+                    - type: 'null'
+                primaryAddressAnyOf:
+                  description: Customer's primary address
+                  anyOf:
+                    - $ref: '#/components/schemas/ContactObject'
+                    - type: 'null'
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Customer,
+                pointer: '#/components/schemas/Customer',
+                options,
+                deps,
+            });
+            expect(schema.isCircular).toBe(false);
+            const oneOfField = schema.fields?.find((f) => f.name === 'primaryAddressOneOf');
+            expect(oneOfField).toBeDefined();
+            expect(oneOfField?.schema.oneOf).toBeDefined();
+            expect(oneOfField?.schema.oneOf?.length).toBe(2);
+            oneOfField?.schema.oneOf?.forEach((variant) => {
+                expect(variant.isCircular).toBe(false);
+            });
+            const anyOfField = schema.fields?.find((f) => f.name === 'primaryAddressAnyOf');
+            expect(anyOfField).toBeDefined();
+            expect(anyOfField?.schema.oneOf).toBeDefined();
+            expect(anyOfField?.schema.oneOf?.length).toBe(2);
+            anyOfField?.schema.oneOf?.forEach((variant) => {
+                expect(variant.isCircular).toBe(false);
+            });
+        });
+        test('oneOf/anyOf with circular reference should be detected', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.1.0
+        components:
+          schemas:
+            TreeNode:
+              type: object
+              properties:
+                value:
+                  type: string
+                nextOneOf:
+                  oneOf:
+                    - $ref: '#/components/schemas/TreeNode'
+                    - type: 'null'
+                nextAnyOf:
+                  anyOf:
+                    - $ref: '#/components/schemas/TreeNode'
+                    - type: 'null'
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.TreeNode,
+                pointer: '#/components/schemas/TreeNode',
+                options,
+                deps,
+            });
+            const oneOfField = schema.fields?.find((f) => f.name === 'nextOneOf');
+            expect(oneOfField).toBeDefined();
+            expect(oneOfField?.schema.oneOf).toBeDefined();
+            const oneOfCircularVariant = oneOfField?.schema.oneOf?.find((v) => v.isCircular);
+            expect(oneOfCircularVariant).toBeDefined();
+            const anyOfField = schema.fields?.find((f) => f.name === 'nextAnyOf');
+            expect(anyOfField).toBeDefined();
+            expect(anyOfField?.schema.oneOf).toBeDefined();
+            const anyOfCircularVariant = anyOfField?.schema.oneOf?.find((v) => v.isCircular);
+            expect(anyOfCircularVariant).toBeDefined();
+        });
+        test('schemaDefinition should resolve schema with conditional operators', () => {
+            const spec = conditionalSchemaSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Test,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toHaveLength(2);
+            expect(schema.oneOf?.[0].schema.title).toBe('=== 10');
+            expect(schema.oneOf?.[1].schema.title).toBe('case 2');
+            expect(schema.oneOf?.[0].schema).toMatchSnapshot();
+            expect(schema.oneOf?.[1].schema).toMatchSnapshot();
+        });
+        test('schemaDefinition should resolve field with conditional operators', () => {
+            const spec = conditionalFieldSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Test,
+                pointer: '',
+                options,
+                deps,
+            });
+            expect(schema.fields).toHaveLength(1);
+            expect(schema.fields && schema.fields[0].schema.oneOf).toHaveLength(2);
+            expect(schema.fields && schema.fields[0].schema.oneOf?.[0].schema.title).toBe('isString');
+            expect(schema.fields && schema.fields[0].schema.oneOf?.[1].schema.title).toBe('notString');
+            expect(schema.fields && schema.fields[0].schema.oneOf?.[0].schema).toMatchSnapshot();
+            expect(schema.fields && schema.fields[0].schema.oneOf?.[1].schema).toMatchSnapshot();
+        });
+        test('schemaDefinition should resolve patternProperties', () => {
+            vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const spec = patternPropertiesSpec;
+            parser = new OpenAPIParser(spec, undefined, {
+                ...options,
+                sortRequiredPropsFirst: true,
+            });
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.Patterns,
+                pointer: '',
+                options: {
+                    ...options,
+                    sortRequiredPropsFirst: true,
+                },
+                deps,
+            });
+            expect(schema.fields).toHaveLength(5);
+            expect(schema.fields?.[0].kind).toEqual('field');
+            expect(schema.fields?.[0].name).toEqual('nestedObjectProp');
+            expect(schema.fields?.[0].schema.fields?.[0].kind).toEqual('patternProperties');
+            expect(schema.fields?.[1].kind).toEqual('field');
+            expect(schema.fields?.[1].name).toEqual('nestedArrayProp');
+            expect(schema.fields?.[1].schema.type).toEqual('array');
+            expect(schema.fields?.[1].schema.items?.fields?.[0].kind).toEqual('patternProperties');
+            expect(schema.fields?.[2].kind).toEqual('patternProperties');
+            expect(schema.fields?.[2].schema.type).toEqual('string');
+            expect(schema.fields?.[3].kind).toEqual('patternProperties');
+            expect(schema.fields?.[3].schema.type).toEqual('object');
+            expect(schema.fields?.[4].kind).toEqual('patternProperties');
+            expect(schema.fields?.[4].schema.type).toEqual('any');
+        });
+        describe('type array', () => {
+            function testImmutablePart(schema) {
+                expect(schema.minItems).toEqual(1);
+                expect(schema.maxItems).toEqual(10);
+                expect(schema.fields?.[0].schema.type).toEqual('string');
+                expect(schema.fields?.[1].schema.type).toEqual('number');
+            }
+            const eachArray = ['./fixtures/3.1/prefixItems.json', './fixtures/arrayItems.json'];
+            test.each(eachArray)('schemaDefinition should resolve prefixItems without additional items', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case1,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                testImmutablePart(schema);
+                expect(schema.fields).toHaveLength(3);
+                expect(schema.fields?.[2].name).toEqual('[2]');
+                expect(schema.fields?.[2].schema.pointer).toEqual('#/components/schemas/Cat');
+                expect(schema.fields?.[2].schema.type).toEqual('object');
+            });
+            test.each(eachArray)('schemaDefinition should resolve prefixItems with additional items', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case2,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                testImmutablePart(schema);
+                expect(schema.fields).toHaveLength(4);
+                expect(schema.fields?.[3].name).toEqual('[3...]');
+                expect(schema.fields?.[2].schema.type).toEqual('object');
+                expect(schema.fields?.[2].schema.pointer).toEqual('#/components/schemas/Cat');
+                expect(schema.fields?.[3].schema.type).toEqual('any');
+            });
+            test.each(eachArray)('schemaDefinition should resolve prefixItems with additional items with $ref', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case3,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                testImmutablePart(schema);
+                expect(schema.fields).toHaveLength(4);
+                expect(schema.fields?.[3].name).toEqual('[3...]');
+                expect(schema.fields?.[2].schema.type).toEqual('object');
+                expect(schema.fields?.[2].schema.pointer).toEqual('#/components/schemas/Cat');
+                expect(schema.fields?.[3].schema.type).toEqual('object');
+                expect(schema.fields?.[3].schema.pointer).toEqual('#/components/schemas/Dog');
+            });
+            test.each(eachArray)('schemaDefinition should resolve prefixItems with additional schema items', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case4,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                testImmutablePart(schema);
+                expect(schema.fields).toHaveLength(4);
+                expect(schema.fields?.[3].name).toEqual('[3...]');
+                expect(schema.fields?.[2].schema.type).toEqual('object');
+                expect(schema.fields?.[2].schema.pointer).toEqual('#/components/schemas/Cat');
+                expect(schema.fields?.[3].schema.type).toEqual('object');
+            });
+            test.each(eachArray)('schemaDefinition should resolve prefixItems with additional array items', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case5,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                testImmutablePart(schema);
+                expect(schema.fields).toHaveLength(4);
+                expect(schema.fields?.[3].name).toEqual('[3...]');
+                expect(schema.fields?.[2].schema.type).toEqual('object');
+                expect(schema.fields?.[2].schema.pointer).toEqual('#/components/schemas/Cat');
+                expect(schema.fields?.[3].schema.type).toEqual('array');
+                expect(schema.fields?.[3].schema.fields).toHaveLength(1);
+                expect(schema.fields?.[3].schema.fields?.[0].schema.type).toEqual('string');
+                expect(schema.fields?.[3].schema.fields?.[0].schema.constraints).toEqual([
+                    '>= 0 characters',
+                ]);
+            });
+            test.each(eachArray)('schemaDefinition should resolve prefixItems with additional array items', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case6,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                expect(schema.type).toBe('array');
+                expect(schema.typePrefix).toBe('Array of ');
+                expect(schema.items?.fields).toHaveLength(2);
+                expect(schema.items?.pointer).toEqual('#/components/schemas/Tag');
+                expect(schema.isPrimitive).toBe(false);
+                expect(schema.items?.isPrimitive).toBe(false);
+                expect(schema.minItems).toBe(1);
+            });
+            test.each(eachArray)('schemaDefinition should resolve items with boolean type', (specFixture) => {
+                const spec = fixtureMap[specFixture];
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Case7,
+                    pointer: '',
+                    options,
+                    deps,
+                });
+                expect(schema.fields?.[0].schema?.type).toBe('array');
+                expect(schema.fields?.[0].schema?.typePrefix).toBe('Array of ');
+                expect(schema.fields?.[0].schema.items?.displayType).toBe('any');
+                expect(schema?.fields).toHaveLength(1);
+                expect(schema.fields?.[0].schema.pointer).toEqual('#/components/schemas/AnyArray');
+                expect(schema.fields?.[0].schema.isPrimitive).toBe(true);
+            });
+        });
+        describe('array items info', () => {
+            const specWithRefItems = parseYaml(outdent `
+        openapi: 3.1.0
+        components:
+          schemas:
+            Collection:
+              type: object
+              required:
+                - owners
+              properties:
+                owners:
+                  type: array
+                  minItems: 1
+                  maxItems: 20
+                  description: List of groups which have write and read privileges over the collection.
+                  items:
+                    $ref: '#/components/schemas/AclGroup'
+                viewers:
+                  type: array
+                  items:
+                    $ref: '#/components/schemas/AclGroup'
+            AclGroup:
+              type: string
+              format: email
+              maxLength: 256
+              pattern: ^[a-zA-Z0-9_+&*-]+@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$
+              description: OSDU Access Control List (ACL) group that controls data access.
+      `);
+            function getCollectionSchema() {
+                const parser = new OpenAPIParser(specWithRefItems, undefined, options);
+                return getSchema({
+                    parser,
+                    schemaOrRef: specWithRefItems.components?.schemas?.Collection,
+                    pointer: '#/components/schemas/Collection',
+                    options,
+                    deps,
+                });
+            }
+            test('should keep only array-level info on the array schema and items info on the nested items schema', () => {
+                const schema = getCollectionSchema();
+                const owners = schema.fields?.find((f) => f.name === 'owners');
+                expect(owners?.schema.type).toEqual('array');
+                // the array row keeps only its own info
+                expect(owners?.schema.pattern).toBeUndefined();
+                expect(owners?.schema.format).toBeUndefined();
+                expect(owners?.schema.displayFormat).toBeFalsy();
+                expect(owners?.schema.title).toEqual('');
+                expect(owners?.schema.constraints).toEqual(['[ 1 .. 20 ] items']);
+                expect(owners?.schema.description).toEqual('List of groups which have write and read privileges over the collection.');
+                expect(owners?.description).toEqual('List of groups which have write and read privileges over the collection.');
+                // items with their own documentation make the array expandable
+                expect(owners?.schema.isPrimitive).toBe(false);
+                // the items info is rendered in the nested items row
+                expect(owners?.schema.items?.title).toEqual('AclGroup');
+                expect(owners?.schema.items?.pattern).toEqual('^[a-zA-Z0-9_+&*-]+@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$');
+                expect(owners?.schema.items?.format).toEqual('email');
+                expect(owners?.schema.items?.constraints).toEqual(['<= 256 characters']);
+                expect(owners?.schema.items?.description).toEqual('OSDU Access Control List (ACL) group that controls data access.');
+            });
+            test('array with no own description shows the items description only in the nested items row', () => {
+                const schema = getCollectionSchema();
+                const viewers = schema.fields?.find((f) => f.name === 'viewers');
+                expect(viewers?.schema.description).toEqual('');
+                expect(viewers?.description).toEqual('');
+                expect(viewers?.schema.constraints).toEqual([]);
+                expect(viewers?.schema.isPrimitive).toBe(false);
+                expect(viewers?.schema.items?.description).toEqual('OSDU Access Control List (ACL) group that controls data access.');
+                expect(viewers?.schema.items?.constraints).toEqual(['<= 256 characters']);
+            });
+            test('should keep the array own info when inline items have no extra info', () => {
+                const spec = parseYaml(outdent `
+          openapi: 3.1.0
+          components:
+            schemas:
+              Tags:
+                type: array
+                minItems: 1
+                description: List of tags.
+                items:
+                  type: string
+        `);
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Tags,
+                    pointer: '#/components/schemas/Tags',
+                    options,
+                    deps,
+                });
+                expect(schema.description).toEqual('List of tags.');
+                expect(schema.pattern).toBeUndefined();
+                expect(schema.format).toBeUndefined();
+                expect(schema.constraints).toEqual(['non-empty']);
+                // trivial items stay flattened into the array row
+                expect(schema.isPrimitive).toBe(true);
+            });
+            test('$ref sibling description should win over the referenced items description', () => {
+                const spec = parseYaml(outdent `
+          openapi: 3.1.0
+          components:
+            schemas:
+              Owners:
+                type: array
+                description: Description for property.
+                items:
+                  $ref: '#/components/schemas/AclGroup'
+                  description: Sibling description for items.
+              AclGroup:
+                type: string
+                maxLength: 256
+                description: OSDU Access Control List (ACL) group that controls data access.
+        `);
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Owners,
+                    pointer: '#/components/schemas/Owners',
+                    options,
+                    deps,
+                });
+                expect(schema.description).toEqual('Description for property.');
+                expect(schema.items?.description).toEqual('Sibling description for items.');
+            });
+            test('$ref sibling description should win over the referenced items pre-parsed markdown description', () => {
+                // simulates Realm which pre-parses markdown descriptions into x-parsed-md-* extensions;
+                // plain-text descriptions (like the sibling one) are not pre-parsed
+                const spec = {
+                    openapi: '3.1.0',
+                    components: {
+                        schemas: {
+                            Owners: {
+                                type: 'array',
+                                items: {
+                                    $ref: '#/components/schemas/AclGroup',
+                                    description: 'Sibling description for items.',
+                                },
+                            },
+                            AclGroup: {
+                                type: 'string',
+                                description: 'OSDU `ACL` group.',
+                                'x-parsed-md-description': { result: 'parsed markdoc ast of the ACL description' },
+                            },
+                        },
+                    },
+                };
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Owners,
+                    pointer: '#/components/schemas/Owners',
+                    options,
+                    deps,
+                });
+                expect(schema.items?.description).toEqual('Sibling description for items.');
+            });
+            test.each([
+                ['default', { type: 'string', default: 'admin' }],
+                ['const', { type: 'string', const: 'fixed' }],
+                ['deprecated', { type: 'string', deprecated: true }],
+                ['contentEncoding', { type: 'string', contentEncoding: 'base64' }],
+            ])('items with own %s render as a nested items row', (_keyword, items) => {
+                const parser = new OpenAPIParser({ openapi: '3.1.0' }, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: { type: 'array', items },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(schema.isPrimitive).toBe(false);
+            });
+            test('items example is hoisted to the array row only when items have no own info', () => {
+                const parser = new OpenAPIParser({ openapi: '3.1.0' }, undefined, options);
+                // trivial items: the example is hoisted onto the array row
+                const flat = getSchema({
+                    parser,
+                    schemaOrRef: {
+                        type: 'array',
+                        items: { type: 'string', example: 'kuku.test' },
+                    },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(flat.example).toEqual(['kuku.test']);
+                // documented items render as a nested row which shows the example itself
+                const rich = getSchema({
+                    parser,
+                    schemaOrRef: {
+                        type: 'array',
+                        items: { type: 'string', example: 'kuku.test', description: 'Items description.' },
+                    },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(rich.example).toBeUndefined();
+                expect(rich.items?.example).toEqual('kuku.test');
+            });
+            test('object property own example wins over the parent object example entry', () => {
+                const parser = new OpenAPIParser({ openapi: '3.1.0' }, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: {
+                        type: 'object',
+                        example: { id: 1, users: [] },
+                        properties: {
+                            id: { type: 'integer' },
+                            users: {
+                                type: 'array',
+                                example: ['data.default.owners@opendes.testing.slb.com'],
+                                items: { type: 'string' },
+                            },
+                        },
+                    },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                // the parent example fills properties without their own example
+                expect(schema.fields?.find((f) => f.name === 'id')?.example).toEqual(1);
+                // but never overrides a property's own example
+                expect(schema.fields?.find((f) => f.name === 'users')?.example).toEqual([
+                    'data.default.owners@opendes.testing.slb.com',
+                ]);
+            });
+            test('tuple array example moves to the item rows when it fits the tuple length', () => {
+                const parser = new OpenAPIParser({ openapi: '3.1.0' }, undefined, options);
+                const tupleSchema = {
+                    type: 'array',
+                    example: ['first', 42],
+                    prefixItems: [{ type: 'string' }, { type: 'number' }],
+                };
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: tupleSchema,
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(schema.example).toBeUndefined();
+                expect(schema.fields?.[0].example).toEqual('first');
+                expect(schema.fields?.[1].example).toEqual(42);
+                // falsy example values are still distributed to the item rows
+                const falsyExample = getSchema({
+                    parser,
+                    schemaOrRef: {
+                        ...tupleSchema,
+                        example: [0, false],
+                        prefixItems: [{ type: 'number' }, { type: 'boolean' }],
+                    },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(falsyExample.example).toBeUndefined();
+                expect(falsyExample.fields?.[0].example).toEqual(0);
+                expect(falsyExample.fields?.[1].example).toEqual(false);
+                // an explicit empty example has no entries to distribute and stays on the array row
+                const emptyExample = getSchema({
+                    parser,
+                    schemaOrRef: { ...tupleSchema, example: [] },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(emptyExample.example).toEqual([]);
+                expect(emptyExample.fields?.[0].example).toBeUndefined();
+                // an example longer than the tuple stays on the array row so no entries are lost,
+                // and is not also distributed to the item rows
+                const longExample = getSchema({
+                    parser,
+                    schemaOrRef: {
+                        ...tupleSchema,
+                        example: ['first', 42, 'extra'],
+                    },
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(longExample.example).toEqual(['first', 42, 'extra']);
+                expect(longExample.fields?.[0].example).toBeUndefined();
+                expect(longExample.fields?.[1].example).toBeUndefined();
+            });
+            test.each([
+                // no items schema means any items are accepted
+                [{ type: 'array' }, 'Array of any'],
+                // items: false permits no items, so no item type is advertised
+                [{ type: 'array', items: false }, 'Array of items'],
+                // the parent of an items-less nested array still holds arrays
+                [{ type: 'array', items: { type: 'array' } }, 'Array of arrays'],
+            ])('array display type for %j', (schemaOrRef, expected) => {
+                const parser = new OpenAPIParser({ openapi: '3.1.0' }, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: schemaOrRef,
+                    pointer: '#/components/schemas/Test',
+                    options,
+                    deps,
+                });
+                expect(schema.typePrefix + schema.displayType).toEqual(expected);
+            });
+            test('should not hoist items info when inline items are an object (non-primitive)', () => {
+                const spec = parseYaml(outdent `
+          openapi: 3.1.0
+          components:
+            schemas:
+              Members:
+                type: array
+                minItems: 1
+                description: List of members.
+                items:
+                  type: object
+                  description: A member of the museum.
+                  maxProperties: 5
+                  properties:
+                    name:
+                      type: string
+        `);
+                const parser = new OpenAPIParser(spec, undefined, options);
+                const schema = getSchema({
+                    parser,
+                    schemaOrRef: spec.components?.schemas?.Members,
+                    pointer: '#/components/schemas/Members',
+                    options,
+                    deps,
+                });
+                expect(schema.description).toEqual('List of members.');
+                expect(schema.constraints).toEqual(['non-empty']);
+                expect(schema.items?.fields).toHaveLength(1);
+                expect(schema.items?.fields?.[0].name).toEqual('name');
+            });
+        });
+        test('content example should override the schema example on the parameter', () => {
+            const spec = fieldsSpec;
+            parser = new OpenAPIParser(spec, undefined, options);
+            const field = getField(parser, {
+                $ref: '#/components/parameters/queryParamWithContentExample',
+            }, '', options, deps);
+            expect(field.example).toEqual({ id: 'content example' });
+            const schema = getSchema({
+                parser,
+                schemaOrRef: field.schema.schema,
+                pointer: '',
+                options,
+                deps,
+            });
+            // a property's own example stays more specific than the distributed parent example
+            expect(schema.fields && schema.fields[0].example).toEqual('schema example');
+        });
+        test('should get correct fields data if it includes allOf', () => {
+            const spec = parseYaml(outdent `
+      openapi: 3.0.0
+      components:
+        schemas:
+          User:
+            allOf:
+              - type: object
+                properties:
+                  name:
+                    type: string
+                    description: correct description name
+                    readOnly: false
+                    writeOnly: false
+                  allOf:
+                    - '#/components/schemas/NameField'
+          NameField:
+            description: name description
+            readOnly: true
+            writeOnly: true
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.User,
+                pointer: '#/components/schemas/User',
+                options,
+                deps,
+            });
+            expect(schema.fields?.[0].schema?.readOnly).toBe(false);
+            expect(schema.fields?.[0].schema?.writeOnly).toBe(false);
+            expect(printSchema(schema)).toMatchInlineSnapshot(`
+        "name: <string> (correct description name)
+        allOf: <any>"
+      `);
+        });
+        test('memoizes fields so repeated access returns stable model identities', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.0.0
+        components:
+          schemas:
+            User:
+              type: object
+              properties:
+                name:
+                  type: string
+                address:
+                  type: object
+                  properties:
+                    city:
+                      type: string
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.User,
+                pointer: '#/components/schemas/User',
+                options,
+                deps,
+            });
+            // Same array and same child model instances across accesses — this is what
+            // lets React's memoization skip re-rendering unchanged subtrees.
+            expect(schema.fields).toBe(schema.fields);
+            expect(schema.fields?.[1].schema).toBe(schema.fields?.[1].schema);
+            expect(schema.fields?.[1].schema.fields).toBe(schema.fields?.[1].schema.fields);
+        });
+        test('should preserve readOnly on deep property overridden via allOf in a complex schema', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.0.0
+        components:
+          schemas:
+            ArticleType:
+              type: object
+              properties:
+                id:
+                  type: string
+                name:
+                  type: string
+            ArticleTypeForCreateEditArticle:
+              allOf:
+                - type: object
+                  required: [id]
+                  properties:
+                    name:
+                      readOnly: true
+                - $ref: '#/components/schemas/ArticleType'
+            Version:
+              type: object
+              properties:
+                id:
+                  type: string
+                articleType:
+                  $ref: '#/components/schemas/ArticleType'
+            VersionForCreateArticle:
+              allOf:
+                - type: object
+                  required: [name]
+                  properties:
+                    articleType:
+                      $ref: '#/components/schemas/ArticleTypeForCreateEditArticle'
+                - $ref: '#/components/schemas/Version'
+            Article:
+              type: object
+              properties:
+                versions:
+                  type: array
+                  items:
+                    $ref: '#/components/schemas/Version'
+            CreateArticleSchema:
+              allOf:
+                - type: object
+                  properties:
+                    versions:
+                      type: array
+                      items:
+                        $ref: '#/components/schemas/VersionForCreateArticle'
+                - $ref: '#/components/schemas/Article'
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.CreateArticleSchema,
+                pointer: '#/components/schemas/CreateArticleSchema',
+                options,
+                deps,
+            });
+            const versions = schema.fields?.find((f) => f.name === 'versions');
+            const articleType = versions?.schema.items?.fields?.find((f) => f.name === 'articleType');
+            const name = articleType?.schema.fields?.find((f) => f.name === 'name');
+            expect(name).toBeDefined();
+            expect(name?.schema.readOnly).toBe(true);
+        });
+        describe('enum values', () => {
+            test('should get correct fields enum fields without duplication', () => {
+                const spec = parseYaml(outdent `
+          openapi: 3.0.0
+          components:
+            schemas:
+              StringField: { type: string, title: StringField, enum: [A, B, C] }
+              FieldA: { type: string, title: FieldA, enum: [A1, A2, A3] }
+              FieldB: { type: string, title: FieldB, enum: [B1, B2, B3] }
+              FieldC: { type: string, title: FieldC, enum: [C1, C2, C3] }
+              ObjectWithAllOf:
+                title: StringFilter
+                type: object
+                allOf:
+                  - properties:
+                      type: { type: string, enum: [STRING] }
+                      field: { $ref: '#/components/schemas/StringField' }
+                    required: [type, field, values]
+                  - oneOf:
+                      - properties:
+                          field: { type: string, enum: [A] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldA' } }
+                      - properties:
+                          field: { type: string, enum: [B] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldB' } }
+                      - properties:
+                          field: { type: string, enum: [C] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldC' } }
+              ObjectWithOneOf:
+                title: StringFilter
+                type: object
+                properties:
+                  type: { type: string, enum: [STRING] }
+                  field: { $ref: '#/components/schemas/StringField' }
+                required: [type, field, values]
+                oneOf:
+                  - properties:
+                      field: { type: string, enum: [A] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldA' } }
+                  - properties:
+                      field: { type: string, enum: [B] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldB' } }
+                  - properties:
+                      field: { type: string, enum: [C] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldC' } }
+        `);
+                parser = new OpenAPIParser(spec, undefined, options);
+                const schemaWithOneOf = getSchema({
+                    parser,
+                    schemaOrRef: spec.components.schemas.ObjectWithOneOf,
+                    pointer: '#/components/schemas/ObjectWithOneOf',
+                    options,
+                    deps,
+                });
+                expect(printSchema(schemaWithOneOf, enumDetailsPrinter)).toMatchInlineSnapshot(`
+          "oneOf
+            StringFilter ->
+              field*: <string>enum: [A,B,C]
+              values*: [<string>enum: [A1,A2,A3]]
+              type*: <string>enum: [STRING]
+            StringFilter ->
+              field*: <string>enum: [A,B,C]
+              values*: [<string>enum: [B1,B2,B3]]
+              type*: <string>enum: [STRING]
+            StringFilter ->
+              field*: <string>enum: [A,B,C]
+              values*: [<string>enum: [C1,C2,C3]]
+              type*: <string>enum: [STRING]"
+        `);
+                const schemaWithAllOf = getSchema({
+                    parser,
+                    schemaOrRef: spec.components.schemas.ObjectWithAllOf,
+                    pointer: '#/components/schemas/ObjectWithAllOf',
+                    options,
+                    deps,
+                });
+                expect(printSchema(schemaWithAllOf, enumDetailsPrinter)).toMatchInlineSnapshot(`
+          "oneOf
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [A,B,C]
+              values*: [<string>enum: [A1,A2,A3]]
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [B,A,C]
+              values*: [<string>enum: [B1,B2,B3]]
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [C,A,B]
+              values*: [<string>enum: [C1,C2,C3]]"
+        `);
+            });
+            test('should get correct fields enum limits', () => {
+                const spec = parseYaml(outdent `
+          openapi: 3.0.0
+          components:
+            schemas:
+              StringField: { type: string, title: StringField, enum: [A, B, C] }
+              FieldA: { type: string, title: FieldA, enum: [A1, A2, A3] }
+              FieldB: { type: string, title: FieldB, enum: [B1, B2, B3] }
+              FieldC: { type: string, title: FieldC, enum: [C1, C2, C3] }
+              ObjectWithAllOf:
+                title: StringFilter
+                type: object
+                allOf:
+                  - properties:
+                      type: { type: string, enum: [STRING] }
+                    required: [type, field, values]
+                  - oneOf:
+                      - properties:
+                          field: { type: string, enum: [A] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldA' } }
+                      - properties:
+                          field: { type: string, enum: [B] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldB' } }
+                      - properties:
+                          field: { type: string, enum: [C] }
+                          values: { type: array, items: { $ref: '#/components/schemas/FieldC' } }
+              ObjectWithOneOf:
+                title: StringFilter
+                type: object
+                properties:
+                  type: { type: string, enum: [STRING] }
+                required: [type, field, values]
+                oneOf:
+                  - properties:
+                      field: { type: string, enum: [A] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldA' } }
+                  - properties:
+                      field: { type: string, enum: [B] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldB' } }
+                  - properties:
+                      field: { type: string, enum: [C] }
+                      values: { type: array, items: { $ref: '#/components/schemas/FieldC' } }
+        `);
+                parser = new OpenAPIParser(spec, undefined, options);
+                const schemaWithOneOf = getSchema({
+                    parser,
+                    schemaOrRef: spec.components.schemas.ObjectWithOneOf,
+                    pointer: '#/components/schemas/ObjectWithOneOf',
+                    options,
+                    deps,
+                });
+                expect(printSchema(schemaWithOneOf, enumDetailsPrinter)).toMatchInlineSnapshot(`
+          "oneOf
+            StringFilter ->
+              field*: <string>enum: [A]
+              values*: [<string>enum: [A1,A2,A3]]
+              type*: <string>enum: [STRING]
+            StringFilter ->
+              field*: <string>enum: [B]
+              values*: [<string>enum: [B1,B2,B3]]
+              type*: <string>enum: [STRING]
+            StringFilter ->
+              field*: <string>enum: [C]
+              values*: [<string>enum: [C1,C2,C3]]
+              type*: <string>enum: [STRING]"
+        `);
+                const schemaWithAllOf = getSchema({
+                    parser,
+                    schemaOrRef: spec.components.schemas.ObjectWithAllOf,
+                    pointer: '#/components/schemas/ObjectWithAllOf',
+                    options,
+                    deps,
+                });
+                expect(printSchema(schemaWithAllOf, enumDetailsPrinter)).toMatchInlineSnapshot(`
+          "oneOf
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [A]
+              values*: [<string>enum: [A1,A2,A3]]
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [B]
+              values*: [<string>enum: [B1,B2,B3]]
+            StringFilter ->
+              type*: <string>enum: [STRING]
+              field*: <string>enum: [C]
+              values*: [<string>enum: [C1,C2,C3]]"
+        `);
+            });
+        });
+        test('should get correct sibling inside schema type for openapi 3.1', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.1.0
+        paths:
+          /test:
+            get:
+              operationId: test
+              responses:
+                '200':
+                  content:
+                    application/json:
+                      schema:
+                        type: object
+                        properties:
+                          testAttr:
+                            description: Overridden description
+                            type: string
+                            $ref: '#/components/schemas/Test'
+        components:
+          schemas:
+            Test:
+              type: object
+              description: Refed description
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const name = 'application/json';
+            const mediaType = getMediaType(parser, name, true, spec.paths['/test'].get.responses['200'].content[name], options, deps);
+            expect(printSchema(mediaType?.schema)).toMatchInlineSnapshot(`"testAttr: <object> (Overridden description)"`);
+        });
+        test('should not override schema in openapi 3.0', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.0.0
+        paths:
+          /test:
+            get:
+              operationId: test
+              responses:
+                '200':
+                  content:
+                    application/json:
+                      schema:
+                        type: object
+                        properties:
+                          testAttr:
+                            type: string
+                            description: Overridden description
+                            $ref: '#/components/schemas/Test'
+        components:
+          schemas:
+            Test:
+              type: object
+              description: Refed description
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const name = 'application/json';
+            const mediaType = getMediaType(parser, name, true, spec.paths['/test'].get.responses['200'].content[name], options, deps);
+            expect(printSchema(mediaType?.schema)).toMatchInlineSnapshot(`"testAttr: <object> (Refed description)"`);
+        });
+        test('should correctly merge the types of props in an allOf', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.0.0
+        components:
+          schemas:
+            value:
+              allOf:
+                - type: object
+                  properties:
+                    baseProp: { type: string }
+                    testProp: { type: boolean }
+                - type: object
+                  properties:
+                    baseProp: { type: string }
+                    testProp: { type: number }
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.value,
+                pointer: '#/components/schemas/value',
+                options,
+                deps,
+            });
+            expect(printSchema(schema)).toMatchInlineSnapshot(`
+        "baseProp: <string>
+        testProp: <number>"
+      `);
+        });
+        // Required for JSON Schema Specification Draft 07, which is used by asyncapi-docs
+        test('should handle array schema with items as an array', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.0.0
+        components:
+          schemas:
+            BranchPayload:
+              title: Branch created payload
+              allOf:
+                - type: object
+                  properties:
+                    subjects:
+                      type: array
+                      items:
+                        - type: object
+                          description: Summary of Branch resource.
+                          properties:
+                            uri:
+                              type: string
+                              format: uri
+                              readOnly: true
+                          required:
+                            - uri
+                        - type: object
+                          description: Summary of Branch resource.
+                          properties:
+                            id:
+                              type: string
+                              readOnly: true
+                          required:
+                            - id
+                    additionalItems: false
+                    minItems: 1
+                    maxItems: 1
+      `);
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components.schemas.BranchPayload,
+                pointer: '#/components/schemas/BranchPayload',
+                options,
+                deps,
+            });
+            expect(printSchema(schema)).toMatchInlineSnapshot(`
+        "subjects:
+          [0]:
+            uri*: <string>
+          [1]:
+            id*: <string>
+        additionalItems: <any>
+        minItems: <any>
+        maxItems: <any>"
+      `);
+        });
+        test('oneOf child titles should not be overridden by parent schema title via $ref', () => {
+            const spec = {
+                openapi: '3.1.0',
+                components: {
+                    schemas: {
+                        DocumentMetadata: {
+                            type: 'object',
+                            properties: {
+                                entityMetadata: {
+                                    $ref: '#/components/schemas/EntityMetadata',
+                                },
+                            },
+                        },
+                        EntityMetadata: {
+                            title: 'EntityMetadata',
+                            description: 'Metadata for associated entity of document.',
+                            type: 'object',
+                            oneOf: [
+                                { $ref: '#/components/schemas/PnrMetadataWrapper' },
+                                { $ref: '#/components/schemas/EventMetadataWrapper' },
+                            ],
+                        },
+                        PnrMetadataWrapper: {
+                            type: 'object',
+                            title: 'PnrMetadataWrapper',
+                            properties: {
+                                pnrMetadata: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                        EventMetadataWrapper: {
+                            type: 'object',
+                            title: 'EventMetadataWrapper',
+                            properties: {
+                                eventMetadata: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            parser = new OpenAPIParser(spec, undefined, options);
+            const documentSchema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.DocumentMetadata,
+                pointer: '#/components/schemas/DocumentMetadata',
+                options,
+                deps,
+            });
+            const entityMetadataField = documentSchema.fields?.find((f) => f.name === 'entityMetadata');
+            expect(entityMetadataField).toBeDefined();
+            expect(entityMetadataField?.schema.oneOf).toBeDefined();
+            expect(entityMetadataField?.schema.oneOf).toHaveLength(2);
+            expect(entityMetadataField?.schema.oneOf?.[0].title).toBe('PnrMetadataWrapper');
+            expect(entityMetadataField?.schema.oneOf?.[1].title).toBe('EventMetadataWrapper');
+            expect(entityMetadataField?.schema.oneOf?.[0].title).not.toBe('EntityMetadata');
+            expect(entityMetadataField?.schema.oneOf?.[1].title).not.toBe('EntityMetadata');
+        });
+        test('oneOf with allOf $ref should preserve each variant own title', () => {
+            const spec = {
+                openapi: '3.0.0',
+                components: {
+                    schemas: {
+                        CalloutCommon: {
+                            title: 'Callout - Without authentication',
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                calloutBaseurl: { type: 'string' },
+                            },
+                        },
+                        CalloutBasicAuth: {
+                            title: 'Callout - Base authentication',
+                            allOf: [
+                                { $ref: '#/components/schemas/CalloutCommon' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        authUsername: { type: 'string' },
+                                        authPassword: { type: 'string' },
+                                    },
+                                },
+                            ],
+                        },
+                        CalloutOauth2: {
+                            title: 'Callout - OAuth 2.0 authentication',
+                            allOf: [
+                                { $ref: '#/components/schemas/CalloutCommon' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        oauthClientId: { type: 'string' },
+                                        oauthClientSecret: { type: 'string' },
+                                    },
+                                },
+                            ],
+                        },
+                        CalloutTemplateRequest: {
+                            oneOf: [
+                                { $ref: '#/components/schemas/CalloutCommon' },
+                                { $ref: '#/components/schemas/CalloutBasicAuth' },
+                                { $ref: '#/components/schemas/CalloutOauth2' },
+                            ],
+                        },
+                    },
+                },
+            };
+            parser = new OpenAPIParser(spec, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: spec.components?.schemas?.CalloutTemplateRequest,
+                pointer: '#/components/schemas/CalloutTemplateRequest',
+                options,
+                deps,
+            });
+            expect(schema.oneOf).toBeDefined();
+            expect(schema.oneOf).toHaveLength(3);
+            expect(schema.oneOf?.[0].title).toBe('Callout - Without authentication');
+            expect(schema.oneOf?.[1].title).toBe('Callout - Base authentication');
+            expect(schema.oneOf?.[2].title).toBe('Callout - OAuth 2.0 authentication');
+        });
+    });
+});
+//# sourceMappingURL=Schema.test.js.map