@conduit-client/model 3.8.0 → 3.9.0

package/dist/types/v1/parser/swagger/SwaggerAPI.d.ts

@@ -0,0 +1,50 @@
+import { type FileParserLogger, type NamedLoggerService } from '@conduit-client/utils';
+import { type SwaggerType } from './types';
+import { type ResolvedServiceOverrides } from '../../api/service-overrides';
+import { SourcePositionMap, type Position } from './source-position-map';
+import type { API, EndPoint, Server } from '../../api';
+import type { ReadOnlyTypeRegistry, TypeRegistry } from '../../types';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
+export declare const V1_VERSION = "1.0.0";
+export declare const ANONYMOUS_TYPE_NAME = "<anonymous>";
+export declare class SwaggerAPI implements API {
+    readonly document: OpenAPIV3.Document;
+    readonly sourceUrl: URL;
+    private services;
+    private fileParserLogger;
+    private positionMap;
+    typeRegistry?: TypeRegistry<SwaggerType>;
+    _endpoints?: EndPoint[];
+    _servers?: Server[];
+    annotationsVersion?: string;
+    basePath: string;
+    private built;
+    private parsedDefaultOperationCacheStrategyType?;
+    private parsedDefaultTypeCacheControl?;
+    private parsedNamespace?;
+    private defaultedNamespace;
+    serviceOverrides?: ResolvedServiceOverrides;
+    constructor(document: OpenAPIV3.Document, sourceUrl: URL, services: NamedLoggerService & NamedFeatureFlagsService, fileParserLogger: FileParserLogger, positionMap: SourcePositionMap);
+    /**
+     * Get the source position for a given JSON path in the OpenAPI document.
+     * @param jsonPath - The JSON path (e.g., "paths//users/get" or "components/schemas/User")
+     * @returns The position if found, undefined otherwise
+     */
+    getPosition(jsonPath: string): Position | undefined;
+    private build;
+    private buildEndpoints;
+    private buildServers;
+    private buildTypes;
+    get endpoints(): ReadonlyArray<EndPoint>;
+    get defaults(): API['defaults'];
+    get servers(): ReadonlyArray<Server>;
+    get types(): ReadOnlyTypeRegistry<SwaggerType>;
+    get namespace(): string;
+    checkAnnotationsVersion(): void;
+    setRootLevelAnnotations(): void;
+    /**
+     * Validates all endpoints and types. A validation error will be thrown if any are invalid.
+     */
+    validate(): void;
+}

package/dist/types/v1/parser/swagger/__tests__/parser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/swagger-api-service.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/swagger-extensions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/swagger-types.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/swagger-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/validation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/__tests__/version.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/endpoints/swagger-endpoint.d.ts

@@ -0,0 +1,30 @@
+import type { AuraController, AuraEndPoint, BaseEndPoint, HttpEndPoint, Parameter, Operation, Server } from '../../../api';
+import type { SwaggerAPI } from '../SwaggerAPI';
+import type { SwaggerType, SwaggerTypeFactory } from '../types';
+import type { TypeRegistry } from '../../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { OpenAPIV3 } from 'openapi-types';
+export type SwaggerEndPoint = SwaggerAuraEndpoint | SwaggerHttpEndPoint;
+export type NetworkPreference = 'aura' | 'http';
+export declare function swaggerEndpointFactory(pathStr: string, pathItem: OpenAPIV3.PathItemObject, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, server: Server, api: SwaggerAPI): SwaggerEndPoint | undefined;
+export declare abstract class SwaggerBaseEndpoint implements BaseEndPoint {
+    protected pathItem: OpenAPIV3.PathItemObject;
+    operations: ReadonlyArray<Operation>;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    api: SwaggerAPI;
+    path: string;
+    uriParameters: Record<string, Parameter>;
+    abstract type: 'aura' | 'http';
+    constructor(pathStr: string, pathItem: OpenAPIV3.PathItemObject, operations: ReadonlyArray<Operation>, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, api: SwaggerAPI);
+}
+export declare class SwaggerHttpEndPoint extends SwaggerBaseEndpoint implements HttpEndPoint {
+    readonly type = "http";
+}
+export declare class SwaggerAuraEndpoint extends SwaggerBaseEndpoint implements AuraEndPoint {
+    networkPreference: NetworkPreference;
+    readonly type = "aura";
+    auraController: AuraController;
+    constructor(pathStr: string, pathItem: OpenAPIV3.PathItemObject, operations: Operation[], swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, api: SwaggerAPI, networkPreference: NetworkPreference);
+    buildAuraController(): AuraController;
+}

package/dist/types/v1/parser/swagger/endpoints/swagger-operation.d.ts

@@ -0,0 +1,71 @@
+import { type LoggerService, type FileParserLogger } from '@conduit-client/utils';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { BaseAuraOperation, AuraOperationWithRequestBody, BaseOperation, HttpMethod, Request, Response, CacheStrategy, ConfigSchemaType, OperationType, ErrorStrategy, Binding, BaseHttpOperation, HttpOperationWithRequestBody, BaseGraphQLOperation } from '../../../api/endpoint';
+import type { SwaggerType, SwaggerTypeFactory } from '../types';
+import type { TypeRegistry } from '../../../types';
+import type { SwaggerEndPoint } from './swagger-endpoint';
+import type { API, Server } from '../../../api';
+import { type ResolvedOperationServices } from '../../../api/service-overrides';
+import { OperationSchemaBuilder } from '../../zod-schemas';
+export declare abstract class SwaggerBaseOperation implements BaseOperation {
+    protected operation: OpenAPIV3.OperationObject;
+    protected methodStr: string;
+    protected swaggerTypeFactory: SwaggerTypeFactory;
+    protected typeRegistry: TypeRegistry<SwaggerType>;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    endpoint: SwaggerEndPoint;
+    server: Server;
+    method: HttpMethod;
+    operationId: string | undefined;
+    requests: Request[];
+    responses: Response[];
+    operationType: OperationType;
+    configSchemaType: ConfigSchemaType;
+    errorStrategy: ErrorStrategy;
+    bindings: Binding[];
+    exposeRefresh: boolean;
+    protected parsedCacheStrategy: CacheStrategy;
+    protected operationSchemaBuilder: OperationSchemaBuilder;
+    defaults: API['defaults'];
+    serviceOverrides: ResolvedOperationServices;
+    position: {
+        line: number;
+        column: number;
+    };
+    basePath: string;
+    abstract readonly type: 'aura' | 'http';
+    constructor(operation: OpenAPIV3.OperationObject, methodStr: string, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, endpoint: SwaggerEndPoint, server: Server);
+    get cacheStrategy(): CacheStrategy;
+    private buildRequests;
+    private buildResponses;
+}
+export declare class SwaggerHttpOperation extends SwaggerBaseOperation implements BaseHttpOperation {
+    readonly type = "http";
+}
+export declare class SwaggerHttpOperationWithRequestBody extends SwaggerBaseOperation implements HttpOperationWithRequestBody {
+    readonly type = "http";
+    configBodyParam: string;
+    constructor(operation: OpenAPIV3.OperationObject, methodStr: string, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, endpoint: SwaggerEndPoint, server: Server);
+}
+export declare class SwaggerAuraOperation extends SwaggerBaseOperation implements BaseAuraOperation {
+    readonly type = "aura";
+    method: HttpMethod;
+    aura: {
+        methodName: string;
+    };
+    constructor(operation: OpenAPIV3.OperationObject, methodStr: string, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, endpoint: SwaggerEndPoint, server: Server);
+}
+export declare class SwaggerAuraOperationWithRequestBody extends SwaggerBaseOperation implements AuraOperationWithRequestBody {
+    readonly type = "aura";
+    method: HttpMethod;
+    configBodyParam: string;
+    aura: {
+        methodName: string;
+        bodyParam: string;
+    };
+    constructor(operation: OpenAPIV3.OperationObject, methodStr: string, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, endpoint: SwaggerEndPoint, server: Server);
+}
+type SwaggerBaseOperationConstructor = new (...args: any[]) => SwaggerBaseOperation & BaseOperation;
+export declare function SwaggerGraphQLOperationMixin<T extends SwaggerBaseOperationConstructor>(Base: T): T & (new (...args: any[]) => BaseGraphQLOperation);
+export {};

package/dist/types/v1/parser/swagger/index.d.ts

@@ -0,0 +1,4 @@
+export * from './swagger-api-service';
+export * from './types';
+export { getSwaggerAnnotationVersion } from './version';
+export { parseSwaggerDocument, parseUrl as parseSwaggerUrl } from './parser';

package/dist/types/v1/parser/swagger/parser.d.ts

@@ -0,0 +1,19 @@
+import { SwaggerAPI } from './SwaggerAPI';
+import { SourcePositionMap } from './source-position-map';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { FileParserLogger, NamedLoggerService } from '@conduit-client/utils';
+import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
+export interface ParsedSwaggerDocument {
+    document: OpenAPIV3.Document;
+    positionMap: SourcePositionMap;
+}
+/**
+ * Parse and validate an OpenAPI document using swagger-parser
+ * Uses bundle() instead of validate() to preserve $ref references
+ * Also extracts source position information for accurate error reporting
+ */
+export declare function parseSwaggerDocument(source: URL, logger: FileParserLogger): Promise<ParsedSwaggerDocument>;
+/**
+ * Parse an OpenAPI file and create a SwaggerAPI instance
+ */
+export declare function parseUrl(source: URL, services: NamedLoggerService & NamedFeatureFlagsService, fileParserLogger: FileParserLogger): Promise<SwaggerAPI>;

package/dist/types/v1/parser/swagger/source-position-map.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Represents a source position in a YAML file
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+/**
+ * Maps JSON paths to their source positions in the YAML file.
+ * Used to provide accurate line/column information for validation errors.
+ */
+export declare class SourcePositionMap {
+    private positions;
+    /**
+     * Get the position for a given JSON path
+     * @param jsonPath - The JSON path (e.g., "paths//users/get" or "components/schemas/User")
+     */
+    get(jsonPath: string): Position | undefined;
+    /**
+     * Set the position for a given JSON path
+     */
+    set(jsonPath: string, position: Position): void;
+    /**
+     * Check if a position exists for a given JSON path
+     */
+    has(jsonPath: string): boolean;
+    /**
+     * Get all stored paths
+     */
+    keys(): IterableIterator<string>;
+}
+/**
+ * Builds a SourcePositionMap from YAML content by parsing it with the yaml package
+ * which preserves source position information.
+ *
+ * @param yamlContent - The raw YAML content as a string
+ * @returns A SourcePositionMap containing positions for operations and schemas
+ */
+export declare function buildSourcePositionMap(yamlContent: string): SourcePositionMap;

package/dist/types/v1/parser/swagger/swagger-api-service.d.ts

@@ -0,0 +1,8 @@
+import type { NamedLoggerService } from '@conduit-client/utils';
+import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
+import type { APIService } from '../../api';
+/**
+ * Returns a new APIService based on the Swagger Parser code.
+ * @returns a new APIService
+ */
+export declare function swaggerAPIService(services: NamedLoggerService & NamedFeatureFlagsService): APIService;

package/dist/types/v1/parser/swagger/swagger-extensions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extract x-onestore extensions from an OpenAPI object
+ */
+export declare function extractExtensions(obj: object): Record<string, unknown>;
+/**
+ * Extract a specific extension value from an OpenAPI object
+ */
+export declare function getExtension<T = unknown>(obj: Record<string, unknown>, name: string): T | undefined;

package/dist/types/v1/parser/swagger/swagger-utils.d.ts

@@ -0,0 +1,37 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ScalarType } from '../../types';
+export type OpenAPISchema = OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+/**
+ * Check if an object is a reference object ($ref)
+ * Works with any OpenAPI object type that could be a reference
+ */
+export declare function isReferenceObject<T>(obj: T | OpenAPIV3.ReferenceObject): obj is OpenAPIV3.ReferenceObject;
+export declare function isSchemaObject(schema: OpenAPISchema): schema is OpenAPIV3.SchemaObject;
+export declare function isArraySchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isObjectSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isScalarSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isEnumSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isOneOfSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isAllOfSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isAnyOfSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isNotSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function isNullableSchema(schema: OpenAPIV3.SchemaObject): boolean;
+export declare function hasDiscriminator(schema: OpenAPIV3.SchemaObject): boolean;
+/**
+ * Maps OpenAPI scalar types to intermediate model scalar types
+ */
+export declare function mapScalarType(schema: OpenAPIV3.SchemaObject): ScalarType['type'];
+/**
+ * Extracts the type name from a $ref string
+ * e.g., "#/components/schemas/User" -> "User"
+ */
+export declare function getRefTypeName(ref: string): string;
+/**
+ * Coerce a value to its proper type based on the schema type
+ */
+export declare function coerceValueByType(value: unknown, type: ScalarType['type']): string | boolean | number | null;
+/**
+ * Check if schema has enum values.
+ * Throws an error if non-scalar values (objects/arrays) are found.
+ */
+export declare function getEnumValues(schema: OpenAPIV3.SchemaObject, schemaName?: string): Array<string | number | boolean | null>;

package/dist/types/v1/parser/swagger/types/SwaggerAllOfType.d.ts

@@ -0,0 +1,22 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerType } from '.';
+import type { AllOfType, DiscriminatedObjectType, Type } from '../../../types';
+export type SwaggerAllOfType = SwaggerType & AllOfType;
+export declare class SwaggerAllOfTypeImpl extends SwaggerBaseType<'allOf'> implements SwaggerAllOfType {
+    type: "allOf";
+    values?: (string | number | boolean | null)[] | undefined;
+    allOf: SwaggerType[];
+    typeResolve(): void;
+    includes(t: Type): boolean;
+    get discriminatedParent(): DiscriminatedObjectType | undefined;
+    protected validateDiscriminators(): void;
+    get extensions(): {
+        type: "unidentifiable";
+    } | {
+        type: "identifiable";
+        key: {
+            fields: Record<string, string>;
+        };
+        'cache-control': import("../../..").TypeCacheControlExtension;
+    };
+}

package/dist/types/v1/parser/swagger/types/SwaggerAnyType.d.ts

@@ -0,0 +1,7 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerType } from '.';
+import type { AnyType } from '../../../types';
+export type SwaggerAnyType = SwaggerType & AnyType;
+export declare class SwaggerAnyTypeImpl extends SwaggerBaseType<'any'> implements SwaggerAnyType {
+    type: "any";
+}

package/dist/types/v1/parser/swagger/types/SwaggerArrayType.d.ts

@@ -0,0 +1,9 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerType } from '.';
+import type { ArrayType, Type } from '../../../types';
+export type SwaggerArrayType = SwaggerType & ArrayType;
+export declare class SwaggerArrayTypeImpl extends SwaggerBaseType<'array'> implements SwaggerArrayType {
+    type: "array";
+    items: Type;
+    typeResolve(): void;
+}

package/dist/types/v1/parser/swagger/types/SwaggerBaseType.d.ts

@@ -0,0 +1,26 @@
+import type { SwaggerTypeFactory } from './factory';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { BaseType, Type, TypeExtensions, TypeRegistry } from '../../../types';
+import type { SwaggerType } from '.';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { SwaggerAPI } from '../SwaggerAPI';
+export declare abstract class SwaggerBaseType<T extends Type['type'], S extends OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject = OpenAPIV3.SchemaObject> implements BaseType {
+    api: SwaggerAPI;
+    schema: S;
+    schemaName: string | undefined;
+    protected typeRegistry: TypeRegistry<SwaggerType>;
+    protected factory: SwaggerTypeFactory;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    resolved: boolean;
+    abstract type: T;
+    parsedExtensions: TypeExtensions;
+    schemaPosition: {
+        line: number;
+        column: number;
+    };
+    constructor(api: SwaggerAPI, schema: S, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger, jsonPath?: string);
+    resolve(): void;
+    typeResolve(): void;
+    get extensions(): TypeExtensions;
+}

package/dist/types/v1/parser/swagger/types/SwaggerDiscriminatedObjectType.d.ts

@@ -0,0 +1,26 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import { type SwaggerObjectType } from './SwaggerObjectType';
+import type { SwaggerTypeProps, SwaggerType, SwaggerTypeFactory } from '.';
+import type { DiscriminatedObjectType, Type, TypeRegistry } from '../../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { SwaggerAPI } from '../SwaggerAPI';
+export type SwaggerDiscriminatedObjectType = SwaggerTypeProps & DiscriminatedObjectType;
+export declare class SwaggerDiscriminatedObjectTypeImpl extends SwaggerBaseType<'discriminatedObject'> implements SwaggerDiscriminatedObjectType {
+    readonly type = "discriminatedObject";
+    readonly baseType: SwaggerObjectType;
+    readonly discriminator: string;
+    protected _mapping: Record<string, Type> | undefined;
+    constructor(api: SwaggerAPI, schema: OpenAPIV3.SchemaObject, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+    typeResolve(): void;
+    get mapping(): Record<string, Type>;
+    private resolveDiscriminator;
+    /**
+     * Adds implicit discriminator values (i.e., type names) as mappings to types
+     */
+    private buildImplicitMapping;
+    /**
+     * Adds explicit discriminator values as mappings to types
+     */
+    private buildExplicitMapping;
+}

package/dist/types/v1/parser/swagger/types/SwaggerEnumType.d.ts

@@ -0,0 +1,13 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerTypeFactory, SwaggerTypeProps, SwaggerType } from '.';
+import type { EnumType } from '../../../types';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { TypeRegistry } from '../../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { SwaggerAPI } from '../SwaggerAPI';
+export type SwaggerEnumType = SwaggerTypeProps & EnumType;
+export declare class SwaggerEnumTypeImpl extends SwaggerBaseType<'enum'> implements SwaggerEnumType {
+    type: "enum";
+    values: Array<string | number | boolean | null>;
+    constructor(api: SwaggerAPI, schema: OpenAPIV3.SchemaObject, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}

package/dist/types/v1/parser/swagger/types/SwaggerNilType.d.ts

@@ -0,0 +1,7 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerTypeProps } from '.';
+import type { NilType } from '../../../types';
+export type SwaggerNilType = SwaggerTypeProps & NilType;
+export declare class SwaggerNilTypeImpl extends SwaggerBaseType<'nil'> implements SwaggerNilType {
+    type: "nil";
+}

package/dist/types/v1/parser/swagger/types/SwaggerNotType.d.ts

@@ -0,0 +1,13 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerTypeFactory, SwaggerTypeProps, SwaggerType } from '.';
+import type { NotType, Type } from '../../../types';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { TypeRegistry } from '../../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { SwaggerAPI } from '../SwaggerAPI';
+export type SwaggerNotType = SwaggerTypeProps & NotType;
+export declare class SwaggerNotTypeImpl extends SwaggerBaseType<'not'> implements SwaggerNotType {
+    type: "not";
+    not: Type;
+    constructor(api: SwaggerAPI, schema: OpenAPIV3.SchemaObject, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}

package/dist/types/v1/parser/swagger/types/SwaggerObjectType.d.ts

@@ -0,0 +1,13 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerTypeProps } from '.';
+import type { Property, ObjectType, Type } from '../../../types';
+export type SwaggerObjectType = SwaggerTypeProps & ObjectType;
+export declare class SwaggerObjectTypeImpl extends SwaggerBaseType<'object'> implements SwaggerObjectType {
+    type: "object";
+    properties: Record<string, Property>;
+    resolved: boolean;
+    additionalProperties: Type;
+    typeResolve(): void;
+    private resolveProperties;
+    private resolveAdditionalProperties;
+}

package/dist/types/v1/parser/swagger/types/SwaggerOneOfType.d.ts

@@ -0,0 +1,16 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { SwaggerType } from '.';
+import type { OneOf } from '../../../types';
+export type SwaggerOneOfType = SwaggerType & OneOf;
+export declare class SwaggerOneOfTypeImpl extends SwaggerBaseType<'oneOf'> implements SwaggerOneOfType {
+    type: "oneOf";
+    values?: (string | number | boolean | null)[] | undefined;
+    oneOf: SwaggerType[];
+    typeResolve(): void;
+    /**
+     * When OpenAPI has 'nullable: true' on an object with identifiable extensions,
+     * it may be represented as a oneOf with [object, null]. This method detects this pattern
+     * and preserves the identifiable extensions from the object member on the union.
+     */
+    private preserveIdentifiableExtensionsFromNullablePattern;
+}

package/dist/types/v1/parser/swagger/types/SwaggerRefType.d.ts

@@ -0,0 +1,12 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { RefType, SwaggerType, Type } from '../../../';
+import type { OpenAPIV3 } from 'openapi-types';
+export type SwaggerRefType = SwaggerType & RefType;
+export declare class SwaggerRefTypeImpl extends SwaggerBaseType<'ref', OpenAPIV3.ReferenceObject> implements SwaggerRefType {
+    type: "ref";
+    $ref: Type;
+    resolved: boolean;
+    refString: string;
+    constructor(...args: ConstructorParameters<typeof SwaggerBaseType<'ref', OpenAPIV3.ReferenceObject>>);
+    typeResolve(): void;
+}

package/dist/types/v1/parser/swagger/types/SwaggerScalarTypes.d.ts

@@ -0,0 +1,46 @@
+import { SwaggerBaseType } from './SwaggerBaseType';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { SwaggerTypeProps, SwaggerType, SwaggerTypeFactory } from '.';
+import type { BooleanType, DateTimeOnlyType, DateTimeType, DateType, DoubleType, IntegerType, NumberType, ScalarType, StringType, TimeType } from '../../../types';
+import type { TypeRegistry } from '../../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { SwaggerAPI } from '../SwaggerAPI';
+export type SwaggerBooleanType = SwaggerTypeProps & BooleanType;
+export type SwaggerDoubleType = SwaggerTypeProps & DoubleType;
+export type SwaggerIntegerType = SwaggerTypeProps & IntegerType;
+export type SwaggerNumberType = SwaggerTypeProps & NumberType;
+export type SwaggerStringType = SwaggerTypeProps & StringType;
+export type SwaggerDateType = SwaggerTypeProps & DateType;
+export type SwaggerTimeType = SwaggerTypeProps & TimeType;
+export type SwaggerDateTimeOnlyType = SwaggerTypeProps & DateTimeOnlyType;
+export type SwaggerDateTimeType = SwaggerTypeProps & DateTimeType;
+export declare abstract class SwaggerEnumerableScalarType<T extends string | number | boolean | null, S extends ScalarType['type']> extends SwaggerBaseType<S> {
+    values?: Array<T>;
+    typeResolve(): void;
+}
+export declare class SwaggerBooleanTypeImpl extends SwaggerEnumerableScalarType<boolean, 'boolean'> implements SwaggerBooleanType {
+    type: "boolean";
+}
+export declare class SwaggerDoubleTypeImpl extends SwaggerEnumerableScalarType<number, 'double'> implements SwaggerDoubleType {
+    type: "double";
+}
+export declare class SwaggerIntegerTypeImpl extends SwaggerEnumerableScalarType<number, 'integer'> implements SwaggerIntegerType {
+    type: "integer";
+}
+export declare class SwaggerNumberTypeImpl extends SwaggerEnumerableScalarType<number, 'number'> implements SwaggerNumberType {
+    type: "number";
+}
+export declare class SwaggerStringTypeImpl extends SwaggerEnumerableScalarType<string, 'string'> implements SwaggerStringType {
+    type: "string";
+}
+export declare class SwaggerDateTypeImpl extends SwaggerEnumerableScalarType<string, 'date'> implements SwaggerDateType {
+    type: "date";
+}
+declare const DATE = "date";
+declare const DATE_TIME = "date-time";
+export declare class SwaggerDateTimeImpl extends SwaggerEnumerableScalarType<string, 'datetime'> implements SwaggerDateTimeType {
+    type: "datetime";
+    format: typeof DATE | typeof DATE_TIME;
+    constructor(api: SwaggerAPI, schema: OpenAPIV3.SchemaObject, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerAnyType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerArrayType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerBaseType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerDiscriminatedObjectType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerEnumType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerNilType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerNotType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerObjectType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerOneOfType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/__tests__/SwaggerScalarType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/types/factory.d.ts

@@ -0,0 +1,22 @@
+import { type OpenAPISchema } from '../swagger-utils';
+import type { SwaggerType } from '.';
+import type { TypeRegistry, Type } from '../../../types';
+import type { SwaggerAPI } from '../SwaggerAPI';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+/**
+ * Constructs a SwaggerType based on the provided OpenAPI Schema.
+ *
+ * @param api The API
+ * @param schema The OpenAPI Schema for which a SwaggerType is to be created.
+ * @param schemaName Optional name for the schema (for named types)
+ * @param typeRegistry The TypeRegistry is searched for an existing SwaggerType.
+ * @param logger A LoggerService for logging standard operations.
+ * @param fileParserLogger A FileParserLogger for logging file parsing specific operations.
+ * @param resolve Optional boolean flag to determine if the constructed type should resolve references (default: false).
+ * @param allowedTypes Optional set of allowed type categories to limit the types constructed (default: empty set).
+ * @param skipRegistry Optional boolean flag to bypass type registry cache lookup (default: false).
+ * @param jsonPath Optional JSON path for position lookup (e.g., "components/schemas/Foo/properties/bar").
+ * @returns The constructed or retrieved SwaggerType based on the provided schema and conditions.
+ */
+export declare function swaggerTypeFactory(api: SwaggerAPI, schema: OpenAPISchema, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, resolve?: boolean, allowedTypes?: Set<Type['type']> | undefined, skipRegistry?: boolean, jsonPath?: string): SwaggerType;
+export type SwaggerTypeFactory = typeof swaggerTypeFactory;

package/dist/types/v1/parser/swagger/types/index.d.ts

@@ -0,0 +1,21 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Type } from '../../../types';
+export type SwaggerTypeProps = {
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    schemaName: string | undefined;
+    resolve: () => void;
+    resolved: boolean;
+};
+export type SwaggerType = SwaggerTypeProps & Type;
+export * from './SwaggerAnyType';
+export * from './SwaggerArrayType';
+export * from './SwaggerObjectType';
+export * from './SwaggerNilType';
+export * from './SwaggerScalarTypes';
+export * from './SwaggerOneOfType';
+export * from './SwaggerAllOfType';
+export * from './SwaggerEnumType';
+export * from './SwaggerRefType';
+export * from './SwaggerNotType';
+export * from './SwaggerDiscriminatedObjectType';
+export * from './factory';

package/dist/types/v1/parser/swagger/validation.d.ts

@@ -0,0 +1,11 @@
+import type { FileParserLogger } from '@conduit-client/utils';
+import type { SwaggerAPI } from './SwaggerAPI';
+/**
+ * Validates the @api and logs any information related to validation. Returns
+ * true when the @api model is valid and false otherwise.
+ *
+ * @param api
+ * @param fileParserLogger
+ * @returns true when the @api model is valid, false otherwise.
+ */
+export declare function isValidSwaggerAPI(api: SwaggerAPI, fileParserLogger: FileParserLogger): boolean;

package/dist/types/v1/parser/swagger/version.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import { type Version } from '@conduit-client/utils';
+/**
+ * Extracts the version from the x-onestore extension in the OpenAPI document
+ */
+export declare function getSwaggerAnnotationVersion(document: OpenAPIV3.Document): Version;