@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261004.085740Z

package/src/api-schemas/dashboard.contract.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { z } from 'zod';
-import type {
-    CreateDashboardPayload,
-    Dashboard,
-    DashboardDataSource,
-    DashboardItem,
-    DashboardStatus,
-    DashboardVersion,
-    UpdateDashboardPayload,
-} from '../data-platform.js';
-import type {
-    CreateDashboardPayloadSchema,
-    DashboardDataSourceSchema,
-    DashboardItemSchema,
-    DashboardSchema,
-    DashboardStatusSchema,
-    DashboardVersionSchema,
-    UpdateDashboardPayloadSchema,
-} from './dashboard.js';
-import { ApiSchemaComponents, validateApiRequest, validateApiResponse } from './registry.js';
-
-type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-function assertType<T extends true>(_ok: T): void {}
-
-describe('the dashboard public types', () => {
-    it('derive from the runtime schemas instead of restating them', () => {
-        assertType<Equals<DashboardStatus, z.infer<typeof DashboardStatusSchema>>>(true);
-        assertType<Equals<DashboardDataSource, z.infer<typeof DashboardDataSourceSchema>>>(true);
-        assertType<Equals<DashboardItem, z.infer<typeof DashboardItemSchema>>>(true);
-        assertType<Equals<Dashboard, z.infer<typeof DashboardSchema>>>(true);
-        assertType<Equals<DashboardVersion, z.infer<typeof DashboardVersionSchema>>>(true);
-        assertType<Equals<CreateDashboardPayload, z.infer<typeof CreateDashboardPayloadSchema>>>(true);
-        assertType<Equals<UpdateDashboardPayload, z.infer<typeof UpdateDashboardPayloadSchema>>>(true);
-    });
-
-    it('keeps the runtime status values available without importing Zod from the root entry', async () => {
-        const common = await import('../data-platform.js');
-        expect(common.DashboardStatus).toEqual({ ACTIVE: 'active', ARCHIVED: 'archived' });
-    });
-});
-
-describe('dashboard request validation', () => {
-    const create = {
-        name: 'Revenue',
-        dataSource: { kind: 'data_sql', query: 'select * from revenue' },
-        spec: { mark: 'bar' },
-    };
-
-    it('accepts the two documented data-source branches', () => {
-        expect(validateApiRequest('CreateDashboardPayload', create)).toMatchObject({ valid: true });
-        expect(
-            validateApiRequest('CreateDashboardPayload', {
-                ...create,
-                dataSource: { kind: 'store_es_dsl', dsl: { size: 20 }, result: { type: 'hits' } },
-            }),
-        ).toMatchObject({ valid: true });
-    });
-
-    it('rejects an unknown data-source discriminator and undeclared payload fields', () => {
-        expect(
-            validateApiRequest('CreateDashboardPayload', {
-                ...create,
-                dataSource: { kind: 'http', url: 'https://example.test/data' },
-            }).valid,
-        ).toBe(false);
-        expect(validateApiRequest('CreateDashboardPayload', { ...create, project: 'ignored-before' }).valid).toBe(
-            false,
-        );
-    });
-
-    it('accepts legacy updates without a revision while rejecting undeclared fields', () => {
-        expect(validateApiRequest('UpdateDashboardPayload', {}).valid).toBe(true);
-        expect(validateApiRequest('UpdateDashboardPayload', { summary: 'Legacy update' }).valid).toBe(true);
-        expect(
-            validateApiRequest('UpdateDashboardPayload', {
-                expected_edit_revision: 1,
-                spec: { mark: 'line' },
-            }),
-        ).toMatchObject({
-            valid: true,
-        });
-        expect(
-            validateApiRequest('UpdateDashboardPayload', { expected_edit_revision: 1, skip_versioning: true }),
-        ).toMatchObject({ valid: true });
-        expect(validateApiRequest('UpdateDashboardPayload', { expected_edit_revision: 1, unknown: true }).valid).toBe(
-            false,
-        );
-    });
-
-    it('keeps the two bulk bodies as the free-form string-array map already published', () => {
-        expect(validateApiRequest('StringArrayMap', { ids: ['one', 'two'] })).toMatchObject({ valid: true });
-        expect(validateApiRequest('StringArrayMap', { labels: ['one'] })).toMatchObject({ valid: true });
-        expect(validateApiRequest('StringArrayMap', { ids: 'one' }).valid).toBe(false);
-    });
-});
-
-describe('dashboard response validation', () => {
-    const item = {
-        id: 'dashboard-1',
-        edit_revision: 1,
-        name: 'Revenue',
-        tags: [],
-        updated_by: 'user:editor',
-        created_by: 'user:author',
-        created_at: '2026-08-01T00:00:00.000Z',
-        updated_at: '2026-08-02T00:00:00.000Z',
-        store_id: 'store-1',
-        status: 'active',
-        panel_count: 0,
-        query_count: 0,
-    };
-
-    it('accepts the mapper-produced listing and full response shapes', () => {
-        expect(validateApiResponse('DashboardItem', item)).toMatchObject({ valid: true });
-        expect(
-            validateApiResponse('Dashboard', {
-                ...item,
-                query: 'select * from revenue',
-                spec: { mark: 'bar' },
-                queries: [],
-                panels: [],
-                layout: { columns: 2, cellWidth: 600, cellHeight: 400, padding: 20 },
-            }),
-        ).toMatchObject({ valid: true });
-    });
-
-    it('rejects persistence-only fields instead of allowing a document spread to escape', () => {
-        expect(validateApiResponse('DashboardItem', { ...item, account: 'account-1' }).valid).toBe(false);
-    });
-
-    it('registers the complete response closure used by the endpoints', () => {
-        expect(ApiSchemaComponents).toHaveProperty('DashboardItemArray');
-        expect(ApiSchemaComponents).toHaveProperty('DashboardVersionItemArray');
-        expect(ApiSchemaComponents).toHaveProperty('DashboardVersion');
-        expect(ApiSchemaComponents).toHaveProperty('Dashboard');
-    });
-});

package/src/api-schemas/data-store.contract.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import type {
-    AlterTableOperation,
-    DataStore,
-    DataStoreSchemaResponse,
-    ImportJob,
-    ListDataStoreVersionsQuery,
-} from '../data-platform.js';
-import type {
-    AlterTableOperationSchema,
-    DataStoreSchema,
-    DataStoreSchemaResponseSchema,
-    ImportJobSchema,
-    ListDataStoreVersionsQuerySchema,
-} from './data-store.js';
-import { ApiSchemaComponents, validateApiRequest, validateApiResponse } from './registry.js';
-
-describe('data-store API contracts', () => {
-    it('derives the public types from the runtime schemas', () => {
-        expectTypeOf<DataStore>().toEqualTypeOf<import('zod').z.infer<typeof DataStoreSchema>>();
-        expectTypeOf<ImportJob>().toEqualTypeOf<import('zod').z.infer<typeof ImportJobSchema>>();
-        expectTypeOf<AlterTableOperation>().toEqualTypeOf<import('zod').z.infer<typeof AlterTableOperationSchema>>();
-        expectTypeOf<DataStoreSchemaResponse>().toEqualTypeOf<
-            import('zod').z.infer<typeof DataStoreSchemaResponseSchema>
-        >();
-        expectTypeOf<ListDataStoreVersionsQuery>().toEqualTypeOf<
-            import('zod').z.infer<typeof ListDataStoreVersionsQuerySchema>
-        >();
-    });
-
-    it('accepts a recoverable import ID at the HTTP request boundary', () => {
-        const input = { mode: 'append', message: 'Import rows', tables: {}, import_id: '6aa400001234567890abcdef' };
-        expect(validateApiRequest('ImportDataPayload', input).valid).toBe(true);
-        expect(validateApiRequest('ImportDataPayload', { ...input, import_id: 'invalid' }).valid).toBe(false);
-    });
-
-    it('rejects undeclared request fields through the published component', () => {
-        expect(
-            validateApiRequest('CreateDataStorePayload', {
-                name: 'analytics',
-                project: 'ignored-by-the-old-handler',
-            }).valid,
-        ).toBe(false);
-    });
-
-    it('enforces every alter-table discriminator branch', () => {
-        expect(
-            validateApiRequest('AlterTablePayload', {
-                changes: [{ op: 'rename_column', from: 'old_name', to: 'new_name' }],
-            }).valid,
-        ).toBe(true);
-
-        expect(
-            validateApiRequest('AlterTablePayload', {
-                changes: [{ op: 'rename_column', from: 'old_name', column: 'new_name' }],
-            }).valid,
-        ).toBe(false);
-    });
-
-    it('keeps free-form row and parameter maps open', () => {
-        expect(
-            validateApiRequest('QueryPayload', {
-                sql: 'SELECT * FROM users WHERE tenant = $tenant',
-                params: { tenant: 'project-1', include_archived: false },
-            }).valid,
-        ).toBe(true);
-    });
-
-    it('requires the renamed store_id field on import-job responses', () => {
-        const response: ImportJob = {
-            id: 'job-1',
-            store_id: 'store-1',
-            status: 'completed',
-            tables: ['users'],
-            mode: 'append',
-            rows_imported: 2,
-            started_at: '2026-08-02T00:00:00.000Z',
-        };
-        expect(validateApiResponse('ImportJob', response).valid).toBe(true);
-        expect(validateApiResponse('ImportJob', { ...response, store_id: undefined }).valid).toBe(false);
-    });
-
-    it('registers the entire data-store reference closure', () => {
-        for (const name of [
-            'DataStore',
-            'DataSchema',
-            'DataTable',
-            'DataColumn',
-            'DataStoreSchemaResponse',
-            'DataSchemaForAI',
-            'ListDataStoreVersionsQuery',
-            'GetDataStoreTableQuery',
-        ]) {
-            expect(ApiSchemaComponents[name]).toBeDefined();
-        }
-    });
-});

package/src/api-schemas/document-processing.contract.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { DocAnalyzeRunStatusResponse, DocumentPrepOptions } from '../store/doc-analyzer.js';
-import type { GroundedExtractionRequest } from '../store/grounded-extraction.js';
-import type {
-    RenderMarkdownPayload,
-    RenderMarkdownStartResponse,
-    RenderMarkdownStatusQuery,
-} from '../store/rendering.js';
-import { MarkdownRenditionFormat } from '../store/store.js';
-import { WorkflowExecutionStatus } from '../store/workflow.js';
-import type {
-    DocAnalyzeRunStatusResponseSchema,
-    DocumentPrepOptionsSchema,
-    GroundedExtractionRequestSchema,
-    RenderMarkdownPayloadSchema,
-    RenderMarkdownStartResponseSchema,
-    RenderMarkdownStatusQuerySchema,
-} from './document-processing.js';
-import { validateApiRequest, validateApiResponse } from './registry.js';
-
-type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-function assertType<T extends true>(_value: T): void {}
-
-describe('rendering and document-processing API contracts', () => {
-    it('derives the public types from their schemas', () => {
-        assertType<Equals<RenderMarkdownPayload, typeof RenderMarkdownPayloadSchema._output>>(true);
-        assertType<Equals<RenderMarkdownStartResponse, typeof RenderMarkdownStartResponseSchema._output>>(true);
-        assertType<Equals<RenderMarkdownStatusQuery, typeof RenderMarkdownStatusQuerySchema._output>>(true);
-        assertType<Equals<DocumentPrepOptions, typeof DocumentPrepOptionsSchema._output>>(true);
-        assertType<Equals<GroundedExtractionRequest, typeof GroundedExtractionRequestSchema._output>>(true);
-        assertType<Equals<DocAnalyzeRunStatusResponse, typeof DocAnalyzeRunStatusResponseSchema._output>>(true);
-    });
-
-    it('keeps WorkflowExecutionStatus numeric on the wire', () => {
-        expect(
-            validateApiResponse('RenderMarkdownStartResponse', {
-                workflow_id: 'render:1',
-                workflow_run_id: 'run-1',
-                status: WorkflowExecutionStatus.RUNNING,
-                format: MarkdownRenditionFormat.pdf,
-            }).valid,
-        ).toBe(true);
-        expect(
-            validateApiResponse('RenderMarkdownStartResponse', {
-                workflow_id: 'render:1',
-                workflow_run_id: 'run-1',
-                status: WorkflowExecutionStatus.TIMED_OUT,
-                format: MarkdownRenditionFormat.pdf,
-            }).valid,
-        ).toBe(true);
-        expect(
-            validateApiResponse('RenderMarkdownStartResponse', {
-                workflow_id: 'render:1',
-                workflow_run_id: 'run-1',
-                status: 'RUNNING',
-                format: MarkdownRenditionFormat.pdf,
-            }).valid,
-        ).toBe(false);
-    });
-
-    it('keeps document prep extensible while closing grounded extraction', () => {
-        expect(validateApiRequest('DocumentPrepOptions', { custom_processor_flag: true }).valid).toBe(true);
-        expect(validateApiRequest('GroundedExtractionRequest', { force_ocr: true }).valid).toBe(true);
-        expect(validateApiRequest('GroundedExtractionRequest', { force_ocr: true, unexpected: true }).valid).toBe(
-            false,
-        );
-    });
-
-    it('enforces the published rendering metadata author array', () => {
-        const base = { format: MarkdownRenditionFormat.pdf, content: '# Report' };
-        expect(validateApiRequest('RenderMarkdownPayload', { ...base, metadata: { author: ['Ada'] } }).valid).toBe(
-            true,
-        );
-        expect(validateApiRequest('RenderMarkdownPayload', { ...base, metadata: { author: 'Ada' } }).valid).toBe(false);
-    });
-});

package/src/api-schemas/emit-json-schema.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { toOpenApiComponents } from './adapter.js';
-import { emitJsonSchema } from './emit-json-schema.js';
-
-describe('explicit union emission', () => {
-    it('preserves optional explicit unions and nullable schemas', () => {
-        const schema = z.object({
-            explicit: z.union([z.string(), z.null()]).optional().describe('Clear with null'),
-            nullable: z.string().nullable(),
-        });
-        const emitted = emitJsonSchema(schema);
-        expect(emitted.properties).toEqual({
-            explicit: { anyOf: [{ type: 'string' }, { type: 'null' }], description: 'Clear with null' },
-            nullable: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-        });
-        expect(JSON.stringify(emitted)).not.toContain('x-vertesia-explicit-union');
-    });
-
-    it('preserves referenced explicit unions inside named definitions', () => {
-        const value = z.union([z.string(), z.boolean(), z.number(), z.null()]).meta({ id: 'Value' });
-        const schema = z.object({ value }).meta({ id: 'Holder' });
-        const components = toOpenApiComponents({ Holder: emitJsonSchema(schema) });
-        expect(components.Value).toEqual({
-            anyOf: [{ type: 'string' }, { type: 'boolean' }, { type: 'number' }, { type: 'null' }],
-        });
-        expect(JSON.stringify(components)).not.toContain('x-vertesia-explicit-union');
-    });
-
-    it('retains constraints on union branches', () => {
-        expect(emitJsonSchema(z.union([z.string().min(2), z.null()])).anyOf).toEqual([
-            { type: 'string', minLength: 2 },
-            { type: 'null' },
-        ]);
-    });
-});

package/src/api-schemas/environment.contract.test.ts

@@ -1,202 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SupportedProviders } from '../environment.js';
-import { ApiSchemaComponents, validateApiRequest, validateApiResponse } from './registry.js';
-
-/**
- * The environment contracts, pinned where converting them changed what the document says or where
- * the conversion had a choice to make.
- *
- * Thirty-six components, of which thirty-two re-emit byte-identically; what is asserted here is the
- * four that do not, the two provider vocabularies that have to stay in step, and the secret boundary
- * that is the reason the read and write shapes are separate objects.
- */
-
-describe('the provider vocabulary', () => {
-    /**
-     * `SupportedProviders` is llumiverse's `Providers` merged with the three studio-only virtual
-     * providers, and the schema reads its members off that merged object rather than restating them.
-     * This is the assertion that it still does: a provider added on either side has to reach the
-     * document without anyone editing a list, which is the whole reason `z.enum()` takes the object.
-     */
-    it('publishes every member of the merged provider object, in its order', () => {
-        expect(enumOf('SupportedProviders')).toEqual(Object.values(SupportedProviders));
-    });
-
-    it('includes the studio-only virtual providers, which llumiverse does not know about', () => {
-        expect(enumOf('SupportedProviders')).toEqual(
-            expect.arrayContaining(['virtual_lb', 'virtual_mediator', 'test']),
-        );
-    });
-
-    it('rejects a provider that is neither', () => {
-        expect(validateApiRequest('ExecutionEnvironmentCreatePayload', { name: 'e', provider: 'openai' }).valid).toBe(
-            true,
-        );
-        expect(
-            validateApiRequest('ExecutionEnvironmentCreatePayload', { name: 'router', provider: 'openrouter' }).valid,
-        ).toBe(true);
-        expect(validateApiRequest('ExecutionEnvironmentCreatePayload', { name: 'e', provider: 'gpt' }).valid).toBe(
-            false,
-        );
-    });
-});
-
-describe('the environment secret boundary', () => {
-    it('accepts an API key on create', () => {
-        expect(
-            validateApiRequest('ExecutionEnvironmentCreatePayload', {
-                name: 'vertex',
-                provider: 'vertexai',
-                apiKey: 'shhh',
-            }),
-        ).toMatchObject({ valid: true });
-    });
-
-    it('publishes apiKey on the read shape, because what comes back is the masked value', () => {
-        // Unlike the OAuth providers, the read shape does NOT drop the field: `toEnvironmentResponse`
-        // overwrites it with `apikey_hint` or a masked form of the key, so the property a caller reads
-        // is a display hint rather than a credential. The response contract has to allow it, or every
-        // environment read would fail its own check.
-        const environment = {
-            id: '68b1779130afe5403a1589ba',
-            name: 'vertex',
-            provider: 'vertexai',
-            apiKey: 'AKIA...3xQf',
-            apikey_hint: 'AKIA...3xQf',
-            account: '69d4762f24d3048c99149d0b',
-            created_by: 'u1',
-            updated_by: 'u1',
-            created_at: '2026-01-01T00:00:00.000Z',
-            updated_at: '2026-01-01T00:00:00.000Z',
-        };
-
-        expect(validateApiResponse('ExecutionEnvironment', environment)).toMatchObject({ valid: true });
-        expect(validateApiResponse('ExecutionEnvironment', { ...environment, secret: 'x' }).valid).toBe(false);
-    });
-});
-
-describe('ExecutionEnvironmentSettings', () => {
-    /**
-     * The one component in this closure published OPEN. It carried an index signature, so a setting
-     * for a provider this build has never heard of round-trips instead of being rejected — which is
-     * what the settings bag is for, and the reason it is absent from `STRICT_COMPONENTS`.
-     */
-    it('accepts a setting it does not declare', () => {
-        expect(
-            validateApiRequest('ExecutionEnvironmentUpdatePayload', {
-                settings: { bucket_access_principal: 'sa@p.iam', some_future_driver_flag: true },
-            }),
-        ).toMatchObject({ valid: true });
-    });
-
-    it('still rejects an undeclared property on the payload around it', () => {
-        expect(validateApiRequest('ExecutionEnvironmentUpdatePayload', { setttings: {} }).valid).toBe(false);
-    });
-});
-
-describe('the create and update payloads', () => {
-    /**
-     * They used to be `Omit<ExecutionEnvironment, ...>` and `Partial<Omit<...>>`. Both are stated
-     * where they are named now, from one shared field list — so the assertion that matters is that
-     * the two still describe the same fields, which the mapped types used to guarantee structurally.
-     */
-    it('describe the same fields, one requiring name and provider and the other requiring nothing', () => {
-        expect(propertiesOf('ExecutionEnvironmentUpdatePayload')).toEqual(
-            propertiesOf('ExecutionEnvironmentCreatePayload'),
-        );
-        expect(requiredOf('ExecutionEnvironmentCreatePayload')).toEqual(['name', 'provider']);
-        expect(requiredOf('ExecutionEnvironmentUpdatePayload')).toEqual([]);
-    });
-
-    it('neither accepts a server-owned field', () => {
-        // `id`, `account` and the audit fields are on the read shape only. A payload carrying one used
-        // to be silently ignored; the write shapes not listing them is what makes it a 400.
-        for (const field of ['id', 'account', 'created_by', 'created_at', 'apikey_hint']) {
-            expect(
-                validateApiRequest('ExecutionEnvironmentCreatePayload', { name: 'e', provider: 'test', [field]: 'x' })
-                    .valid,
-            ).toBe(false);
-            expect(validateApiRequest('ExecutionEnvironmentUpdatePayload', { [field]: 'x' }).valid).toBe(false);
-        }
-    });
-
-    it('accepts an empty update body', () => {
-        expect(validateApiRequest('ExecutionEnvironmentUpdatePayload', {}).valid).toBe(true);
-    });
-});
-
-describe('the model search query', () => {
-    /**
-     * `text` was published `required: true` and is optional now. The interface declared it
-     * non-optional, but `EnvironmentsApi.listModels(id, payload?)` takes the payload optionally and
-     * three existing call sites pass nothing — so enforcing the requirement the document stated would
-     * have 400'd the UI on a parameter the server never wanted.
-     */
-    it('takes no required parameter', () => {
-        // The scanner expands this component into four query parameters, and a property the component
-        // does not require becomes a parameter the document does not require.
-        expect(requiredOf('ModelSearchPayload')).toEqual([]);
-        expect(validateApiRequest('ModelSearchPayload', {}).valid).toBe(true);
-    });
-
-    it('still rejects a value outside the model-type vocabulary', () => {
-        expect(validateApiRequest('ModelSearchPayload', { type: 'text' }).valid).toBe(true);
-        expect(validateApiRequest('ModelSearchPayload', { type: 'spreadsheet' }).valid).toBe(false);
-    });
-});
-
-describe('the embeddings request', () => {
-    it('discriminates its four input shapes on type', () => {
-        expect(ApiSchemaComponents.EmbeddingsApiInput).toMatchObject({
-            discriminator: {
-                propertyName: 'type',
-                mapping: { text: expect.stringContaining('EmbeddingsApiTextInput') },
-            },
-        });
-    });
-
-    it('accepts a text input and refuses one carrying an image source', () => {
-        const request = (input: unknown) => validateApiRequest('EmbeddingsApiRequest', { inputs: [input] });
-
-        expect(request({ type: 'text', text: 'hello' })).toMatchObject({ valid: true });
-        expect(request({ type: 'text', text: 'hello', source: { url: 'gs://b/o' } }).valid).toBe(false);
-        expect(request({ type: 'image', source: { url: 'gs://b/o' } })).toMatchObject({ valid: true });
-    });
-
-    it('accepts an empty inputs array, which the handler rejects rather than the schema', () => {
-        // `minItems` is deliberately not published: an empty batch is well-formed and useless, and
-        // adding the constraint would newly reject a request the document has always described.
-        expect(validateApiRequest('EmbeddingsApiRequest', { inputs: [] }).valid).toBe(true);
-    });
-
-    it('accepts the logical project embedding type and rejects unknown types', () => {
-        expect(
-            validateApiRequest('EmbeddingsApiRequest', {
-                embedding_type: 'properties',
-                inputs: [{ type: 'text', text: '{}' }],
-            }).valid,
-        ).toBe(true);
-        expect(
-            validateApiRequest('EmbeddingsApiRequest', {
-                embedding_type: 'audio',
-                inputs: [{ type: 'audio', source: { url: 'gs://b/o' } }],
-            }).valid,
-        ).toBe(false);
-    });
-});
-
-function enumOf(component: 'SupportedProviders'): string[] {
-    const emitted = ApiSchemaComponents[component] as { enum?: unknown };
-    if (!Array.isArray(emitted?.enum)) throw new Error(`${component} is not published as an enum`);
-    return emitted.enum as string[];
-}
-
-function propertiesOf(component: string): string[] {
-    const emitted = ApiSchemaComponents[component] as { properties?: Record<string, unknown> };
-    return Object.keys(emitted?.properties ?? {});
-}
-
-function requiredOf(component: string): string[] {
-    const emitted = ApiSchemaComponents[component] as { required?: unknown };
-    return Array.isArray(emitted?.required) ? (emitted.required as string[]) : [];
-}