@goast/core 0.6.0 → 0.7.0-beta.2

package/dist/src/transform/transform-document.d.ts

@@ -0,0 +1,4 @@
+import type { OpenApiDocument } from '../parse/openapi-types.ts';
+import type { Deref } from '../parse/types.ts';
+import type { OpenApiTransformerContext } from './types.ts';
+export declare function transformDocument(context: OpenApiTransformerContext, document: Deref<OpenApiDocument>): void;

package/{esm → dist}/src/transform/transform-document.js

@@ -1,12 +1,10 @@
 import { getOpenApiObjectIdentifier } from './helpers.js';
 export function transformDocument(context, document) {
-    var _a;
-    for (const tag of (_a = document.tags) !== null && _a !== void 0 ? _a : []) {
+    for (const tag of document.tags ?? []) {
         transformTag(context, tag);
     }
 }
 function transformTag(context, tag, isReference = false) {
-    var _a;
     const openApiObjectId = getOpenApiObjectIdentifier(tag);
     const existing = context.transformed.services.get(openApiObjectId);
     if (existing)
@@ -20,7 +18,7 @@ function transformTag(context, tag, isReference = false) {
         },
         $ref: ref,
         id,
-        name: (_a = tag.name) !== null && _a !== void 0 ? _a : id,
+        name: tag.name ?? id,
         description: tag.description,
         endpoints: [],
     };

package/{esm → dist}/src/transform/transform-endpoint.d.ts

@@ -1,5 +1,4 @@
-import type { OpenApiCollectorEndpointInfo } from '../collect/types.js';
-import type { ApiEndpoint } from './api-types.js';
-import type { OpenApiTransformerContext } from './types.js';
+import type { OpenApiCollectorEndpointInfo } from '../collect/types.ts';
+import type { ApiEndpoint } from './api-types.ts';
+import type { OpenApiTransformerContext } from './types.ts';
 export declare function transformEndpoint(context: OpenApiTransformerContext, endpointInfo: OpenApiCollectorEndpointInfo): ApiEndpoint;
-//# sourceMappingURL=transform-endpoint.d.ts.map

package/{esm → dist}/src/transform/transform-endpoint.js

@@ -2,7 +2,6 @@ import { isOpenApiObjectProperty } from '../internal-utils.js';
 import { determineEndpointName, getCustomFields, getOpenApiObjectIdentifier } from './helpers.js';
 import { transformSchema } from './transform-schema.js';
 export function transformEndpoint(context, endpointInfo) {
-    var _a, _b, _c, _d;
     const apiPath = transformApiPath(context, endpointInfo.path, endpointInfo.pathItem);
     const endpoint = {
         $src: {
@@ -17,13 +16,13 @@ export function transformEndpoint(context, endpointInfo) {
         method: endpointInfo.method,
         summary: endpointInfo.operation.summary,
         description: endpointInfo.operation.description,
-        parameters: combineParameters(apiPath.parameters, (_b = (_a = endpointInfo.operation.parameters) === null || _a === void 0 ? void 0 : _a.map((p) => transformParameter(context, p))) !== null && _b !== void 0 ? _b : []),
-        deprecated: (_c = endpointInfo.operation.deprecated) !== null && _c !== void 0 ? _c : false,
+        parameters: combineParameters(apiPath.parameters, endpointInfo.operation.parameters?.map((p) => transformParameter(context, p)) ?? []),
+        deprecated: endpointInfo.operation.deprecated ?? false,
         requestBody: endpointInfo.operation.requestBody
             ? transformRequestBody(context, endpointInfo.operation.requestBody)
             : undefined,
         responses: transformResponses(context, endpointInfo.operation.responses),
-        tags: (_d = endpointInfo.operation.tags) !== null && _d !== void 0 ? _d : [],
+        tags: endpointInfo.operation.tags ?? [],
         custom: getCustomFields(endpointInfo.operation),
     };
     const tags = endpoint.tags.length === 0 ? [''] : endpoint.tags;
@@ -47,7 +46,6 @@ export function transformEndpoint(context, endpointInfo) {
     return endpoint;
 }
 function transformApiPath(context, path, pathItem, isReference = false) {
-    var _a, _b;
     const existingPath = context.paths.get(path);
     if (existingPath)
         return existingPath;
@@ -66,7 +64,7 @@ function transformApiPath(context, path, pathItem, isReference = false) {
         summary: pathItem.summary,
         description: pathItem.description,
         path: path,
-        parameters: (_b = (_a = pathItem.parameters) === null || _a === void 0 ? void 0 : _a.map((p) => transformParameter(context, p))) !== null && _b !== void 0 ? _b : [],
+        parameters: pathItem.parameters?.map((p) => transformParameter(context, p)) ?? [],
         // HTTP methods are added later (see transformEndpoint)
         get: undefined,
         put: undefined,
@@ -83,7 +81,6 @@ function transformApiPath(context, path, pathItem, isReference = false) {
     return apiPath;
 }
 function transformParameter(context, parameter) {
-    var _a, _b, _c;
     const openApiObjectId = getOpenApiObjectIdentifier(parameter);
     const existing = context.transformed.parameters.get(openApiObjectId);
     if (existing)
@@ -97,11 +94,11 @@ function transformParameter(context, parameter) {
         },
         $ref: ref,
         id: id,
-        name: (_a = parameter.name) !== null && _a !== void 0 ? _a : id,
+        name: parameter.name ?? id,
         target: parameter.in,
         description: parameter.description,
-        required: (_b = parameter.required) !== null && _b !== void 0 ? _b : false,
-        deprecated: (_c = parameter.deprecated) !== null && _c !== void 0 ? _c : false,
+        required: parameter.required ?? false,
+        deprecated: parameter.deprecated ?? false,
         allowEmptyValue: parameter.allowEmptyValue,
         style: parameter.style,
         explode: parameter.explode,
@@ -112,7 +109,6 @@ function transformParameter(context, parameter) {
     return p;
 }
 function transformRequestBody(context, requestBody) {
-    var _a;
     const openApiObjectId = getOpenApiObjectIdentifier(requestBody);
     const existing = context.transformed.requestBodies.get(openApiObjectId);
     if (existing)
@@ -126,7 +122,7 @@ function transformRequestBody(context, requestBody) {
         $ref: ref,
         id: context.idGenerator.generateId('requestBody'),
         description: requestBody.description,
-        required: (_a = requestBody.required) !== null && _a !== void 0 ? _a : false,
+        required: requestBody.required ?? false,
         content: transformContent(context, requestBody.content),
     };
     context.transformed.requestBodies.set(openApiObjectId, rb);
@@ -223,7 +219,6 @@ function transformHeaders(context, headers) {
     return result;
 }
 function transformHeader(context, header, name) {
-    var _a, _b;
     const openApiObjectId = getOpenApiObjectIdentifier(header);
     const existing = context.transformed.headers.get(openApiObjectId);
     if (existing)
@@ -233,7 +228,6 @@ function transformHeader(context, header, name) {
     const id = context.idGenerator.generateId('header');
     if (isSchema(header)) {
         h = {
-            // deno-lint-ignore no-explicit-any
             $src: Object.assign({}, header.$src, { component: header }),
             $ref: ref,
             id,
@@ -250,14 +244,13 @@ function transformHeader(context, header, name) {
     }
     else {
         h = {
-            // deno-lint-ignore no-explicit-any
             $src: Object.assign({}, header.$src, { component: header }),
             $ref: ref,
             id,
             name,
             description: header.description,
-            required: (_a = header.required) !== null && _a !== void 0 ? _a : false,
-            deprecated: (_b = header.deprecated) !== null && _b !== void 0 ? _b : false,
+            required: header.required ?? false,
+            deprecated: header.deprecated ?? false,
             allowEmptyValue: header.allowEmptyValue,
             style: header.style,
             explode: header.explode,

package/dist/src/transform/transform-schema.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiSchema } from '../parse/openapi-types.ts';
+import type { Deref } from '../parse/types.ts';
+import type { ApiSchema } from './api-types.ts';
+import type { OpenApiTransformerContext } from './types.ts';
+export declare function transformSchema<T extends Deref<OpenApiSchema>>(ctx: OpenApiTransformerContext, schema: T): ApiSchema;

package/{esm → dist}/src/transform/transform-schema.js

@@ -1,12 +1,11 @@
 import { createOverwriteProxy } from '../utils/object.utils.js';
 import { asTypeArray, determineSchemaAccessibility, determineSchemaKind, determineSchemaName, getCustomFields, getOpenApiObjectIdentifier, hasNullType, transformAdditionalProperties, transformSchemaProperties, withoutNullType, } from './helpers.js';
 export function transformSchema(ctx, schema) {
-    var _a, _b, _c;
     if (!schema) {
         throw new Error('Schema is required.');
     }
     const schemaSource = `${schema.$src.file}:${schema.$src.path}`;
-    const existingSchema = (_a = ctx.schemas.get(schemaSource)) !== null && _a !== void 0 ? _a : ctx.incompleteSchemas.get(schemaSource);
+    const existingSchema = ctx.schemas.get(schemaSource) ?? ctx.incompleteSchemas.get(schemaSource);
     if (existingSchema)
         return existingSchema;
     const openApiObjectId = getOpenApiObjectIdentifier(schema);
@@ -23,7 +22,7 @@ export function transformSchema(ctx, schema) {
         if (remainingTypes.length === 0) {
             // A type array that contains nothing but `null` constrains nullability only. If the schema also has a
             // `$ref`, the actual type is the referenced one; otherwise the schema really is just the null type.
-            remainingTypes = withoutNullType(asTypeArray((_b = schema.$ref) === null || _b === void 0 ? void 0 : _b.type));
+            remainingTypes = withoutNullType(asTypeArray(schema.$ref?.type));
         }
         if (remainingTypes.length > 1) {
             // Still a genuine multi-type schema; only the `null` member is absorbed into `nullable`.
@@ -52,7 +51,7 @@ export function transformSchema(ctx, schema) {
         name: nameInfo.name,
         isNameGenerated: nameInfo.isGenerated,
         description: schema.description,
-        deprecated: (_c = schema.deprecated) !== null && _c !== void 0 ? _c : false,
+        deprecated: schema.deprecated ?? false,
         accessibility: determineSchemaAccessibility(schema),
         kind,
         enum: schema.enum,
@@ -65,9 +64,7 @@ export function transformSchema(ctx, schema) {
         const: schema.const,
         discriminator: schema.discriminator
             ? {
-                propertyName: typeof schema.discriminator === 'string'
-                    ? schema.discriminator
-                    : schema.discriminator.propertyName,
+                propertyName: typeof schema.discriminator === 'string' ? schema.discriminator : schema.discriminator.propertyName,
                 mapping: {},
             }
             : undefined,
@@ -86,13 +83,12 @@ export function transformSchema(ctx, schema) {
     return completeSchema;
 }
 function allExtensionsTransformer(schema, context) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
     // A schema with `prefixItems` is a tuple. Tuples are not modelled, but the `items` schema of a tuple only
     // describes the elements *after* the prefix, so it must not be reported as the element schema of the array:
     // that would actively mistype the array instead of leaving its elements unspecified.
-    const isTuple = ((_b = (_a = schema.prefixItems) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+    const isTuple = (schema.prefixItems?.length ?? 0) > 0;
     return {
-        oneOf: (_d = (_c = schema.oneOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
+        oneOf: schema.oneOf?.map((s) => transformSchema(context, s)) ?? [],
         format: schema.format,
         pattern: schema.pattern,
         minLength: schema.minLength,
@@ -101,8 +97,8 @@ function allExtensionsTransformer(schema, context) {
         maximum: schema.maximum,
         properties: transformSchemaProperties(context, schema, transformSchema),
         additionalProperties: transformAdditionalProperties(context, schema, transformSchema),
-        allOf: (_f = (_e = schema.allOf) === null || _e === void 0 ? void 0 : _e.map((s) => transformSchema(context, s))) !== null && _f !== void 0 ? _f : [],
-        anyOf: (_h = (_g = schema.anyOf) === null || _g === void 0 ? void 0 : _g.map((s) => transformSchema(context, s))) !== null && _h !== void 0 ? _h : [],
+        allOf: schema.allOf?.map((s) => transformSchema(context, s)) ?? [],
+        anyOf: schema.anyOf?.map((s) => transformSchema(context, s)) ?? [],
         items: !isTuple && schema.items ? transformSchema(context, schema.items) : undefined,
         minItems: schema.minItems,
         maxItems: schema.maxItems,

package/dist/src/transform/transformer.d.ts

@@ -0,0 +1,4 @@
+import type { OpenApiCollectorData } from '../collect/types.ts';
+import type { ApiData } from './api-types.ts';
+import { type OpenApiTransformerOptions } from './types.ts';
+export declare function transformOpenApi(data: OpenApiCollectorData, options?: Partial<OpenApiTransformerOptions>): ApiData;

package/{esm → dist}/src/transform/types.d.ts

@@ -1,7 +1,7 @@
-import type { OpenApiCollectorData } from '../collect/types.js';
-import type { ArrayItem } from '../utils/type.utils.js';
-import type { ApiContent, ApiData, ApiHeader, ApiParameter, ApiPath, ApiRequestBody, ApiResponse, ApiSchema, ApiSchemaExtensions, ApiSchemaKind, ApiService } from './api-types.js';
-import type { IdGenerator } from './helpers.js';
+import type { OpenApiCollectorData } from '../collect/types.ts';
+import type { ArrayItem } from '../utils/type.utils.ts';
+import type { ApiContent, ApiData, ApiHeader, ApiParameter, ApiPath, ApiRequestBody, ApiResponse, ApiSchema, ApiSchemaExtensions, ApiSchemaKind, ApiService } from './api-types.ts';
+import type { IdGenerator } from './helpers.ts';
 export type OpenApiTransformerOptions = {
     /**
      * Determines how schemas without a `type` property should be treated.
@@ -33,4 +33,3 @@ export type OpenApiTransformerContext = {
 } & {
     [K in Exclude<keyof ApiData, 'documents'>]: Map<string, ArrayItem<ApiData[K]>>;
 };
-//# sourceMappingURL=types.d.ts.map

package/{script → dist}/src/utils/action-provider.d.ts

@@ -1,4 +1,4 @@
-import type { EmptyConstructor, FunctionNames } from './type.utils.js';
+import type { EmptyConstructor, FunctionNames } from './type.utils.ts';
 type MatchingFunctionNames<T, TAction> = {
     [K in keyof T]: T[K] extends TAction ? K : never;
 }[keyof T];
@@ -19,11 +19,10 @@ type ValueActionRunner<T, TAction> = {
 type ActionRunner<TAction> = CtorActionRunner<any, TAction> | FnActionRunner<TAction> | ValueActionRunner<any, TAction>;
 export declare class ActionProvider<TAction extends (...args: any[]) => any> {
     private readonly _runner;
-    constructor(_runner: ActionRunner<TAction>);
+    constructor(runner: ActionRunner<TAction>);
     run(...args: Parameters<TAction>): ReturnType<TAction>;
     static fromType<T, TName extends FunctionNames<T>>(type: EmptyConstructor<T>, functionName: TName): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never>;
     static fromFn<TAction extends (...args: any[]) => any>(fn: TAction): ActionProvider<TAction>;
     static fromValue<T, TName extends FunctionNames<T>>(value: T, functionName: TName): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never>;
 }
 export {};
-//# sourceMappingURL=action-provider.d.ts.map

package/{esm → dist}/src/utils/action-provider.js

@@ -1,11 +1,7 @@
 export class ActionProvider {
-    constructor(_runner) {
-        Object.defineProperty(this, "_runner", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: _runner
-        });
+    _runner;
+    constructor(runner) {
+        this._runner = runner;
     }
     run(...args) {
         switch (this._runner.kind) {

package/{esm → dist}/src/utils/api-data.utils.d.ts

@@ -1,3 +1,2 @@
-import type { ApiComponent, ApiData } from '../transform/api-types.js';
+import type { ApiComponent, ApiData } from '../transform/api-types.ts';
 export declare function getSourceDisplayName<T>(data: ApiData, component: ApiComponent<T>): string;
-//# sourceMappingURL=api-data.utils.d.ts.map

package/{esm → dist}/src/utils/array.utils.d.ts

@@ -1,2 +1 @@
 export declare function removeItems<T>(array: T[], predicate: (item: T) => boolean): void;
-//# sourceMappingURL=array.utils.d.ts.map

package/{script → dist}/src/utils/asset-manager.d.ts

@@ -6,4 +6,3 @@ export declare class AssetManager {
     copyAssetFile(relativePath: string, destDir: string, logName?: string): Promise<void>;
     private fetchAssetFile;
 }
-//# sourceMappingURL=asset-manager.d.ts.map

package/{esm → dist}/src/utils/asset-manager.js

@@ -1,15 +1,9 @@
-import * as dntShim from "../../_dnt.shims.js";
 import { basename, resolve } from 'node:path';
 import { fileURLToPath, URL } from 'node:url';
 import fs from 'fs-extra';
 export class AssetManager {
+    _assetsBaseUrl;
     constructor(assetsBaseUrl) {
-        Object.defineProperty(this, "_assetsBaseUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this._assetsBaseUrl = assetsBaseUrl;
     }
     async getAssetFileContent(relativePath) {
@@ -41,7 +35,7 @@ export class AssetManager {
     }
     async fetchAssetFile(relativePath) {
         const url = new URL(relativePath, this._assetsBaseUrl);
-        const response = await dntShim.fetch(url);
+        const response = await fetch(url);
         if (!response.ok) {
             throw new Error(`Failed to fetch asset file "${relativePath}" from "${url.href}": ${response.statusText} (${response.status})`);
         }

package/{esm → dist}/src/utils/class.utils.d.ts

@@ -5,4 +5,3 @@ export declare function classifyArray<TItem, TClassification extends Record<stri
 };
 export declare function isInstanceOf<T>(item: unknown, type: abstract new (...args: any[]) => T): item is T;
 export declare function getIsInstanceOf<T>(type: abstract new (...args: any[]) => T): (item: unknown) => item is T;
-//# sourceMappingURL=class.utils.d.ts.map

package/{esm → dist}/src/utils/class.utils.js

@@ -1,4 +1,3 @@
-// deno-lint-ignore-file no-explicit-any
 export function classifyArray(items, classification) {
     const result = { rest: [] };
     for (const key in classification) {

package/{script → dist}/src/utils/common.utils.d.ts

@@ -1,4 +1,4 @@
-import type { SingleOrMultiple } from './type.utils.js';
+import type { SingleOrMultiple } from './type.utils.ts';
 export declare function isNullish(value: unknown): value is null | undefined;
 export declare function notNullish<T>(value: T): value is NonNullable<T>;
 export declare function concatSingleOrMultiple<T>(...values: SingleOrMultiple<T>[]): SingleOrMultiple<T>;
@@ -13,4 +13,3 @@ export declare function runEach<T extends Iterable<unknown>>(values: T, callback
 export declare function transformEach<T, U>(values: Iterable<T>, callback: (value: T) => U): U[];
 export declare function asVoid(_: unknown): void;
 export {};
-//# sourceMappingURL=common.utils.d.ts.map

package/{esm → dist}/src/utils/condition.d.ts

@@ -1,4 +1,3 @@
 export type Condition<T = never> = boolean | ([T] extends [never] ? () => boolean : (ctx: T) => boolean);
 export declare function evalCondition(condition: Condition<never>): boolean;
 export declare function evalCondition<T>(condition: Condition<T>, ctx: T): boolean;
-//# sourceMappingURL=condition.d.ts.map

package/dist/src/utils/endpoint.utils.d.ts

@@ -0,0 +1,2 @@
+import type { ApiEndpoint } from '../transform/api-types.ts';
+export declare function getEndpointUrlPreview(endpoint: ApiEndpoint): string;

package/{esm → dist}/src/utils/error.utils.d.ts

@@ -1,2 +1 @@
 export declare function throwExp(message: string): never;
-//# sourceMappingURL=error.utils.d.ts.map

package/{esm → dist}/src/utils/factory.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor } from './type.utils.js';
+import type { Constructor } from './type.utils.ts';
 type FactoryProvider<T, TArgs extends unknown[]> = {
     kind: 'ctor';
     factory: Constructor<T, TArgs>;
@@ -11,11 +11,10 @@ type FactoryProvider<T, TArgs extends unknown[]> = {
 };
 export declare class Factory<T, TArgs extends unknown[]> {
     private readonly _provider;
-    constructor(_provider: FactoryProvider<T, TArgs>);
+    constructor(provider: FactoryProvider<T, TArgs>);
     create(...args: TArgs): T;
     static fromType<T, TArgs extends unknown[]>(type: Constructor<T, TArgs>): Factory<T, TArgs>;
     static fromFn<T, TArgs extends unknown[]>(fn: (...args: TArgs) => T): Factory<T, TArgs>;
     static fromValue<T>(value: T): Factory<T, []>;
 }
 export {};
-//# sourceMappingURL=factory.d.ts.map

package/{esm → dist}/src/utils/factory.js

@@ -1,11 +1,7 @@
 export class Factory {
-    constructor(_provider) {
-        Object.defineProperty(this, "_provider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: _provider
-        });
+    _provider;
+    constructor(provider) {
+        this._provider = provider;
     }
     create(...args) {
         switch (this._provider.kind) {

package/{esm → dist}/src/utils/file-system.utils.d.ts

@@ -1,5 +1,5 @@
-import type { OpenApiGeneratorConfig } from '../codegen/config.js';
-import type { Nullable } from './type.utils.js';
+import type { OpenApiGeneratorConfig } from '../codegen/config.ts';
+import type { Nullable } from './type.utils.ts';
 export type DirectoryScanOptions = {
     recursive: boolean;
     maxDepth: Nullable<number>;
@@ -8,4 +8,3 @@ export type DirectoryScanOptions = {
 export declare const defaultDirectoryScanOptions: DirectoryScanOptions;
 export declare function getFiles(dir: string, options?: Partial<DirectoryScanOptions>): Promise<string[]>;
 export declare function writeGeneratedFile(config: OpenApiGeneratorConfig, filePath: string, content: string): void;
-//# sourceMappingURL=file-system.utils.d.ts.map

package/{esm → dist}/src/utils/generator.utils.d.ts

@@ -1,2 +1 @@
 export declare function getInitializedValue<T>(value: T | undefined): T;
-//# sourceMappingURL=generator.utils.d.ts.map

package/{esm → dist}/src/utils/object.utils.d.ts

@@ -1,3 +1,2 @@
 export declare function createOverwriteProxy<T extends object>(target: T, values?: Partial<T>): T;
 export declare function getDeepProperty(obj: object, path: string[]): unknown;
-//# sourceMappingURL=object.utils.d.ts.map

package/{esm → dist}/src/utils/object.utils.js

@@ -11,23 +11,14 @@ export function getDeepProperty(obj, path) {
         if (!current || typeof current !== 'object') {
             return undefined;
         }
-        // deno-lint-ignore no-explicit-any
         current = current[key];
     }
     return current;
 }
 class OverwriteProxyHandler {
-    constructor() {
-        Object.defineProperty(this, "_overwrittenValues", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-    }
+    _overwrittenValues = {};
     get(target, prop) {
-        var _a;
-        return (_a = this._overwrittenValues[prop]) !== null && _a !== void 0 ? _a : target[prop];
+        return this._overwrittenValues[prop] ?? target[prop];
     }
     set(_target, prop, value) {
         this._overwrittenValues[prop] = value;

package/dist/src/utils/schema-factory.d.ts

@@ -0,0 +1,41 @@
+import type { ApiSchema, ApiSchemaBase, ApiSchemaComponent, ApiSchemaExtensions, ApiSchemaProperty } from '../transform/api-types.ts';
+export type TestSchema = Partial<Omit<ApiSchemaBase, 'required'>> & Partial<ApiSchemaComponent> & {
+    required?: string[];
+};
+export type TestOneofSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'oneOf'>, 'kind'>>;
+export type TestMultiTypeSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'multi-type'>, 'kind' | 'properties'>> & {
+    properties?: ApiSchemaProperty[];
+};
+export type TestStringSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'string'>, 'kind' | 'type'>>;
+export type TestBooleanSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'boolean'>, 'kind' | 'type'>>;
+export type TestNullSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'null'>, 'kind' | 'type'>>;
+export type TestNumberSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'number'>, 'kind' | 'type'>>;
+export type TestIntegerSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'integer'>, 'kind' | 'type'>>;
+export type TestArraySchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'array'>, 'kind' | 'type'>>;
+export type TestObjectSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'object'>, 'kind' | 'type' | 'properties'>> & {
+    properties?: ApiSchemaProperty[];
+};
+export type TestCombinedSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'combined'>, 'kind'>>;
+export type TestUnknownSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'unknown'>, 'kind'>>;
+export declare function createOneOfSchema(schema?: TestOneofSchema): ApiSchema<'oneOf'>;
+export declare function createMultiTypeSchema(schema?: TestMultiTypeSchema): ApiSchema<'multi-type'>;
+export declare function createStringSchema(schema?: TestStringSchema): ApiSchema<'string'>;
+export declare function createBooleanSchema(schema?: TestBooleanSchema): ApiSchema<'boolean'>;
+export declare function createNullSchema(schema?: TestNullSchema): ApiSchema<'null'>;
+export declare function createNumberSchema(schema?: TestNumberSchema): ApiSchema<'number'>;
+export declare function createIntegerSchema(schema?: TestIntegerSchema): ApiSchema<'integer'>;
+export declare function createArraySchema(schema?: TestArraySchema): ApiSchema<'array'>;
+export declare function createObjectSchema(schema?: TestObjectSchema): ApiSchema<'object'>;
+export declare function createCombinedSchema(schema?: TestCombinedSchema): ApiSchema<'combined'>;
+export declare function createUnknownSchema(schema?: TestUnknownSchema): ApiSchema<'unknown'>;
+export declare function createOneOfProperty(name: string, schema?: TestOneofSchema): ApiSchemaProperty;
+export declare function createMultiTypeProperty(name: string, schema?: TestMultiTypeSchema): ApiSchemaProperty;
+export declare function createStringProperty(name: string, schema?: TestStringSchema): ApiSchemaProperty;
+export declare function createBooleanProperty(name: string, schema?: TestBooleanSchema): ApiSchemaProperty;
+export declare function createNullProperty(name: string, schema?: TestNullSchema): ApiSchemaProperty;
+export declare function createNumberProperty(name: string, schema?: TestNumberSchema): ApiSchemaProperty;
+export declare function createIntegerProperty(name: string, schema?: TestIntegerSchema): ApiSchemaProperty;
+export declare function createArrayProperty(name: string, schema?: TestArraySchema): ApiSchemaProperty;
+export declare function createObjectProperty(name: string, schema?: TestObjectSchema): ApiSchemaProperty;
+export declare function createCombinedProperty(name: string, schema?: TestCombinedSchema): ApiSchemaProperty;
+export declare function createUnknownProperty(name: string, schema?: TestUnknownSchema): ApiSchemaProperty;

package/dist/src/utils/schema-factory.js

@@ -0,0 +1,132 @@
+let nextId = 0;
+function createSchemaBase(schema) {
+    const name = schema.name ?? `schema-${nextId++}`;
+    return {
+        ...schema,
+        name,
+        $src: schema.$src,
+        id: schema.id ?? name,
+        isNameGenerated: schema.isNameGenerated ?? schema.id !== undefined,
+        deprecated: schema.deprecated ?? false,
+        accessibility: schema.accessibility ?? 'all',
+        required: new Set(schema.required ?? []),
+        custom: {},
+    };
+}
+export function createOneOfSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'oneOf',
+        oneOf: schema.oneOf ?? [],
+    };
+}
+export function createMultiTypeSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'multi-type',
+        type: schema.type ?? [],
+        properties: new Map((schema.properties ?? []).map((p) => [p.name, p])),
+        allOf: schema.allOf ?? [],
+        anyOf: schema.anyOf ?? [],
+    };
+}
+export function createStringSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'string',
+        type: 'string',
+    };
+}
+export function createBooleanSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'boolean',
+        type: 'boolean',
+    };
+}
+export function createNullSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'null',
+        type: 'null',
+    };
+}
+export function createNumberSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'number',
+        type: 'number',
+    };
+}
+export function createIntegerSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'integer',
+        type: 'integer',
+    };
+}
+export function createArraySchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'array',
+        type: 'array',
+        items: schema.items ?? undefined,
+    };
+}
+export function createObjectSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'object',
+        type: 'object',
+        properties: new Map((schema.properties ?? []).map((p) => [p.name, p])),
+        allOf: schema.allOf ?? [],
+        anyOf: schema.anyOf ?? [],
+    };
+}
+export function createCombinedSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'combined',
+        allOf: schema.allOf ?? [],
+        anyOf: schema.anyOf ?? [],
+    };
+}
+export function createUnknownSchema(schema = {}) {
+    return {
+        ...createSchemaBase(schema),
+        kind: 'unknown',
+    };
+}
+export function createOneOfProperty(name, schema = {}) {
+    return { name, schema: createOneOfSchema(schema) };
+}
+export function createMultiTypeProperty(name, schema = {}) {
+    return { name, schema: createMultiTypeSchema(schema) };
+}
+export function createStringProperty(name, schema = {}) {
+    return { name, schema: createStringSchema(schema) };
+}
+export function createBooleanProperty(name, schema = {}) {
+    return { name, schema: createBooleanSchema(schema) };
+}
+export function createNullProperty(name, schema = {}) {
+    return { name, schema: createNullSchema(schema) };
+}
+export function createNumberProperty(name, schema = {}) {
+    return { name, schema: createNumberSchema(schema) };
+}
+export function createIntegerProperty(name, schema = {}) {
+    return { name, schema: createIntegerSchema(schema) };
+}
+export function createArrayProperty(name, schema = {}) {
+    return { name, schema: createArraySchema(schema) };
+}
+export function createObjectProperty(name, schema = {}) {
+    return { name, schema: createObjectSchema(schema) };
+}
+export function createCombinedProperty(name, schema = {}) {
+    return { name, schema: createCombinedSchema(schema) };
+}
+export function createUnknownProperty(name, schema = {}) {
+    return { name, schema: createUnknownSchema(schema) };
+}

package/{esm → dist}/src/utils/schema.utils.d.ts

@@ -1,5 +1,5 @@
-import type { OpenApiSchema } from '../parse/openapi-types.js';
-import type { ApiSchema } from '../transform/api-types.js';
+import type { OpenApiSchema } from '../parse/openapi-types.ts';
+import type { ApiSchema } from '../transform/api-types.ts';
 export declare function resolveAnyOfAndAllOf(schema: ApiSchema<'combined' | 'object'>, ignoreNonObjectParts: boolean): ApiSchema<'object'> | undefined;
 export declare const DEFAULT_IGNORED_SCHEMA_PROPERTIES: (keyof OpenApiSchema)[];
 /**
@@ -9,4 +9,3 @@ export declare const DEFAULT_IGNORED_SCHEMA_PROPERTIES: (keyof OpenApiSchema)[];
  * @param propertiesToIgnore The properties to ignore when checking for a schema definition.
  */
 export declare function getSchemaReference(schema: ApiSchema, propertiesToIgnore: (keyof OpenApiSchema)[]): ApiSchema;
-//# sourceMappingURL=schema.utils.d.ts.map