@conduit-client/generator-ts 2.0.0

package/dist/types/v1/model/base-command-model.d.ts

@@ -0,0 +1,186 @@
+import { type ServiceVersion } from '@conduit-client/utils';
+import type { ImportableReference } from '../files';
+import type { Operation, Parameter, Type, QueryParameter, TypeOfParameter, HttpMethod, Binding, ResolvedOperationServices } from '@conduit-client/model/v1';
+import type { InvalidateConfig } from '@conduit-client/utils';
+export type ServiceDependency = {
+    version: ServiceVersion;
+    descriptor: ImportableReference;
+    namedService: ImportableReference;
+    localName: string;
+    serviceName: string;
+    tags?: Record<string, string>;
+    optional?: boolean;
+};
+export type CommandServiceDependencies = {
+    baseClass: ServiceDependency;
+    inherited: ServiceDependency[];
+    extra: ServiceDependency[];
+    overrides: ResolvedOperationServices;
+    defaultOverrides: ResolvedOperationServices;
+};
+export type OperationType = 'query' | 'mutation' | 'graphql';
+export type ContentModel = {
+    'application/json'?: Type;
+};
+export type CacheStrategy = {
+    type: 'none';
+} | {
+    type: 'resource';
+    config: {
+        'max-age': number;
+    };
+} | {
+    type: 'normalized';
+    'cache-control': {
+        type: 'no-cache';
+    } | {
+        type: 'max-age';
+        'max-age': number;
+    };
+    key?: Record<string, string>;
+};
+export type ErrorStrategy = {
+    type: 'stringified';
+} | {
+    type: 'fetchResponse';
+};
+export type ConfigSchemaType = 'default' | 'flattened';
+export type InvalidationConfig = {
+    statusCode: string;
+    invalidation: InvalidateConfig[];
+};
+export type NetworkPreference = 'aura' | 'http';
+export type ICommandModel = {
+    readonly transportType: 'aura' | 'http';
+    readonly className: string;
+    readonly commandName: string;
+    readonly filePath: string;
+    readonly bindings: Binding[];
+    readonly configType: Type;
+    readonly responseType: ({
+        default: ContentModel;
+    } & {
+        [statusCode: number]: ContentModel;
+    }) | undefined;
+    readonly uriParameters: {
+        name: string;
+        type: TypeOfParameter<Parameter>;
+        required: boolean;
+        explode?: boolean;
+    }[];
+    readonly queryParameters: {
+        name: string;
+        type: TypeOfParameter<QueryParameter>;
+        required: boolean;
+        explode?: boolean;
+    }[];
+    readonly headers: {
+        name: string;
+        type: TypeOfParameter<Parameter>;
+        required: boolean;
+        explode?: boolean;
+        defaultValue?: TypeOfParameter<Parameter>;
+    }[];
+    readonly body?: {
+        content: ContentModel;
+        parameterName: string;
+    };
+    getAllParams(): {
+        name: string;
+        type: TypeOfParameter<Parameter<Type>>;
+        required: boolean;
+        explode?: boolean;
+        defaultValue?: TypeOfParameter<Parameter<Type>>;
+    }[];
+    readonly serviceDependencies: CommandServiceDependencies;
+    readonly configSchemaType: ConfigSchemaType;
+    readonly exposeRefresh: boolean;
+    readonly operationType: OperationType;
+    aura?: {
+        controller: string;
+        method: string;
+        bodyParam?: string;
+    };
+    networkPreference?: NetworkPreference;
+    errorStrategy: ErrorStrategy;
+    cacheStrategy: CacheStrategy;
+    method: HttpMethod;
+    serverUrlPath: string;
+    endpointUrlPath: string;
+    invalidationConfigs: InvalidationConfig[];
+};
+/**
+ * Base abstract class for command models that encapsulates the common functionality required by all command models.
+ * It provides a structure for mapping API operations to the necessary command-specific metadata to be used for code generation.
+ */
+export declare abstract class BaseCommandModel implements ICommandModel {
+    protected operation: Operation;
+    constructor(operation: Operation);
+    abstract get serviceDependencies(): CommandServiceDependencies;
+    getAllParams(): {
+        name: string;
+        type: TypeOfParameter<Parameter<Type>>;
+        required: boolean;
+        explode?: boolean;
+    }[];
+    get transportType(): "aura" | "http";
+    /**
+     *  Defaulted in {@link ../../../../model/src/v1/amf/endpoints/amf-operation.ts#L54}
+     * */
+    get bindings(): Binding[];
+    get body(): {
+        content: ContentModel;
+        parameterName: string;
+    } | undefined;
+    get configType(): Type;
+    get responseType(): {
+        default: {
+            'application/json': Type;
+        };
+    } | undefined;
+    get uriParameters(): {
+        name: string;
+        type: import("@conduit-client/model/v1").BooleanType | import("@conduit-client/model/v1").DoubleType | import("@conduit-client/model/v1").IntegerType | import("@conduit-client/model/v1").NumberType | import("@conduit-client/model/v1").StringType | import("@conduit-client/model/v1").DateType | import("@conduit-client/model/v1").TimeType | import("@conduit-client/model/v1").DateTimeOnlyType | import("@conduit-client/model/v1").DateTimeType;
+        required: boolean;
+        explode?: boolean;
+    }[];
+    get queryParameters(): {
+        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;
+    }[];
+    get headers(): {
+        name: string;
+        type: import("@conduit-client/model/v1").ScalarType;
+        required: boolean;
+        explode?: boolean;
+    }[];
+    get commandName(): string;
+    get className(): string;
+    get filePath(): string;
+    get configSchemaType(): import("@conduit-client/model/v1").ConfigSchemaType;
+    get exposeRefresh(): boolean;
+    get operationType(): import("@conduit-client/model/v1").OperationType;
+    get errorStrategy(): import("@conduit-client/model/v1").ErrorStrategy;
+    get cacheStrategy(): import("@conduit-client/model/v1").CacheStrategy;
+    get method(): HttpMethod;
+    get serverUrlPath(): string;
+    get endpointUrlPath(): string;
+    get request(): import("@conduit-client/model/v1").Request<Type>;
+    get invalidationConfigs(): InvalidationConfig[];
+    protected buildBody(): {
+        content: ContentModel;
+        parameterName: string;
+    } | undefined;
+    protected buildResponseType(): {
+        default: {
+            'application/json': Type;
+        };
+    } | undefined;
+}

package/dist/types/v1/model/graphql-command-model-interface.d.ts

@@ -0,0 +1,12 @@
+import type { ICommandModel } from './base-command-model';
+import type { GraphQLSchemaModel } from './graphql-schema-model';
+/**
+ * Interface for GraphQL command models that extends the base command model
+ * with GraphQL-specific functionality, particularly schema access.
+ */
+export interface IGraphQLCommandModel extends ICommandModel {
+    /**
+     * The GraphQL schema model containing type information and metadata
+     */
+    readonly schema: GraphQLSchemaModel;
+}

package/dist/types/v1/model/graphql-schema-model.d.ts

@@ -0,0 +1,104 @@
+import { TypeCacheControlExtension } from '@conduit-client/model/v1';
+import { GraphQLSchema, GraphQLType, GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLField, GraphQLInputField } from 'graphql';
+export type BaseGraphQLTypeMetadata = {
+    typename: string;
+};
+export type IdentifiableGraphQLTypeMetadata = BaseGraphQLTypeMetadata & {
+    'cache-control': TypeCacheControlExtension;
+};
+export type RootGraphQLTypeMetadata = BaseGraphQLTypeMetadata & {
+    'cache-control': TypeCacheControlExtension;
+};
+export type UnidentifiableGraphQLTypeMetadata = BaseGraphQLTypeMetadata;
+export type CursorConnectionGraphQLTypeMetadata = BaseGraphQLTypeMetadata;
+export type GraphQLTypeMetadata = IdentifiableGraphQLTypeMetadata | UnidentifiableGraphQLTypeMetadata | CursorConnectionGraphQLTypeMetadata | RootGraphQLTypeMetadata;
+export type GraphQLTypeCategory = 'unidentifiable' | 'identifiable' | 'cursor-connection' | 'root';
+export type GraphQLSingleFieldType = {
+    kind: 'single';
+    name: string;
+    typename: string;
+    nullable: boolean;
+};
+export type GraphQLListFieldType = {
+    kind: 'list';
+    nullable: boolean;
+    items: GraphQLSingleFieldType | GraphQLListFieldType;
+};
+export type GraphQLFieldType = {
+    type: GraphQLSingleFieldType | GraphQLListFieldType;
+    args?: Record<string, GraphQLArgumentType>;
+    description?: string | null;
+};
+type GraphQLArgumentType = {
+    type: GraphQLSingleFieldType | GraphQLListFieldType;
+    defaultValue?: any;
+    description?: string | null;
+};
+export type GraphQLBaseTypeModel = {
+    name: string;
+    category: 'unidentifiable';
+    metadata?: UnidentifiableGraphQLTypeMetadata;
+} | {
+    name: string;
+    category: 'cursor-connection';
+    metadata?: CursorConnectionGraphQLTypeMetadata;
+} | {
+    name: string;
+    category: 'identifiable';
+    metadata: IdentifiableGraphQLTypeMetadata;
+    idField: string;
+} | {
+    name: string;
+    category: 'root';
+    metadata: RootGraphQLTypeMetadata;
+};
+export type GraphQLObjectTypeModel = {
+    kind: 'object';
+    fields: Record<string, GraphQLFieldType>;
+    interfaces?: string[];
+} & GraphQLBaseTypeModel;
+export type GraphQLUnionTypeModel = {
+    kind: 'union';
+    fields: Record<string, GraphQLFieldType>;
+    possibleTypes: GraphQLTypeModel[];
+} & GraphQLBaseTypeModel;
+type GraphQLEnumValueModel = {
+    name: string;
+    value: number;
+    description?: string | null;
+};
+export type GraphQLEnumTypeModel = {
+    kind: 'enum';
+    values: Record<string, GraphQLEnumValueModel>;
+} & GraphQLBaseTypeModel;
+type GraphQLInputObjectTypeModel = {
+    kind: 'input';
+    fields: Record<string, GraphQLFieldType>;
+} & GraphQLBaseTypeModel;
+export type GraphQLInterfaceTypeModel = {
+    kind: 'interface';
+    fields: Record<string, GraphQLFieldType>;
+    possibleTypes: GraphQLTypeModel[];
+} & GraphQLBaseTypeModel;
+export type GraphQLTypeModel = GraphQLObjectTypeModel | GraphQLUnionTypeModel | GraphQLEnumTypeModel | GraphQLInputObjectTypeModel | GraphQLInterfaceTypeModel;
+export interface GraphQLSchemaModel {
+    types: GraphQLTypeModel[];
+    queryTypeName: string;
+    mutationTypeName?: string;
+}
+/**
+ * Validates that the provided type metadata is valid for the given GraphQL schema.
+ * Ensures that:
+ * - All identifiable types have cache-control metadata
+ * - All referenced typenames exist in the schema
+ * - Metadata matches the expected category for each type
+ */
+export declare function validateGraphQLSchemaModel(typeMap: Record<string, GraphQLType>, metadataByTypename: Map<string, GraphQLTypeMetadata>, rootTypeNames: string[], defaults?: Partial<TypeCacheControlExtension>): void;
+export declare function isRelayConnectionType(type: GraphQLObjectType): boolean;
+export declare function unwrapFieldType(type: GraphQLType): GraphQLSingleFieldType | GraphQLListFieldType;
+export declare function getFieldInfo(field: GraphQLField<any, any>): GraphQLFieldType;
+export declare function getInputFieldInfo(field: GraphQLInputField): GraphQLFieldType;
+export declare function getOutputIdField(type: GraphQLObjectType | GraphQLInterfaceType): string | undefined;
+export declare function getInputIdField(type: GraphQLInputObjectType): string | undefined;
+export declare function buildGraphQLSchemaModel(schema: GraphQLSchema, typeMetadata?: GraphQLTypeMetadata[], defaults?: Partial<TypeCacheControlExtension>): GraphQLSchemaModel;
+export {};

package/dist/types/v1/model/http-command-model.d.ts

@@ -0,0 +1,32 @@
+import { BaseCommandModel, type ServiceDependency } from './base-command-model';
+export declare const INPUT_PAYLOAD_MEMBER_NAME = "inputPayload";
+/**
+ * Represents an HTTP command model that extends BaseCommandModel to handle HTTP-specific commands.
+ * This model specifically manages the input payload and service dependencies for HTTP operations.
+ */
+export declare class HttpCommandModel extends BaseCommandModel {
+    getInputPayloadParameterName(): string;
+    getAllParams(): {
+        name: string;
+        type: import("@conduit-client/model/v1").ScalarType | ({
+            type: "array";
+            items: import("@conduit-client/model/v1").Type;
+        } & import("@conduit-client/model/v1").BaseType & {
+            items?: import("@conduit-client/model/v1").ScalarType;
+        });
+        required: boolean;
+        explode?: boolean;
+    }[];
+    /**
+     * Defines and retrieves the service dependencies for the HTTP command model,
+     * including any adjustments based on the server URL indicating specific service requirements.
+     * @returns {CommandServiceDependencies} An object detailing the service dependencies.
+     */
+    get serviceDependencies(): {
+        baseClass: ServiceDependency;
+        inherited: ServiceDependency[];
+        extra: never[];
+        overrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+        defaultOverrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+    };
+}

package/dist/types/v1/model/http-graphql-command-model.d.ts

@@ -0,0 +1,16 @@
+import { GraphQLSchemaModel } from './graphql-schema-model';
+import { HttpNormalizedCachingCommandModel } from './http-normalized-caching-command-model';
+import { HttpGraphQLOperation } from '@conduit-client/model/v1';
+import type { IGraphQLCommandModel } from './graphql-command-model-interface';
+export declare class HttpGraphQLCommandModel extends HttpNormalizedCachingCommandModel implements IGraphQLCommandModel {
+    private schemaModel?;
+    constructor(operation: HttpGraphQLOperation);
+    get serviceDependencies(): {
+        baseClass: import("./base-command-model").ServiceDependency;
+        inherited: import("./base-command-model").ServiceDependency[];
+        extra: never[];
+        overrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+        defaultOverrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+    };
+    get schema(): GraphQLSchemaModel;
+}

package/dist/types/v1/model/http-normalized-caching-command-model.d.ts

@@ -0,0 +1,14 @@
+import { HttpCommandModel } from './http-command-model';
+/**
+ * Represents a command model specifically designed for handling normalized caching for HTTP transport adapters.
+ * This model extends `HttpCommandModel` and overrides the service dependencies to include cache control services.
+ */
+export declare class HttpNormalizedCachingCommandModel extends HttpCommandModel {
+    get serviceDependencies(): {
+        baseClass: import("./base-command-model").ServiceDependency;
+        inherited: import("./base-command-model").ServiceDependency[];
+        extra: never[];
+        overrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+        defaultOverrides: import("@conduit-client/model/v1").ResolvedOperationServices;
+    };
+}

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

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

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

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

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

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

package/dist/types/v1/normalization/__tests__/integration.spec.d.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+export declare function expectRegistryHasType(registryContent: string, typeName: string): void;
+export declare function expectRegistryHasInstantiation(registryContent: string, typeName: string): void;
+export declare function expectRepoFiles(serviceFileCache: Map<string, any>, typeNames: string[]): void;

package/dist/types/v1/normalization/graphql/__tests__/cursor-connection-type-generator.spec.d.ts

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

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

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

package/dist/types/v1/normalization/graphql/__tests__/interface-type-generator.spec.d.ts

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

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

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

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

@@ -0,0 +1,76 @@
+import { Code } from '../../files';
+import type { ImportableReference, NamedFileService } from '../../files';
+import type { GraphQLFieldType, GraphQLSchemaModel, GraphQLTypeModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+export declare const BASE_SCALAR_FIELD_DEF: ImportableReference;
+export declare const BASE_OBJECT_FIELD_DEF: ImportableReference;
+export declare const BASE_ARRAY_FIELD_DEF: ImportableReference;
+export declare const FIELD_DEFS: ImportableReference;
+export declare const GRAPHQL_INPUT_EXTENSION: ImportableReference;
+export declare const GRAPHQL_DATA: ImportableReference;
+export declare const GRAPHQL_TYPE_SERVICES: ImportableReference;
+export declare const GRAPHQL_PUBSUB_SERVICE: ImportableReference;
+export type GenerationOptions = {
+    namespace: string;
+    name: string;
+    className: string;
+};
+export declare abstract class BaseGraphQLTypeGenerator<T extends GraphQLTypeModel & {
+    fields?: Record<string, GraphQLFieldType>;
+    interfaces?: string[];
+}> {
+    protected services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService;
+    constructor(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService);
+    /**
+     * Determine if a GraphQL type should be treated as an object-like type
+     * that needs a repository in the type registry
+     */
+    private isObjectLikeType;
+    /**
+     * Ensure a referenced type is built and return the appropriate registry reference
+     */
+    protected ensureTypeBuiltAndGetReference(referencedType: GraphQLTypeModel, schemaModel: GraphQLSchemaModel): Code;
+    /**
+     * Generate a field definition for a single field type (recursive helper)
+     */
+    private generateSingleFieldDef;
+    /**
+     * Generate field definitions for a GraphQL type
+     */
+    protected generateFieldDefinitions(type: T, dataTypeAnnotation: string | ImportableReference, normalizedDataTypeAnnotation: string | ImportableReference, schemaModel: GraphQLSchemaModel, namespace: string): Code[];
+    /**
+     * Generate complete fields property as a getter method to avoid circular dependencies
+     */
+    protected generateFieldsProperty(type: T, dataTypeAnnotation: string | ImportableReference, normalizedDataTypeAnnotation: string | ImportableReference, schemaModel: GraphQLSchemaModel, namespace: string): Code;
+    /**
+     * Get the ImportableReference for the GraphQLTypeRegistry
+     */
+    protected getGraphQLTypeRegistryReference(): {
+        filename: string;
+        exportedSymbol: string;
+        isType: false;
+    };
+    /**
+     * Generate constructor that accepts services and type registry
+     */
+    protected generateConstructor(): Code;
+    /**
+     * Generate common properties shared by all GraphQL type repositories
+     */
+    protected generateCommonProperties(type: T, options: GenerationOptions): Code;
+    /**
+     * Generate a standard GraphQL type class with common structure
+     */
+    protected generateStandardClass(type: T, schemaModel: GraphQLSchemaModel, options: GenerationOptions, baseClass: ImportableReference, genericTypes: {
+        data: string | ImportableReference;
+        normalized: string | ImportableReference;
+    }, additionalMethods?: Code[]): Code;
+    /**
+     * Generate a standard GraphQL type class for identifiable types with key params
+     */
+    protected generateIdentifiableClass(type: T, schemaModel: GraphQLSchemaModel, options: GenerationOptions, baseClass: ImportableReference, dataTypeAnnotation: string | ImportableReference, normalizedDataTypeAnnotation: string | ImportableReference, keyParamsType: string, additionalMethods?: Code[]): Code;
+    /**
+     * Abstract method to be implemented by specific type generators
+     */
+    abstract generate(type: T, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}

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

@@ -0,0 +1,17 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLObjectTypeModel, GraphQLSchemaModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+export type CursorConnectionGraphQLObjectType = GraphQLObjectTypeModel & {
+    category: 'cursor-connection';
+    defaultPageSize?: number;
+};
+/**
+ * Cursor Connection Type MUST be an Object Type according to the Cursor Connection spec.
+ * https://relay.dev/graphql/connections.htm#sec-Connection-Types
+ */
+export declare class CursorConnectionGraphQLTypeGenerator extends BaseGraphQLTypeGenerator<CursorConnectionGraphQLObjectType> {
+    generate(type: CursorConnectionGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateCursorConnectionGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: CursorConnectionGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,13 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLObjectTypeModel, GraphQLSchemaModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+/**
+ * Query Type MUST be an Object Type according to the GraphQL spec.
+ * https://spec.graphql.org/October2021/#sec-Query
+ */
+export declare class DocumentRootTypeGenerator extends BaseGraphQLTypeGenerator<GraphQLObjectTypeModel> {
+    generate(type: GraphQLObjectTypeModel, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateDocumentRootGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: GraphQLObjectTypeModel, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,13 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLObjectTypeModel, GraphQLSchemaModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+export type IdentifiableGraphQLObjectType = GraphQLObjectTypeModel & {
+    category: 'identifiable';
+    idField: string;
+};
+export declare class IdentifiableGraphQLTypeGenerator extends BaseGraphQLTypeGenerator<IdentifiableGraphQLObjectType> {
+    generate(type: IdentifiableGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateIdentifiableGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: IdentifiableGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,10 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLSchemaModel, GraphQLInterfaceTypeModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+export type InterfaceGraphQLObjectType = GraphQLInterfaceTypeModel;
+export declare class InterfaceGraphQLTypeGenerator extends BaseGraphQLTypeGenerator<InterfaceGraphQLObjectType> {
+    generate(type: InterfaceGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateInterfaceGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: InterfaceGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,13 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLSchemaModel, GraphQLTypeModel } from '../../model/graphql-schema-model';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+export type UnidentifiableGraphQLObjectType = GraphQLTypeModel & {
+    kind: 'object';
+    category: 'unidentifiable';
+};
+export declare class UnidentifiableGraphQLTypeGenerator extends BaseGraphQLTypeGenerator<UnidentifiableGraphQLObjectType> {
+    generate(type: UnidentifiableGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateUnidentifiableGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: UnidentifiableGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,10 @@
+import { Code } from '../../files';
+import type { NamedFileService } from '../../files';
+import type { GraphQLSchemaModel, GraphQLUnionTypeModel } from '../../model/graphql-schema-model';
+import { BaseGraphQLTypeGenerator, GenerationOptions } from './base-type-generator';
+import { NamedGraphQLTypeRegistryGeneratorService } from '../graphql-type-registry-generator';
+export type UnionGraphQLObjectType = GraphQLUnionTypeModel;
+export declare class UnionGraphQLTypeGenerator extends BaseGraphQLTypeGenerator<UnionGraphQLObjectType> {
+    generate(type: UnionGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+}
+export declare function generateUnionGraphQLType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: UnionGraphQLObjectType, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;

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

@@ -0,0 +1,47 @@
+import { IdentifiableGraphQLObjectType } from './graphql/identifiable-type-generator';
+import { UnidentifiableGraphQLObjectType } from './graphql/unidentifiable-type-generator';
+import { CursorConnectionGraphQLObjectType } from './graphql/cursor-connection-type-generator';
+import { InterfaceGraphQLObjectType } from './graphql/interface-type-generator';
+import { UnionGraphQLObjectType } from './graphql/union-type-generator';
+import type { ImportableValueReference, NamedFileService, Code } from '../files';
+import type { GraphQLSchemaModel, GraphQLTypeModel } from '../model/graphql-schema-model';
+import type { GenerationOptions } from './graphql/base-type-generator';
+import { NamedGraphQLTypeRegistryGeneratorService } from './graphql-type-registry-generator';
+export declare const FILE_PER_GRAPHQL_TYPE: (typename: string) => string;
+export interface IGraphQLTypeGenerator {
+    build(options: {
+        namespace: string;
+        name: string;
+        schemaModel: GraphQLSchemaModel;
+    }): ImportableValueReference;
+    buildRef(options: {
+        namespace: string;
+        name: string;
+    }): ImportableValueReference;
+}
+declare function defaultGenerateType(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, type: GraphQLTypeModel, schemaModel: GraphQLSchemaModel, options: GenerationOptions): Code;
+export type GraphQLObjectType = IdentifiableGraphQLObjectType | UnidentifiableGraphQLObjectType | CursorConnectionGraphQLObjectType | InterfaceGraphQLObjectType | UnionGraphQLObjectType;
+/**
+ * A class for building GraphQL type repository implementations
+ */
+export declare class GraphQLTypeGenerator implements IGraphQLTypeGenerator {
+    protected services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService;
+    private fileFor;
+    private generateType;
+    private cache;
+    constructor(services: NamedFileService & NamedGraphQLTypeRegistryGeneratorService, fileFor?: (typename: string) => string, generateType?: typeof defaultGenerateType);
+    /**
+     * Build a GraphQL type repository class, starting from the specified type name
+     * and spidering out to referenced types as needed
+     */
+    build(options: {
+        namespace: string;
+        name: string;
+        schemaModel: GraphQLSchemaModel;
+    }): ImportableValueReference;
+    buildRef(options: {
+        namespace: string;
+        name: string;
+    }): ImportableValueReference;
+}
+export {};