@conduit-client/generator-ts 5.67.0-dev1

package/dist/types/v1/generators/base-command-generator.d.ts

@@ -0,0 +1,88 @@
+import { type Code, type ImportableTypeReference, type NamedFileService } from '../files';
+import type { NamedAPIService } from '@conduit-client/model/v1';
+import type { NamedTypeRegistryGeneratorService } from '../normalization/type-registry-generator';
+import type { NamedJSONSchemaDeclarationService, NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+export type ICommandGenerator = {
+    build(): void;
+};
+/**
+ * Abstract base class for generating command files based on a command model and associated services.
+ *
+ * This class provides a framework for generating files associated with commands, including type definitions,
+ * JSON schemas, and class templates. It leverages protected symbols to encapsulate template pieces,
+ * facilitating the extension and customization in subclasses.
+ *
+ * The commandBaseClass abstract property must reference a type only, importable reference that references the base class that the generated command
+ * will reference. For example, the HTTP concretion of this class would reference:
+ * ```
+ * {
+ *  module: '@conduit-client/command-fetch-network/v1',
+ *  exportedSymbol: 'FetchNetworkCommand',
+ *  isType: true,
+ * }
+ * ```
+ * which corresponds to the import: `import {type FetchNetworkCommand} from '@conduit-client/command-fetch-network/v1'`.
+ *
+ * The class body abstract command provides a hook for concretions to implement whatever contract is required
+ * by their base class. By convention, the concrete implementations of `classBody` should delegate to a method for
+ * each property & class method that is implemented.
+ *
+ * None of the other properties are expected to be overridden in subclasses.
+ *
+ * @abstract
+ * @property {ICommandModel} commandModel - The command model that provides metadata and configuration for generating command files.
+ * @property {NamedFileService & NamedJSONSchemaDeclarationService & NamedTypeDefinitionService} services - Services required for file generation, type definition, and JSON schema generation.
+ */
+export declare abstract class CommandGenerator {
+    protected commandModel: ICommandModel;
+    protected services: NamedAPIService & NamedFileService & NamedJSONSchemaDeclarationService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService;
+    constructor(commandModel: ICommandModel, services: NamedAPIService & NamedFileService & NamedJSONSchemaDeclarationService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService);
+    protected commandTypeGenericsSymbol: symbol;
+    protected commandConfigSchemaSymbol: symbol;
+    protected commandConfigTypeSymbol: symbol;
+    protected commandClassBodySymbol: symbol;
+    protected commandOptionsTypeSymbol: symbol;
+    abstract get commandBaseClass(): ImportableTypeReference;
+    get classBody(): Code[];
+    get commandTypeConstructorArgs(): Code;
+    get commandConstructorArgs(): Code;
+    get exposeSubscribeAndRefresh(): Code;
+    /**
+     * Generates the Command type definition.
+     * Can be overridden by subclasses to customize the Command type signature.
+     */
+    protected generateCommandType(): Code;
+    /**
+     * Generates the constructor for the command class.
+     * Can be overridden by subclasses to customize constructor behavior.
+     */
+    protected generateConstructor(): Code;
+    /**
+     * Generates the operationType getter for the concrete command class.
+     * Subclasses (e.g., GraphQL mixins) can override to emit nothing.
+     */
+    protected generateOperationType(): Code;
+    /**
+     * Template for generating the command file content.
+     * This getter constructs the full template array incorporating various symbols for later replacement in the build process.
+     * @returns {Code[]} An array of code blocks forming the complete command file template.
+     */
+    get template(): (symbol | Code)[];
+    /**
+     * Builds the command file by assembling various components into a file structure and saving it.
+     * This method orchestrates the generation of necessary types, configurations, and class bodies.
+     */
+    build(): void;
+    protected buildCommandConfigType(): Code;
+    protected buildCommandConfigSchema(): Code;
+    protected buildCommandOptionsType(): Code;
+    protected buildCommandTypeGenerics(): Code;
+    protected buildExtraServices(): Code | undefined;
+    protected generateAfterRequestHooks(): Code;
+    private getInvalidationStatements;
+    private generateInvalidationSwitch;
+    private generateInvalidationCasesByStatusCode;
+    protected buildMappedKeyConfig(operationKey: Record<string, string>): Code;
+    private pathToAccessor;
+}

package/dist/types/v1/generators/bindings-generator.d.ts

@@ -0,0 +1,69 @@
+import { Code, type NamedFileService } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import { ImperativeAdapterBindingGenerator } from './imperative-binding-generator';
+import { ImperativeAdapterLegacyBindingGenerator } from './imperative-legacy-binding-generator';
+import { GraphQLImperativeAdapterLegacyBindingGenerator } from './graphql-imperative-legacy-binding-generator';
+import { WireAdapterBindingGenerator } from './wire-binding-generator';
+import type { ICommandModel, ServiceDependency } from '../model/base-command-model';
+import type { NamedTypeRegistryGeneratorService, TypeRegistryGenerator } from '../normalization/type-registry-generator';
+import type { NamedGraphQLTypeRegistryGeneratorService } from '../normalization/graphql-type-registry-generator';
+import { Binding, NamedAPIService } from '@conduit-client/model/v1';
+import { GraphQLImperativeAdapterBindingGenerator } from './graphql-imperative-binding-generator';
+import { GraphQLWireAdapterBindingGenerator } from './graphql-wire-binding-generator';
+import { GraphQLMutationAdapterBindingGenerator } from './graphql-mutation-binding-generator';
+export type IBindingsGenerator = {
+    build(): void;
+};
+export declare function defaultAdapterBindingsGeneratorFactory(services: NamedTypeDefinitionService, model: ICommandModel, binding: Binding): ImperativeAdapterBindingGenerator | ImperativeAdapterLegacyBindingGenerator | WireAdapterBindingGenerator | GraphQLImperativeAdapterBindingGenerator | GraphQLImperativeAdapterLegacyBindingGenerator | GraphQLWireAdapterBindingGenerator | GraphQLMutationAdapterBindingGenerator;
+/**
+ * Class responsible for generating binding files based on command models and service dependencies.
+ *
+ * The `BindingsGenerator` class orchestrates the creation of files that manage service dependencies,
+ * adapters, and invocation logic for a given set of command models. It provides a template for the binding
+ * structure and manages the generation and integration of individual adapter bindings.
+ *
+ * The expectation for new bindings is that new *BindingGenerator classes are used inside of the build method.
+ *
+ * @property {NamedFileService & NamedTypeDefinitionService} services - Services required for file handling and type definitions.
+ * @property {ICommandModel[]} commandModels - Array of command models to generate bindings for.
+ */
+export declare class BindingsGenerator {
+    protected services: NamedAPIService & NamedFileService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedGraphQLTypeRegistryGeneratorService;
+    protected commandModels: ICommandModel[];
+    protected adapterBindingsGeneratorFactory: typeof defaultAdapterBindingsGeneratorFactory;
+    constructor(services: NamedAPIService & NamedFileService & NamedTypeDefinitionService & NamedTypeRegistryGeneratorService & NamedGraphQLTypeRegistryGeneratorService, commandModels: ICommandModel[], adapterBindingsGeneratorFactory?: typeof defaultAdapterBindingsGeneratorFactory);
+    protected adapterDeclarationSymbol: symbol;
+    protected serviceRequirementsSymbol: symbol;
+    protected adapterInvocationSymbol: symbol;
+    protected typeRegistryInstantiationSymbol: symbol;
+    protected typeInvalidationDeclarationSymbol: symbol;
+    protected typeInvalidationDefinitionSymbol: symbol;
+    protected rootTypesInstantiationSymbol: symbol;
+    /**
+     * Template for generating the binding structure in the output file.
+     * Includes placeholders for adapter declarations, service requirements, and adapter invocations.
+     *
+     * Bindings files are structured as:
+     * 1. Adapter declarations -> an export of the wire or imperative adapter that is initially undefined, but has proper typescript typing
+     * 2. Service requirements -> a declaration of what services this module depends on from the service provisioner
+     * 3. Adapter instantiation/invocation -> Creation and population of the declaration with a real adapter implementation, after
+     *    all the required services have been received.
+     *
+     * @returns {Code[]} An array of code blocks forming the template for the binding output file.
+     */
+    get template(): (symbol | Code)[];
+    protected get serviceDependencies(): ServiceDependency[];
+    /**
+     * Builds the binding file, generating declarations, requirements, and invocations for each command model.
+     * This method coordinates with individual binding generators to compile the necessary elements into a single file.
+     */
+    build(): void;
+    buildTypeInvalidation(typesWithNormalization: TypeRegistryGenerator['invalidatableTypes']): {
+        definitions: Code[];
+        declarations: Code[];
+    };
+    protected buildRequirements(): Code;
+    protected get hasRESTNormalization(): boolean;
+    protected get hasGraphQL(): boolean;
+    protected get hasImperativeBindings(): boolean;
+}

package/dist/types/v1/generators/cache-control-generator.d.ts

@@ -0,0 +1,2 @@
+import { TypeCacheControlExtension } from '@conduit-client/model/v1';
+export declare function generateCacheControl(cacheControl: TypeCacheControlExtension): import("..").Code;

package/dist/types/v1/generators/command-config-builder.d.ts

@@ -0,0 +1,28 @@
+import { type Operation, type Type } from '@conduit-client/model/v1';
+import type { ContentModel } from '../model/base-command-model';
+/**
+ * Class for building command configurations based on an operation and its associated parameters.
+ * This builder handles the construction of an object type structure that encapsulates various parameters
+ * from an operation, including query parameters, headers, URI parameters, and potentially a payload.
+ *
+ * @property {Operation} operation - The operation object that provides context for the command configuration.
+ * @property {{ type: Type; name: string } | undefined} payload - Optional payload definition that specifies the type and name of the main data structure if needed.
+ */
+export declare class CommandConfigBuilder {
+    protected operation: Operation;
+    protected payload?: {
+        content: ContentModel;
+        parameterName: string;
+    } | undefined;
+    constructor(operation: Operation, payload?: {
+        content: ContentModel;
+        parameterName: string;
+    } | undefined);
+    /**
+     * Builds and returns an object type configuration based on the initial operation and the optional payload.
+     * This method organizes various request parameters into a structured type definition, suitable for generating type-safe command configurations.
+     *
+     * @returns {ObjectType} The complete configuration type for the command, encapsulating all necessary parameters and payload definitions.
+     */
+    build(): Type;
+}

package/dist/types/v1/generators/graphql-imperative-binding-generator.d.ts

@@ -0,0 +1,23 @@
+import { type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class GraphQLImperativeAdapterBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    protected commandOptionsTypeImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    buildDeclaration(): import("..").Code;
+    get bindingTypeCode(): import("..").Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    get returnShape(): import("..").Code;
+    get invoker(): import("..").Code;
+    get exposeRefresh(): import("..").Code;
+    isSubscribable(): boolean;
+    buildInvocation(servicesName?: string): import("..").Code;
+}

package/dist/types/v1/generators/graphql-imperative-legacy-binding-generator.d.ts

@@ -0,0 +1,18 @@
+import { type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class GraphQLImperativeAdapterLegacyBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    get responseTypeCode(): import("..").Code;
+    buildDeclaration(): import("..").Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    buildInvocation(servicesName?: string): import("..").Code;
+}

package/dist/types/v1/generators/graphql-mutation-binding-generator.d.ts

@@ -0,0 +1,21 @@
+import { type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class GraphQLMutationAdapterBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    protected commandOptionsTypeImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    buildDeclaration(): import("..").Code;
+    get bindingTypeCode(): import("..").Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    get returnShape(): import("..").Code;
+    get invoker(): import("..").Code;
+    buildInvocation(servicesName?: string): import("..").Code;
+}

package/dist/types/v1/generators/graphql-normalized-cache-control-generator-mixin.d.ts

@@ -0,0 +1,13 @@
+import { type ImportableTypeReference } from '../files';
+import type { CommandGenerator } from './base-command-generator';
+import type { NormalizedCacheControlGenerator } from './normalized-cache-control-generator-mixin';
+type Constructor = new (...args: any[]) => CommandGenerator & NormalizedCacheControlGenerator;
+/**
+ * Mixin that adds GraphQL-specific functionality to command generators.
+ * This mixin modifies command generators to work with GraphQL operations by:
+ * 1. Using DocumentNode for the query config type instead of string
+ * 2. Adding documentRootType parameter to constructor
+ * 3. Generating GraphQL-specific methods like buildRequestQuery
+ */
+export declare function GraphQLNormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference): Constructor;
+export {};

package/dist/types/v1/generators/graphql-root-variable-names.d.ts

@@ -0,0 +1,2 @@
+export declare const QUERY_TYPE_VARIABLE_NAME: "queryType";
+export declare const MUTATION_TYPE_VARIABLE_NAME: "mutationType";

package/dist/types/v1/generators/graphql-wire-binding-generator.d.ts

@@ -0,0 +1,18 @@
+import { type Code, type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class GraphQLWireAdapterBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    get responseTypeCode(): Code;
+    buildDeclaration(): Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    buildInvocation(servicesName?: string): Code;
+}

package/dist/types/v1/generators/http-command-generator.d.ts

@@ -0,0 +1,67 @@
+import { Code } from '../files';
+import { CommandGenerator } from './base-command-generator';
+import type { ImportableTypeReference } from '../files';
+import { type Type } from '@conduit-client/model/v1';
+export declare const MEDIATYPE_APP_JSON = "application/json";
+/**
+ * Extends CommandGenerator to provide functionality for generating command files specifically designed for HTTP operations.
+ *
+ * This class specializes in creating files that include detailed HTTP-specific configurations such as fetch parameters,
+ * header construction, query parameters, and error handling, tailored to interact with web APIs using the fetch API.
+ *
+ * @extends CommandGenerator
+ */
+export declare class HttpCommandGenerator extends CommandGenerator {
+    commandBaseClass: ImportableTypeReference;
+    /**
+     * Constructs and returns an array of code blocks that form the body of the HTTP command class.
+     * Includes methods for generating fetch parameters and error coercion logic.
+     * @returns {Code[]} An array of code snippets that define the command class body for HTTP operations.
+     */
+    get classBody(): Code[];
+    /**
+     * Generates a code block for fetch parameters based on the command model's configuration.
+     * Constructs a detailed setup for fetch operations including method, headers, body, and cache settings.
+     * @returns {Code} A comprehensive code snippet that defines all necessary fetch parameters.
+     */
+    generateFetchParams(): Code;
+    /**
+     * Constructs the base URL for the fetch command.
+     * @returns {Code} A code snippet that defines the URL to be used in fetch operations.
+     */
+    generateUrl(): Code;
+    /**
+     * Generates headers necessary for the HTTP fetch based on the command model's requirements.
+     * Handles conditional inclusion of headers based on their defined necessity and request body presence.
+     * @returns {object} An object containing the header names and the corresponding code to create them.
+     */
+    generateHeaders(): Code | undefined;
+    /**
+     * Constructs a setup for handling query parameters within the URL for the fetch operation.
+     * @returns {object} An object containing the parameter names and the corresponding code to handle them.
+     */
+    generateQueryParameters(): Code | undefined;
+    /**
+     * Generates a consolidated list of all parameters involved in the fetch operation.
+     * @returns {Code} A code block that consolidates all necessary parameters from headers, query, and URI.
+     */
+    generateAllParams(): Code;
+    /**
+     * Determines the code snippet for destructuring the input payload based on the configuration schema type.
+     * @returns {Code | undefined} A code snippet for the input payload parameter, if applicable.
+     */
+    generateInputPayloadParameter(): Code | undefined;
+    /**
+     * Encodes a parameter based on its type.
+     * @param {string} name The name of the parameter to encode.
+     * @param {Type} type The type descriptor of the parameter.
+     * @returns {string | undefined} The encoded parameter value as a string, or undefined if the type is unsupported.
+     */
+    encodeParam(name: string, type: Type, required: boolean): string | undefined;
+    /**
+     * Processes the URL with replacements for URI parameters based on their values specified in the command model.
+     * @returns {string} The fully constructed URL with all necessary URI parameter substitutions.
+     */
+    processUrl(): string;
+    generateCoerceError(): Code;
+}

package/dist/types/v1/generators/http-graphql-normalized-cache-control-command-generator.d.ts

@@ -0,0 +1 @@
+export declare const HttpGraphQLNormalizedCacheControlCommandGenerator: new (...args: any[]) => import("./base-command-generator").CommandGenerator & import("./normalized-cache-control-generator-mixin").NormalizedCacheControlGenerator;

package/dist/types/v1/generators/http-normalized-cache-control-command-generator.d.ts

@@ -0,0 +1 @@
+export declare const HttpNormalizedCacheControlCommandGenerator: new (...args: any[]) => import("./base-command-generator").CommandGenerator & import("./normalized-cache-control-generator-mixin").NormalizedCacheControlGenerator;

package/dist/types/v1/generators/imperative-binding-generator.d.ts

@@ -0,0 +1,24 @@
+import { type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class ImperativeAdapterBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    protected commandOptionsTypeImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    buildDeclaration(): import("..").Code;
+    get bindingTypeCode(): import("..").Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    get returnShape(): import("..").Code;
+    get responseTypeCode(): import("..").Code;
+    get invoker(): import("..").Code;
+    get exposeRefresh(): import("..").Code;
+    isSubscribable(): boolean;
+    buildInvocation(servicesName?: string): import("..").Code;
+}

package/dist/types/v1/generators/imperative-legacy-binding-generator.d.ts

@@ -0,0 +1,18 @@
+import { type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class ImperativeAdapterLegacyBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    get responseTypeCode(): import("..").Code;
+    buildDeclaration(): import("..").Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    buildInvocation(servicesName?: string): import("..").Code;
+}

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

@@ -0,0 +1,9 @@
+export * from './aura-command-generator';
+export * from './aura-resource-cache-control-command-generator';
+export * from './base-command-generator';
+export * from './bindings-generator';
+export * from './command-config-builder';
+export * from './http-command-generator';
+export * from './http-graphql-normalized-cache-control-command-generator';
+export * from './api-family-module-generator';
+export * from './graphql-normalized-cache-control-generator-mixin';

package/dist/types/v1/generators/normalized-cache-control-generator-mixin.d.ts

@@ -0,0 +1,15 @@
+import { Code, ImportableTypeReference } from '../files';
+import type { CommandGenerator } from './base-command-generator';
+export interface NormalizedCacheControlGenerator {
+    generateCacheControlStrategyConfig(): Code;
+}
+type Constructor = new (...args: any[]) => CommandGenerator;
+type NormalizedCacheControlConstructor = new (...args: any[]) => CommandGenerator & NormalizedCacheControlGenerator;
+/**
+ *
+ * @param Base The base class to mix in the normalized code generation logic to
+ * @param commandBaseClass An importable refernce to the command base class to use in the generated code
+ * @returns A new class with the normalized generation behavior mixed in
+ */
+export declare function NormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference): NormalizedCacheControlConstructor;
+export {};

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

@@ -0,0 +1,17 @@
+import { type Code } from '../files';
+import { ICommandModel } from '../model/base-command-model';
+/**
+ * Generates a destructuring assignment code block for a given property name, ensuring that the variable names are valid TypeScript identifiers.
+ * This function is particularly useful when dealing with property names that may not directly translate into valid TypeScript variable names,
+ * such as names containing special characters.
+ *
+ * @param propertyName - The original property name to be destructured from an object.
+ * @returns An object containing:
+ *   - `code`: a `Code` type representing the TypeScript code for destructuring the property.
+ *   - `variableName`: a string that represents the valid TypeScript identifier to which the property value is assigned.
+ */
+export declare function buildPropertyDestructureDeclaration(propertyName: string): {
+    code: Code;
+    variableName: string;
+};
+export declare function buildServiceProjection(model: ICommandModel): string[];

package/dist/types/v1/generators/wire-binding-generator.d.ts

@@ -0,0 +1,19 @@
+import { type Code, type ImportableReference } from '../files';
+import { type NamedTypeDefinitionService } from '../types';
+import type { ICommandModel } from '../model/base-command-model';
+import { Binding } from '@conduit-client/model/v1';
+export declare class WireAdapterBindingGenerator {
+    protected services: NamedTypeDefinitionService;
+    protected commandModel: ICommandModel;
+    protected binding: Binding;
+    protected commandConfigTypeImport: ImportableReference;
+    protected commandConfigSchemaImport: ImportableReference;
+    protected classBuilderImport: ImportableReference;
+    constructor(services: NamedTypeDefinitionService, commandModel: ICommandModel, binding: Binding);
+    get responseTypeCode(): Code;
+    buildDeclaration(): Code;
+    get localCommandConstructorName(): string;
+    get localCommandModel(): ICommandModel;
+    buildInvocation(servicesName?: string): Code;
+    getTypeRegistryArgument(): Code;
+}

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

@@ -0,0 +1,4 @@
+export * from './files';
+export * from './types';
+export * from './normalization';
+export * from './api-module-generator-service';

package/dist/types/v1/model/__tests__/aura-command-model.spec.d.ts

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

package/dist/types/v1/model/__tests__/aura-graphql-command-model.spec.d.ts

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

package/dist/types/v1/model/__tests__/aura-normalized-caching-command-model.spec.d.ts

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

package/dist/types/v1/model/__tests__/aura-resource-caching-command-model.spec.d.ts

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

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

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

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

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

package/dist/types/v1/model/__tests__/graphql-utils.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLObjectType, GraphQLInterfaceType, GraphQLEnumType, GraphQLUnionType, GraphQLInputObjectType, GraphQLSchema } from 'graphql';
+export declare const UserType: GraphQLObjectType<any, any>;
+export declare const NestedUserType: GraphQLObjectType<any, any>;
+export declare const EpisodeEnum: GraphQLEnumType;
+export declare const NodeInterface: GraphQLInterfaceType;
+export declare const CharacterInterface: GraphQLInterfaceType;
+export declare const HumanObject: GraphQLObjectType<any, any>;
+export declare const DroidObject: GraphQLObjectType<any, any>;
+export declare const StarshipObject: GraphQLObjectType<any, any>;
+export declare const SearchResultUnion: GraphQLUnionType;
+export declare const SearchResultObject: GraphQLObjectType<any, any>;
+export declare const ReviewInput: GraphQLInputObjectType;
+export declare const ReviewObject: GraphQLObjectType<any, any>;
+export declare const MutationObject: GraphQLObjectType<any, any>;
+export declare const MultipleIdObject: GraphQLObjectType<any, any>;
+export declare const UserConnectionObject: GraphQLObjectType<any, any>;
+export declare const exampleSchema: GraphQLSchema;

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { BaseCommandModel, type CommandServiceDependencies } from './base-command-model';
+/**
+ * Represents a command model for Aura-specific operations, extending the functionalities of the BaseCommandModel.
+ * This class is used to model Aura specific code metadata from the API model.
+ */
+export declare class AuraCommandModel extends BaseCommandModel {
+    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;
+    }[];
+    get networkPreference(): import("@conduit-client/model/v1").NetworkPreference;
+    /**
+     * Gets the Aura controller and method associated with the operation.
+     * @returns {object} An object containing the `controller` and `method` names.
+     */
+    get aura(): {
+        controller: string;
+        method: string;
+        bodyParam: string | undefined;
+    };
+    /**
+     * Provides the service dependencies required by this AuraCommandModel.
+     * Includes information about the base class and inherited services, as well as any extra dependencies.
+     * @returns {object} An object detailing the service dependencies for the Aura command.
+     */
+    get serviceDependencies(): CommandServiceDependencies;
+}

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

@@ -0,0 +1,10 @@
+import { GraphQLSchemaModel } from './graphql-schema-model';
+import { AuraNormalizedCachingCommandModel } from './aura-normalized-caching-command-model';
+import { AuraGraphQLOperation } from '@conduit-client/model/v1';
+import type { IGraphQLCommandModel } from './graphql-command-model-interface';
+export declare class AuraGraphQLCommandModel extends AuraNormalizedCachingCommandModel implements IGraphQLCommandModel {
+    private schemaModel?;
+    constructor(operation: AuraGraphQLOperation);
+    get serviceDependencies(): import("./base-command-model").CommandServiceDependencies;
+    get schema(): GraphQLSchemaModel;
+}

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

@@ -0,0 +1,8 @@
+import { AuraCommandModel } from './aura-command-model';
+/**
+ * Represents a command model specifically designed for handling normalized caching in Aura applications.
+ * This model extends `AuraCommandModel` and overrides the service dependencies to include cache control services.
+ */
+export declare class AuraNormalizedCachingCommandModel extends AuraCommandModel {
+    get serviceDependencies(): import("./base-command-model").CommandServiceDependencies;
+}

package/dist/types/v1/model/aura-resource-caching-command-model.d.ts

@@ -0,0 +1,13 @@
+import { AuraCommandModel } from './aura-command-model';
+/**
+ * Represents a command model specifically designed for handling resource caching in Aura applications.
+ * This model extends `AuraCommandModel` and overrides the service dependencies to include cache control services.
+ */
+export declare class AuraResourceCachingCommandModel extends AuraCommandModel {
+    /**
+     * Overrides the serviceDependencies getter to customize dependencies for caching.
+     * Adds specific dependencies related to cache control, while preserving the base dependencies from `AuraCommandModel`.
+     * @returns {CommandServiceDependencies} An object detailing the service dependencies for caching.
+     */
+    get serviceDependencies(): import("./base-command-model").CommandServiceDependencies;
+}