@conduit-client/model 5.67.0-dev1

package/dist/types/v1/amf/index.d.ts

@@ -0,0 +1,5 @@
+export * from './amf-api-service';
+export * from './types';
+export { V1_VERSION } from './AMFAPI';
+export { getAmfAnnotationVersion } from './version';
+export { parseAmfDocument, parseUrl } from './parser';

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

@@ -0,0 +1,6 @@
+import amf from 'amf-client-js';
+import { AMFAPI } from './AMFAPI';
+import type { FileParserLogger, NamedLoggerService } from '@conduit-client/utils';
+import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
+export declare function parseAmfDocument(source: URL, logger: FileParserLogger): Promise<amf.Document>;
+export declare function parseUrl(source: URL, services: NamedLoggerService & NamedFeatureFlagsService, fileParserLogger: FileParserLogger): Promise<AMFAPI>;

package/dist/types/v1/amf/types/AMFAllOfType.d.ts

@@ -0,0 +1,23 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFType } from '.';
+import type { AllOfType, DiscriminatedObjectType, Type } from '../../types';
+import type amf from 'amf-client-js';
+export type AMFAllOfType = AMFType & AllOfType;
+export declare class AMFAllOfTypeImpl extends AMFBaseType<'allOf', amf.AnyShape> implements AMFAllOfType {
+    type: "allOf";
+    values?: (string | number | boolean | null)[] | undefined;
+    allOf: AMFType[];
+    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/amf/types/AMFAnyType.d.ts

@@ -0,0 +1,7 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFType } from '.';
+import type { AnyType } from '../../types';
+export type AMFAnyType = AMFType & AnyType;
+export declare class AMFAnyTypeImpl extends AMFBaseType<'any'> implements AMFAnyType {
+    type: "any";
+}

package/dist/types/v1/amf/types/AMFArrayType.d.ts

@@ -0,0 +1,10 @@
+import { AMFBaseType } from './AMFBaseType';
+import type amf from 'amf-client-js';
+import type { AMFType } from '.';
+import type { ArrayType, Type } from '../../types';
+export type AMFArrayType = AMFType & ArrayType;
+export declare class AMFArrayTypeImpl extends AMFBaseType<'array', amf.ArrayShape> implements AMFArrayType {
+    type: "array";
+    items: Type;
+    typeResolve(): void;
+}

package/dist/types/v1/amf/types/AMFBaseType.d.ts

@@ -0,0 +1,25 @@
+import type { AMFTypeFactory } from './factory';
+import type amf from 'amf-client-js';
+import type { BaseType, Type, TypeExtensions, TypeRegistry } from '../../types';
+import type { AMFType } from '.';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { API } from '../../api';
+export declare abstract class AMFBaseType<T extends Type['type'], S extends amf.AnyShape = amf.AnyShape> implements BaseType {
+    api: API;
+    shape: S;
+    protected typeRegistry: TypeRegistry<AMFType>;
+    protected factory: AMFTypeFactory;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    resolved: boolean;
+    abstract type: T;
+    parsedExtensions: TypeExtensions;
+    shapePosition: {
+        line: number;
+        column: number;
+    };
+    constructor(api: API, shape: S, typeRegistry: TypeRegistry<AMFType>, factory: AMFTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+    resolve(): void;
+    typeResolve(): void;
+    get extensions(): TypeExtensions;
+}

package/dist/types/v1/amf/types/AMFDiscriminatedObjectType.d.ts

@@ -0,0 +1,34 @@
+import { AMFObjectType, type AMFType, type AMFTypeFactory, AMFTypeProps } from './index';
+import type amf from 'amf-client-js';
+import type { DiscriminatedObjectType, Type, TypeRegistry } from '../../types';
+import type { API } from '../../api';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import { AMFBaseType } from './AMFBaseType';
+export type AMFDiscriminatedObjectType = AMFTypeProps<amf.NodeShape> & DiscriminatedObjectType;
+export declare class AMFDiscriminatedObjectTypeImpl extends AMFBaseType<'discriminatedObject', amf.NodeShape> implements AMFDiscriminatedObjectType {
+    shape: amf.NodeShape;
+    protected typeRegistry: TypeRegistry<AMFType>;
+    protected factory: AMFTypeFactory;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    readonly type = "discriminatedObject";
+    readonly baseType: AMFObjectType;
+    readonly discriminator: string;
+    protected _mapping: Record<string, Type> | undefined;
+    constructor(api: API, shape: amf.NodeShape, typeRegistry: TypeRegistry<AMFType>, factory: AMFTypeFactory, 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
+     */
+    private buildImplicitMapping;
+    /**
+     * Adds explicit discriminator values as mappings to types
+     *
+     * @private
+     */
+    private buildExplicitMapping;
+}

package/dist/types/v1/amf/types/AMFEnumType.d.ts

@@ -0,0 +1,18 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFType, AMFTypeFactory, AMFTypeProps } from '.';
+import type { EnumType } from '../../types';
+import type amf from 'amf-client-js';
+import type { TypeRegistry } from '../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { API } from '../../api';
+export type AMFEnumType = AMFTypeProps & EnumType;
+export declare class AMFEnumTypeImpl extends AMFBaseType<'enum'> implements AMFEnumType {
+    shape: amf.NodeShape;
+    protected typeRegistry: TypeRegistry<AMFType>;
+    protected factory: AMFTypeFactory;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    type: "enum";
+    values: never[];
+    constructor(api: API, shape: amf.NodeShape, typeRegistry: TypeRegistry<AMFType>, factory: AMFTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}

package/dist/types/v1/amf/types/AMFNilType.d.ts

@@ -0,0 +1,7 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFTypeProps } from '.';
+import type { NilType } from '../../types';
+export type AMFNilType = AMFTypeProps & NilType;
+export declare class AMFNilTypeImpl extends AMFBaseType<'nil'> implements AMFNilType {
+    type: "nil";
+}

package/dist/types/v1/amf/types/AMFNotType.d.ts

@@ -0,0 +1,18 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFType, AMFTypeFactory, AMFTypeProps } from '.';
+import type { NotType, Type } from '../../types';
+import type amf from 'amf-client-js';
+import type { TypeRegistry } from '../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { API } from '../../api';
+export type AMFNotType = AMFTypeProps<amf.NodeShape> & NotType;
+export declare class AMFNotTypeImpl extends AMFBaseType<'not', amf.NodeShape> implements AMFNotType {
+    shape: amf.NodeShape;
+    protected typeRegistry: TypeRegistry<AMFType>;
+    protected factory: AMFTypeFactory;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    type: "not";
+    not: Type;
+    constructor(api: API, shape: amf.NodeShape, typeRegistry: TypeRegistry<AMFType>, factory: AMFTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}

package/dist/types/v1/amf/types/AMFObjectType.d.ts

@@ -0,0 +1,14 @@
+import { AMFBaseType } from './AMFBaseType';
+import type amf from 'amf-client-js';
+import type { AMFTypeProps } from '.';
+import type { Property, ObjectType, Type } from '../../types';
+export type AMFObjectType = AMFTypeProps<amf.NodeShape> & ObjectType;
+export declare class AMFObjectTypeImpl extends AMFBaseType<'object', amf.NodeShape> implements AMFObjectType {
+    type: "object";
+    properties: Record<string, Property>;
+    resolved: boolean;
+    additionalProperties: Type;
+    typeResolve(): void;
+    private resolveProperties;
+    private resolveAdditionalProperties;
+}

package/dist/types/v1/amf/types/AMFOneOfType.d.ts

@@ -0,0 +1,17 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { AMFType } from '.';
+import type { OneOf } from '../../types';
+import type amf from 'amf-client-js';
+export type AMFOneOfType = AMFType & OneOf;
+export declare class AMFOneOfTypeImpl extends AMFBaseType<'oneOf', amf.UnionShape> implements AMFOneOfType {
+    type: "oneOf";
+    values?: (string | number | boolean | null)[] | undefined;
+    oneOf: AMFType[];
+    typeResolve(): void;
+    /**
+     * When AMF encounters 'nullable: true' on an object with identifiable extensions,
+     * it converts it to 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/amf/types/AMFRefType.d.ts

@@ -0,0 +1,10 @@
+import { AMFBaseType } from './AMFBaseType';
+import type { RefType, AMFType, Type } from '../..';
+import type amf from 'amf-client-js';
+export type AMFRefType = AMFType & RefType;
+export declare class AMFRefTypeImpl extends AMFBaseType<'ref', amf.AnyShape> implements AMFRefType {
+    type: "ref";
+    $ref: Type;
+    resolved: boolean;
+    typeResolve(): void;
+}

package/dist/types/v1/amf/types/AMFScalarTypes.d.ts

@@ -0,0 +1,47 @@
+import { AMFBaseType } from './AMFBaseType';
+import type amf from 'amf-client-js';
+import type { AMFTypeProps, AMFType, AMFTypeFactory } 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 { API } from '../../api';
+export type AMFBooleanType = AMFTypeProps & BooleanType;
+export type AMFDoubleType = AMFTypeProps & DoubleType;
+export type AMFIntegerType = AMFTypeProps & IntegerType;
+export type AMFNumberType = AMFTypeProps & NumberType;
+export type AMFStringType = AMFTypeProps & StringType;
+export type AMFDateType = AMFTypeProps & DateType;
+export type AMFTimeType = AMFTypeProps & TimeType;
+export type AMFDateTimeOnlyType = AMFTypeProps & DateTimeOnlyType;
+export type AMFDateTimeType = AMFTypeProps & DateTimeType;
+export declare abstract class AMFEnumerableScalarType<T extends string | number | boolean | null, S extends ScalarType['type']> extends AMFBaseType<S> {
+    values?: Array<T>;
+    typeResolve(): void;
+}
+export declare class AMFBooleanTypeImpl extends AMFEnumerableScalarType<boolean, 'boolean'> implements AMFBooleanType {
+    type: "boolean";
+}
+export declare class AMFDoubleTypeImpl extends AMFEnumerableScalarType<number, 'double'> implements AMFDoubleType {
+    type: "double";
+}
+export declare class AMFIntegerTypeImpl extends AMFEnumerableScalarType<number, 'integer'> implements AMFIntegerType {
+    type: "integer";
+}
+export declare class AMFNumberTypeImpl extends AMFEnumerableScalarType<number, 'number'> implements AMFNumberType {
+    type: "number";
+}
+export declare class AMFStringTypeImpl extends AMFEnumerableScalarType<string, 'string'> implements AMFStringType {
+    type: "string";
+}
+export declare class AMFDateTypeImpl extends AMFEnumerableScalarType<string, 'date'> implements AMFDateType {
+    type: "date";
+}
+declare const DATE = "date";
+declare const DATE_TIME = "date-time";
+export declare class AMFDateTimeImpl extends AMFEnumerableScalarType<string, 'datetime'> implements AMFDateTimeType {
+    shape: amf.ScalarShape;
+    type: "datetime";
+    format: typeof DATE | typeof DATE_TIME;
+    constructor(api: API, shape: amf.ScalarShape, typeRegistry: TypeRegistry<AMFType>, factory: AMFTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger);
+}
+export {};

package/dist/types/v1/amf/types/__tests__/AMFAnyType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFArrayType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFBaseType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFDiscriminatedObjectType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFEnumType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFNilType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFNotType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFObjectType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFOneOfType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/AMFScalarType.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/annotations-schemas.spec.d.ts

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

package/dist/types/v1/amf/types/__tests__/factory.spec.d.ts

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

package/dist/types/v1/amf/types/annotations-schemas.d.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import { CacheStrategy } from '../..';
+export declare const cacheControl: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"max-age">;
+    'max-age': z.ZodNumber;
+    'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    'max-age': number;
+    type: "max-age";
+    'stale-while-revalidate'?: number | undefined;
+}, {
+    'max-age': number;
+    type: "max-age";
+    'stale-while-revalidate'?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"no-cache">;
+}, "strip", z.ZodTypeAny, {
+    type: "no-cache";
+}, {
+    type: "no-cache";
+}>]>;
+export declare const resourceCacheControl: z.ZodObject<{
+    'max-age': z.ZodNumber;
+    'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    'max-age': number;
+    'stale-while-revalidate'?: number | undefined;
+}, {
+    'max-age': number;
+    'stale-while-revalidate'?: number | undefined;
+}>;
+export declare const operationCacheStrategy: (defaultCacheStrategyType?: Pick<CacheStrategy, "type">) => z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"none">;
+}, "strict", z.ZodTypeAny, {
+    type: "none";
+}, {
+    type: "none";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    config: z.ZodObject<{
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+}, {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"normalized">;
+    'cache-control': z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"max-age">;
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"no-cache">;
+    }, "strip", z.ZodTypeAny, {
+        type: "no-cache";
+    }, {
+        type: "no-cache";
+    }>]>>;
+    key: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>>;
+}, "strict", z.ZodTypeAny, {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}, {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}>]>, {
+    type: "none";
+} | {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+} | {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}, unknown>;
+export declare const typeExtensions: z.ZodObject<{
+    key: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        fields: Record<string, string>;
+    }, {
+        fields: Record<string, string>;
+    }>;
+    'cache-control': z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"max-age">;
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"no-cache">;
+    }, "strip", z.ZodTypeAny, {
+        type: "no-cache";
+    }, {
+        type: "no-cache";
+    }>]>;
+}, "strict", z.ZodTypeAny, {
+    key: {
+        fields: Record<string, string>;
+    };
+    'cache-control': {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    };
+}, {
+    key: {
+        fields: Record<string, string>;
+    };
+    'cache-control': {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    };
+}>;

package/dist/types/v1/amf/types/factory.d.ts

@@ -0,0 +1,23 @@
+import type amf from 'amf-client-js';
+import type { AMFType } from '.';
+import type { TypeRegistry, Type } from '../../types';
+import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type { API } from '../../api';
+/**
+ * Constructs an AMFType based on the provided AMF Shape and a set of parameters that guide the creation process.
+ *
+ * @param api The API
+ * @param shape The AMF Shape for which an AMFType is to be created.
+ * @param typeRegistry The TypeRegistry is searched for an existing AMFType that corresponds to the shape.
+ *   If a match is found based on shape IDs, it is returned instead of creating a new AMFType.
+ * @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 (e.g., 'allOf', 'oneOf') to limit the types constructed (default: empty set).
+ * @param skipRegistry Optional boolean flag to bypass type registry cache lookup for an existing type (default: false).
+ * @returns The constructed or retrieved AMFType based on the provided shape and conditions.
+ *
+ * @throws Error if the shape type is unsupported, unrecognized, or if specific conditions like 'oneOf' are encountered without support.
+ */
+export declare function amfTypeFactory(api: API, shape: amf.Shape, typeRegistry: TypeRegistry<AMFType>, logger: LoggerService, fileParserLogger: FileParserLogger, resolve?: boolean, allowedTypes?: Set<Type['type']> | undefined, skipRegistry?: boolean): AMFType;
+export type AMFTypeFactory = typeof amfTypeFactory;

package/dist/types/v1/amf/types/index.d.ts

@@ -0,0 +1,16 @@
+import type amf from 'amf-client-js';
+import type { Type } from '../../types';
+export type AMFTypeProps<S extends amf.AnyShape = amf.AnyShape> = {
+    shape: S;
+    resolve: () => void;
+    resolved: boolean;
+};
+export type AMFType = AMFTypeProps & Type;
+export * from './AMFAnyType';
+export * from './AMFArrayType';
+export * from './AMFObjectType';
+export * from './AMFNilType';
+export * from './AMFScalarTypes';
+export * from './AMFOneOfType';
+export * from './factory';
+export * from './annotations-schemas';

package/dist/types/v1/amf/validation.d.ts

@@ -0,0 +1,11 @@
+import type { FileParserLogger } from '@conduit-client/utils';
+import type { AMFAPI } from './AMFAPI';
+/**
+ * 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 isValidAmfAPI(api: AMFAPI, fileParserlogger: FileParserLogger): boolean;

package/dist/types/v1/amf/version.d.ts

@@ -0,0 +1,3 @@
+import { type Version } from '@conduit-client/utils';
+import type amf from 'amf-client-js';
+export declare function getAmfAnnotationVersion(webApi: amf.WebApi): Version;

package/dist/types/v1/api/__tests__/api.spec.d.ts

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

package/dist/types/v1/api/api.d.ts

@@ -0,0 +1,37 @@
+import type { CacheStrategy, EndPoint, UrlParameter } from './endpoint';
+import type { ResolvedOperationServices, ResolvedServiceOverrides } from './service-overrides';
+import type { ReadOnlyTypeRegistry } from '../types';
+import type { TypeCacheControlExtension } from '../types';
+export type API = {
+    /**
+     * The set of types defined by the API.
+     */
+    types: ReadOnlyTypeRegistry;
+    /**
+     * EndPoints exposed by this API.
+     */
+    endpoints: ReadonlyArray<EndPoint>;
+    /**
+     * Servers defined by the API.
+     */
+    servers: ReadonlyArray<Server>;
+    defaults: {
+        operationCacheStrategy: Pick<CacheStrategy, 'type'>;
+        typeCacheControl?: Partial<TypeCacheControlExtension>;
+        services?: ResolvedOperationServices;
+    };
+    namespace: string;
+    /**
+     * The base path used for resolving relative file references in extensions.
+     * For YAML/JSON APIs, this is typically the directory containing the API definition file.
+     */
+    basePath: string;
+    /**
+     * Parsed and validated components-level services catalog, if provided.
+     */
+    serviceOverrides?: ResolvedServiceOverrides;
+};
+export type Server = {
+    url: string;
+    uriParameters: Record<string, UrlParameter>;
+};