@conduit-client/generator-ts 5.67.0-dev1

package/dist/types/v1/normalization/graphql-type-registry-generator.d.ts

@@ -0,0 +1,59 @@
+import { GraphQLTypeGenerator } from './graphql-type-generator';
+import type { NamedFileService, File, ImportableValueReference, ImportableReference } from '../files';
+import type { NamedService } from '@conduit-client/utils';
+import type { GraphQLSchemaModel } from '../model/graphql-schema-model';
+import type { GraphQLObjectType } from './graphql-type-generator';
+import { NamedAPIService } from '@conduit-client/model/v1';
+type GraphQLTypeRepositoryReference = {
+    propertyName: string;
+    typeClassRef: ImportableValueReference;
+    typeName: string;
+};
+type Options = {
+    type: GraphQLObjectType;
+    schemaModel: GraphQLSchemaModel;
+};
+export type IGraphQLTypeRegistryGeneratorService = {
+    build(): ImportableValueReference;
+    buildGraphQLType(options: Options): GraphQLTypeRepositoryReference;
+};
+export type NamedGraphQLTypeRegistryGeneratorService<Name extends string = 'graphqlTypeRegistryGenerator'> = NamedService<Name, IGraphQLTypeRegistryGeneratorService>;
+export declare const NAMED_CACHE_CONTROLLER_SERVICE: ImportableReference;
+export declare const NAMED_PUB_SUB_SERVICE: ImportableReference;
+export declare const TYPE_SERVICES: import("..").Code;
+/**
+ * A class for building the GraphQL type registry for a given module
+ */
+export declare class GraphQLTypeRegistryGenerator implements IGraphQLTypeRegistryGeneratorService {
+    protected services: NamedFileService & NamedAPIService;
+    protected filename: string;
+    protected graphqlTypeGenerator: GraphQLTypeGenerator;
+    constructor(services: NamedFileService & NamedAPIService, filename?: string);
+    setGraphQLTypeGenerator(generator: GraphQLTypeGenerator): void;
+    _file: File | undefined;
+    protected typeDeclarationsSymbol: symbol;
+    protected typeInstantiationsSymbol: symbol;
+    protected typeGettersSymbol: symbol;
+    cache: Map<string, GraphQLTypeRepositoryReference>;
+    private get file();
+    private buildFile;
+    get template(): (symbol | import("..").Code)[];
+    /**
+     * A method for building the base GraphQL type registry code, without any classes populated
+     */
+    build(): {
+        readonly filename: string;
+        readonly exportedSymbol: "GraphQLTypeRegistry";
+        readonly isType: false;
+    };
+    get namespace(): string;
+    /**
+     * A method for building/adding a specific GraphQL type to the registry
+     */
+    buildGraphQLType(options: Options): GraphQLTypeRepositoryReference;
+}
+/**
+ * Creates a GraphQLTypeRegistryGeneratorService.
+ */
+export declare function graphqlTypeRegistryGeneratorService(services: NamedFileService & NamedAPIService, graphqlTypeGenerator?: GraphQLTypeGenerator): IGraphQLTypeRegistryGeneratorService;
+export {};

package/dist/types/v1/normalization/identifiable-type-generator.d.ts

@@ -0,0 +1,19 @@
+import { Code } from '../files';
+import type { IdentifiableType, Type } from '@conduit-client/model/v1';
+import type { NamedNormalizedTypeDefinitionService, NamedTypeDefinitionService } from '../types';
+import type { NamedTypeRegistryGeneratorService } from './type-registry-generator';
+import { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
+/**
+ * Generates the normalizer class for an identifiable type
+ * @param services The services required for this function. TypeDefinitionService is used to generate utility types.
+ * TypeRegistryGeneratorService is used to build references to child types
+ * @param type The type to generate the normalizer for
+ * @param options Options for generating the type, including the type name, namespace, and an optional key param override
+ * @returns Class name and code for the build type class
+ */
+export declare function generateIdentifiableType(services: NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedNormalizeGeneratorService & NamedNormalizedTypeDefinitionService, type: IdentifiableType, options: {
+    className: string;
+    namespace: string;
+    name: string;
+    keyParamType?: Type;
+}): Code;

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

@@ -0,0 +1,28 @@
+export * from './normalized-type-generator';
+export * from './type-registry-generator';
+export * from './normalize-code-gen/normalize-generator-service';
+export { GraphQLTypeGenerator } from './graphql-type-generator';
+export type { GraphQLObjectType, IGraphQLTypeGenerator } from './graphql-type-generator';
+export { GraphQLTypeRegistryGenerator, graphqlTypeRegistryGeneratorService, } from './graphql-type-registry-generator';
+export type { IGraphQLTypeRegistryGeneratorService, NamedGraphQLTypeRegistryGeneratorService, } from './graphql-type-registry-generator';
+export { IdentifiableGraphQLTypeGenerator } from './graphql/identifiable-type-generator';
+export type { IdentifiableGraphQLObjectType } from './graphql/identifiable-type-generator';
+export { UnidentifiableGraphQLTypeGenerator } from './graphql/unidentifiable-type-generator';
+export type { UnidentifiableGraphQLObjectType } from './graphql/unidentifiable-type-generator';
+export { CursorConnectionGraphQLTypeGenerator } from './graphql/cursor-connection-type-generator';
+export type { CursorConnectionGraphQLObjectType } from './graphql/cursor-connection-type-generator';
+export { InterfaceGraphQLTypeGenerator } from './graphql/interface-type-generator';
+export type { InterfaceGraphQLObjectType } from './graphql/interface-type-generator';
+export { UnionGraphQLTypeGenerator } from './graphql/union-type-generator';
+export type { UnionGraphQLObjectType } from './graphql/union-type-generator';
+export { BaseGraphQLTypeGenerator } from './graphql/base-type-generator';
+export type { GenerationOptions } from './graphql/base-type-generator';
+export { generateIdentifiableGraphQLType } from './graphql/identifiable-type-generator';
+export { generateUnidentifiableGraphQLType } from './graphql/unidentifiable-type-generator';
+export { generateCursorConnectionGraphQLType } from './graphql/cursor-connection-type-generator';
+export { generateInterfaceGraphQLType } from './graphql/interface-type-generator';
+export { generateUnionGraphQLType } from './graphql/union-type-generator';
+export { TypeRegistryGenerator } from './type-registry-generator';
+export type { ITypeRegistryGeneratorService } from './type-registry-generator';
+export { NormalizedTypeGenerator } from './normalized-type-generator';
+export type { INormalizedTypeGenerator } from './normalized-type-generator';

package/dist/types/v1/normalization/normalize-code-gen/__tests__/normalize-generator-service.spec.d.ts

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

package/dist/types/v1/normalization/normalize-code-gen/__tests__/utils.d.ts

@@ -0,0 +1,15 @@
+import { BaseTypeRegistry, Type } from '@conduit-client/model/v1';
+import { NormalizeGeneratorService } from '../../normalize-code-gen/normalize-generator-service';
+export declare const baseOptions: {
+    namespace: string;
+    typeRegistryRef: import("../../..").Code;
+    cacheRef: import("../../..").Code;
+    denormalizeDataRef: import("../../..").Code;
+    normalizeDataRef: import("../../..").Code;
+    errorsRef: import("../../..").Code;
+    existingNormalizedDataRef: import("../../..").Code;
+};
+export declare function setupNormalizeGenerator(): {
+    generator: NormalizeGeneratorService;
+    typeRegistry: BaseTypeRegistry<Type>;
+};

package/dist/types/v1/normalization/normalize-code-gen/normalize-generator-service.d.ts

@@ -0,0 +1,65 @@
+import { type NamedService } from '@conduit-client/utils';
+import { Code } from '../../files';
+import { type ObjectType, type Type } from '@conduit-client/model/v1';
+import type { DiscriminatedObjectType, NamedAPIService, OneOf } from '@conduit-client/model/v1';
+import { NamedTypeRegistryGeneratorService } from '../type-registry-generator';
+import { NamedJSONSchemaDeclarationService, NamedNormalizedTypeDefinitionService, NamedTypeDefinitionService } from '../../types';
+/**
+ * The input options for the normalize generator service. Includes all the
+ * data and code references required to build an implementation of normalize & denormalize method bodies
+ */
+type Options = {
+    namespace: string;
+    typeRegistryRef: Code;
+    cacheRef: Code;
+    denormalizeDataRef: Code;
+    normalizeDataRef: Code;
+    existingNormalizedDataRef: Code;
+    errorsRef: Code;
+    useReferences?: boolean;
+};
+/**
+ * The result type of the normalize generator service
+ */
+type NormalizationCode = {
+    normalize: Code;
+    denormalize: Code;
+};
+/**
+ * An interface for a service that builds the normalization and denormalization code
+ * for a given type, given a set of code references for required variables, e.g.
+ * a type registry, the data to normalized/denormalize, etc.
+ */
+export type INormalizeGeneratorService = {
+    build(type: Type, options: Options): NormalizationCode;
+};
+/**
+ * The named service definition for the normalize generator
+ */
+export type NamedNormalizeGeneratorService = NamedService<'normalizeGenerator', INormalizeGeneratorService>;
+/**
+ * The implementation of the normalize generator service.
+ */
+export declare class NormalizeGeneratorService implements INormalizeGeneratorService {
+    protected services: NamedAPIService & NamedTypeRegistryGeneratorService & NamedTypeDefinitionService & NamedNormalizedTypeDefinitionService & NamedJSONSchemaDeclarationService;
+    constructor(services: NamedAPIService & NamedTypeRegistryGeneratorService & NamedTypeDefinitionService & NamedNormalizedTypeDefinitionService & NamedJSONSchemaDeclarationService);
+    /**
+     * The public interface method for the normalize generator service, used
+     * to build the body of denormalize/normalize methods.
+     * @param type The type to generate normalization/denormalization code for
+     * @param options The set of required input options to generate the code
+     * @returns The normalize and denormalize code
+     */
+    build(type: Type, options: Options): NormalizationCode;
+    buildNormalizeCode(type: Type, options: Options): NormalizationCode | undefined;
+    buildObjectCode(t: ObjectType, options: Options): NormalizationCode | undefined;
+    buildPropCodes(t: ObjectType, options: Options): NormalizationCode[];
+    buildAdditionalPropsCode(t: ObjectType, hasExplicitPropertiesDefined: boolean, options: Options): NormalizationCode | undefined;
+    buildOneOfCode(type: OneOf, options: Options): NormalizationCode | undefined;
+    buildDiscriminatedObjectCode(t: DiscriminatedObjectType, options: Options): {
+        normalize: Code;
+        denormalize: Code;
+    } | undefined;
+}
+export declare function normalizeGenerator(services: NamedTypeDefinitionService & NamedAPIService & NamedTypeRegistryGeneratorService & NamedJSONSchemaDeclarationService & NamedNormalizedTypeDefinitionService): NormalizeGeneratorService;
+export {};

package/dist/types/v1/normalization/normalized-type-generator.d.ts

@@ -0,0 +1,52 @@
+import type { ImportableValueReference, NamedFileService } from '../files';
+import { type Type } from '@conduit-client/model/v1';
+import type { NamedNormalizedTypeDefinitionService, NamedTypeDefinitionService } from '../types';
+import type { NamedTypeRegistryGeneratorService } from './type-registry-generator';
+import { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
+export type INormalizedTypeGenerator = {
+    build(options: {
+        namespace: string;
+        name: string;
+        type: Type;
+        keyParamType?: Type;
+    }): ImportableValueReference;
+    buildRef(options: {
+        namespace: string;
+        name: string;
+        type: Type;
+        keyParamType?: Type;
+    }): ImportableValueReference;
+};
+type Options = {
+    namespace: string;
+    name: string;
+    type: Type;
+    keyParamsType?: Type;
+};
+export declare const FILE_PER_NORMALIZED_TYPE: (typename: string) => string;
+/**
+ * A class for building normalized type class implementations
+ */
+export declare class NormalizedTypeGenerator implements INormalizedTypeGenerator {
+    protected services: NamedFileService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedNormalizeGeneratorService & NamedNormalizedTypeDefinitionService;
+    private fileFor;
+    private generateType;
+    constructor(services: NamedFileService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedNormalizeGeneratorService & NamedNormalizedTypeDefinitionService, fileFor?: (typename: string) => string, generateType?: typeof defaultGenerateType);
+    cache: Map<string, ImportableValueReference>;
+    protected typeBuildersSymbol: symbol;
+    /**
+     *
+     * @param options The options for building the type normalizer, inclduing the namespace, the name, the type, and key param overrides
+     * @returns An importable reference for the type class
+     */
+    build(options: Options): ImportableValueReference;
+    buildRef(options: Options): {
+        readonly filename: string;
+        readonly exportedSymbol: string;
+        readonly isType: false;
+    };
+}
+declare function defaultGenerateType(services: NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedNormalizeGeneratorService & NamedNormalizedTypeDefinitionService, type: Type, options: Options & {
+    className: string;
+}): import("..").Code;
+export {};

package/dist/types/v1/normalization/type-registry-generator.d.ts

@@ -0,0 +1,68 @@
+import { Code } from '../files';
+import type { NamedJSONSchemaDeclarationService, NamedNormalizedTypeDefinitionService, NamedTypeDefinitionService } from '../types';
+import type { INormalizedTypeGenerator } from './normalized-type-generator';
+import type { NamedService } from '@conduit-client/utils';
+import type { File, ImportableValueReference, NamedFileService } from '../files';
+import { NamedAPIService, type Type } from '@conduit-client/model/v1';
+import { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
+type TypeRepositoryReference = {
+    propertyName: string;
+    typeClassRef: ImportableValueReference;
+};
+type Options = {
+    name: string;
+    namespace: string;
+    keyParamType?: Type;
+    isInvalidatable?: boolean;
+};
+export type ITypeRegistryGeneratorService = {
+    build(): ImportableValueReference;
+    buildType(type: Type, options: Options): TypeRepositoryReference;
+    invalidatableTypes: TypeRepositoryReference[];
+};
+export type NamedTypeRegistryGeneratorService<Name extends string = 'typeRegistryGenerator'> = NamedService<Name, ITypeRegistryGeneratorService>;
+/**
+ * A class for building the type registry for a given module
+ */
+export declare class TypeRegistryGenerator implements ITypeRegistryGeneratorService {
+    protected services: NamedFileService & NamedTypeDefinitionService & NamedNormalizedTypeDefinitionService;
+    protected typeGenerator: INormalizedTypeGenerator;
+    protected filename: string;
+    constructor(services: NamedFileService & NamedTypeDefinitionService & NamedNormalizedTypeDefinitionService, typeGenerator: INormalizedTypeGenerator, filename?: string);
+    _file: File | undefined;
+    protected typeDeclarationsSymbol: symbol;
+    protected typeInstantiationsSymbol: symbol;
+    protected typeGettersSymbol: symbol;
+    cache: Map<string, TypeRepositoryReference>;
+    /**
+     * Note: Use with caution, it is only guaranteed to have the types with normalization
+     * after all operations precessing is complete.
+     */
+    invalidatableTypes: TypeRepositoryReference[];
+    private get file();
+    private buildFile;
+    get template(): (symbol | Code)[];
+    /**
+     * A method for building the base type registry code, without any classes populated
+     * @returns
+     */
+    build(): {
+        readonly filename: string;
+        readonly exportedSymbol: "TypeRegistry";
+        readonly isType: false;
+    };
+    /**
+     * A method for building/adding a specific type to the registry
+     * @param type The type to add to the registry
+     * @param options Options including namespace, name, and key overrides
+     * @returns The name of the method on the registry used to build the type, and an importable reference to the type class
+     */
+    buildType(type: Type, options: Options): TypeRepositoryReference;
+}
+export declare const TYPE_REGISTRY_FILE = "normalization/type-registry.ts";
+/**
+ * Creates a TypeRegistryGeneratorService.
+ *
+ **/
+export declare function typeRegistryGeneratorService(services: NamedAPIService & NamedFileService & NamedTypeDefinitionService & NamedNormalizedTypeDefinitionService & NamedJSONSchemaDeclarationService & Partial<NamedNormalizeGeneratorService>, typeGenerator?: INormalizedTypeGenerator): ITypeRegistryGeneratorService;
+export {};

package/dist/types/v1/normalization/unidentifiable-type-generator.d.ts

@@ -0,0 +1,17 @@
+import type { UnidentifiableType } from '@conduit-client/model/v1';
+import type { NamedNormalizedTypeDefinitionService, NamedTypeDefinitionService } from '../types';
+import type { NamedTypeRegistryGeneratorService } from './type-registry-generator';
+import { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
+/**
+ * Generates the normalizer class for an unidentifiable type
+ * @param services The services required for this function. TypeDefinitionService is used to generate utility types.
+ * TypeRegistryGeneratorService is used to build references to child types
+ * @param type The type to generate the normalizer for
+ * @param options Options for generating the type, including the type name and namespace
+ * @returns Class name and code for the build type class
+ */
+export declare function generateUnidentifiableType(services: NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedNormalizeGeneratorService & NamedNormalizedTypeDefinitionService, type: UnidentifiableType, options: {
+    namespace: string;
+    name: string;
+    className: string;
+}): import("..").Code;

package/dist/types/v1/normalization/utils.d.ts

@@ -0,0 +1,23 @@
+import { type ImportableReference } from '../files';
+export declare const CACHE: ImportableReference;
+export declare const READONLY_CACHE: ImportableReference;
+export declare const NORMALIZED_LINK: ImportableReference;
+export declare const READ_ERRORS: ImportableReference;
+export declare const WRITE_ERRORS: ImportableReference;
+export declare const READ_INPUT: ImportableReference;
+export declare const WRITE_INPUT: ImportableReference;
+export declare const NORMALIZE_DATA_INPUT: ImportableReference;
+export declare const DENORMALIZE_DATA_INPUT: ImportableReference;
+export declare const EXTRACT_READ_WRITE_DATA: ImportableReference;
+export declare const BUILD_READ_WRITE_RESULT: ImportableReference;
+export declare const OK: ImportableReference;
+export declare const RESULT: ImportableReference;
+export declare const READ_RESULT: ImportableReference;
+export declare const WRITE_RESULT: ImportableReference;
+export declare const DEEP_EQUALS: ImportableReference;
+export declare const NAMED_CACHE_CONTROLLER_SERVICE: ImportableReference;
+export declare const NAMED_PUB_SUB_SERVICE: ImportableReference;
+export declare const TYPE_SERVICES: import("..").Code;
+export declare const NORMALIZE_UNION_REPRESENTATION: ImportableReference;
+export declare const DENORMALIZE_UNION_REPRESENTATION: ImportableReference;
+export declare const VALIDATE_JSON_SCHEMA: ImportableReference;

package/dist/types/v1/types/__tests__/json-schema-declarations.spec.d.ts

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

package/dist/types/v1/types/__tests__/json-schema.spec.d.ts

@@ -0,0 +1,3 @@
+import { NilType, ScalarType } from '@conduit-client/model/v1';
+export declare const SCALAR_TYPES: Record<string, ScalarType>;
+export declare const NIL_TYPE: NilType;

package/dist/types/v1/types/__tests__/normalized-type-definition.spec.d.ts

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

package/dist/types/v1/types/__tests__/resolve-all-of-type.spec.d.ts

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

package/dist/types/v1/types/__tests__/type-definition.spec.d.ts

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

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

@@ -0,0 +1,4 @@
+export * from './json-schema';
+export * from './type-definition';
+export * from './json-schema-declarations';
+export * from './normalized-type-definition';

package/dist/types/v1/types/json-schema-declarations.d.ts

@@ -0,0 +1,29 @@
+import { type NamedService } from '@conduit-client/utils';
+import type { Type } from '@conduit-client/model/v1';
+import type { APIService } from '@conduit-client/model/v1';
+import type { Code, FileService } from '../files';
+/**
+ * A JsonSchemaDeclarationService constructs & tracks JSONSchema definitions for types.
+ */
+export type JsonSchemaDeclarationService = {
+    /**
+     * Returns a JSONSchema for a specified Type.
+     *
+     * @param type type to build JSON Schema for. The specified type can be a type in the TypeRegistry
+     *    associated with this service, contain references to a type in the TypeRegistry, or be a standalone
+     *    type with no connection to the TypeRegistry.
+     * @returns Code containing a TypeScript expression of the JSON schema for the type, eg "{type:'string'}"
+     *   or "{type:'object',properties:{foo:{$ref:'#/$defs/bar'}},...<ImportableReference>}". The Code will contain
+     *   ImportableReferences if the input type references any Types in the service's TypeRegistry.
+     */
+    build(type: Type): Code;
+};
+export type NamedJSONSchemaDeclarationService<Name extends string = 'jsonSchema'> = NamedService<Name, JsonSchemaDeclarationService>;
+/**
+ * Creates a JsonSchemaDeclarationService.
+ *
+ **/
+export declare function jsonSchemaDeclarationService(services: {
+    api: APIService;
+    file: FileService;
+}): JsonSchemaDeclarationService;

package/dist/types/v1/types/json-schema.d.ts

@@ -0,0 +1,15 @@
+import { type Type } from '@conduit-client/model/v1';
+import type { JSONSchema, RefType } from '@conduit-client/jsonschema-validate';
+type JsonSchemaForOptions = {
+    referenceFor?: (t: Type) => RefType | undefined;
+    useReferences?: boolean;
+};
+/**
+ * Returns the JSON schema for a specified type.
+ *
+ * @param type the type
+ * @param options Options
+ * @returns JSON schema for type
+ */
+export declare function jsonSchemaFor(type: Type, options?: JsonSchemaForOptions): JSONSchema;
+export {};

package/dist/types/v1/types/normalized-type-definition.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '@conduit-client/model/v1';
+import { Code } from '../files';
+import { TypeDefinitionForOptions, TypeDefinitionService } from './type-definition';
+import { type NamedService } from '@conduit-client/utils';
+import type { AllOfType, DiscriminatedObjectType, NamedAPIService, OneOf } from '@conduit-client/model/v1';
+import type { NamedFileService } from '../files';
+export type INormalizedTypeDefinitionService = {
+    buildReference(type: Type): Code;
+    buildRepresentation(type: Type): Code;
+};
+export declare const SINGLE_FILE_NORMALIZED: (_: string) => string;
+export declare class NormalizedTypeDefinitionService extends TypeDefinitionService implements INormalizedTypeDefinitionService {
+    constructor(services: NamedAPIService & NamedFileService, fileFor?: (typename: string) => string);
+    buildReference(t: Type): Code;
+    buildRepresentation(t: Type): Code;
+    build(type: Type | undefined, useReferences?: boolean): Code;
+    buildAllOfCode(allOfType: AllOfType, options: TypeDefinitionForOptions): Code;
+    buildOneOfCode(t: OneOf, options: TypeDefinitionForOptions): Code;
+    buildDiscriminatedObjectCode(t: DiscriminatedObjectType, options: TypeDefinitionForOptions): Code;
+    getExportedSymbol(typename: string): string;
+}
+export type NamedNormalizedTypeDefinitionService = NamedService<'normalizedTypeDefinition', INormalizedTypeDefinitionService>;
+export declare function normalizedTypeDefinitions(services: NamedAPIService & NamedFileService, options?: {
+    fileFor?: (typename: string) => string;
+}): NormalizedTypeDefinitionService;

package/dist/types/v1/types/resolve-all-of-type.d.ts

@@ -0,0 +1,16 @@
+import { AllOfType, Type } from '@conduit-client/model/v1';
+import { Result } from '@conduit-client/utils';
+/**
+ * This function is intended to collapse an allOf type into it's concrete type
+ * This is allows code generation to operate on a single, canonical type definition
+ * that has had any composition resolved. This process occurs by recursively applying
+ * intersection between all the members of the allof. If at any point an intersection
+ * results in an "impossible" type, e.g. string & number, an error is thrown.
+ *
+ * Please reference the OpenAPI spec to see the intention of composed allOfs:
+ * https://spec.openapis.org/oas/v3.1.0.html#composition-and-inheritance-polymorphism
+ * @param type The all of type to resolve
+ * @returns a resolved type
+ */
+export declare function resolveAllOfType(type: AllOfType): Type;
+export declare function intersectTypes(a: Type, b: Type): Result<Type, Error>;

package/dist/types/v1/types/type-definition.d.ts

@@ -0,0 +1,35 @@
+import { type NamedService } from '@conduit-client/utils';
+import { Code } from '../files';
+import type { ImportableReference, NamedFileService } from '../files';
+import type { DiscriminatedObjectType, ObjectType, Type, RefType, AllOfType, OneOf } from '@conduit-client/model/v1';
+import type { NamedAPIService } from '@conduit-client/model/v1';
+export type TypeDefinitionForOptions = {
+    referenceFor?: (t: Type) => ImportableReference | undefined;
+    useReferences?: boolean;
+};
+export type ITypeDefinitionService = {
+    build(type: Type | undefined): Code;
+};
+export type NamedTypeDefinitionService = NamedService<'typeDefinition', ITypeDefinitionService>;
+export declare class TypeDefinitionService implements ITypeDefinitionService {
+    protected services: NamedAPIService & NamedFileService;
+    private fileFor;
+    constructor(services: NamedAPIService & NamedFileService, fileFor?: (typename: string) => string);
+    cache: Map<string, ImportableReference>;
+    build(type: Type | undefined, useReferences?: boolean): Code;
+    buildTypeCode(t: Type, options: TypeDefinitionForOptions): Code;
+    buildReferenceCode(refType: RefType, options: TypeDefinitionForOptions): Code;
+    buildObjectCode(t: ObjectType, options: TypeDefinitionForOptions): Code;
+    buildDiscriminatedObjectCode(t: DiscriminatedObjectType, options: TypeDefinitionForOptions): Code;
+    buildObjectProperties(t: ObjectType, options: TypeDefinitionForOptions): Code[];
+    buildAdditionalProperties(t: ObjectType, options: TypeDefinitionForOptions): Code[];
+    buildAllOfCode(t: AllOfType, options: TypeDefinitionForOptions): Code;
+    buildOneOfCode(t: OneOf, options: TypeDefinitionForOptions): Code;
+    getExportedSymbol(typename: string): string;
+    buildTypeDeclaration(typename: string): ImportableReference;
+}
+export declare function typeDefinitions(services: NamedAPIService & NamedFileService, options?: {
+    fileFor?: (typename: string) => string;
+}): TypeDefinitionService;
+export declare const FILE_PER_TYPE: (typename: string) => string;
+export declare const SINGLE_FILE: (_: string) => string;

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

@@ -0,0 +1,30 @@
+import type { Parameter, Type, TypeOfParameter } from '@conduit-client/model/v1';
+/**
+ * Converts a set of parameter specification from Record<string, Parameter> to a list of named parameters info.
+ * Performs dupe parameters detection.
+ *
+ * @param records the parameter specifications to convert
+ * @returns a list of parameters info
+ */
+export declare function getParameterMembers<T extends Type = TypeOfParameter<Parameter>>(...records: Record<string, Parameter<T>>[]): {
+    name: string;
+    type: T;
+    required: boolean;
+    explode?: boolean;
+}[];
+export declare const getQueryParameterMembers: (...records: Record<string, Parameter<import("@conduit-client/model/v1").ScalarType | ({
+    type: "array";
+    items: Type;
+} & import("@conduit-client/model/v1").BaseType & {
+    items?: import("@conduit-client/model/v1").ScalarType;
+})>>[]) => {
+    name: string;
+    type: import("@conduit-client/model/v1").ScalarType | ({
+        type: "array";
+        items: Type;
+    } & import("@conduit-client/model/v1").BaseType & {
+        items?: import("@conduit-client/model/v1").ScalarType;
+    });
+    required: boolean;
+    explode?: boolean;
+}[];