@constructive-io/graphql-codegen 4.17.0 → 4.18.0

package/core/codegen/type-resolver.d.ts

@@ -1,10 +1,10 @@
 /**
  * Type Resolver - Convert GraphQL types to TypeScript
  *
- * Utilities for converting CleanTypeRef and other GraphQL types
+ * Utilities for converting TypeRef and other GraphQL types
  * into TypeScript type strings and interface definitions.
  */
-import type { CleanTypeRef } from '../../types/schema';
+import type { TypeRef } from '../../types/schema';
 /**
  * Interface for tracking referenced types during code generation
  */
@@ -38,37 +38,37 @@ export declare function createTypeTracker(options?: TypeTrackerOptions): TypeTra
  */
 export declare function scalarToTsType(scalarName: string): string;
 /**
- * Convert a CleanTypeRef to a TypeScript type string
+ * Convert a TypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
  *
  * @param typeRef - The GraphQL type reference
  * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
+export declare function typeRefToTsType(typeRef: TypeRef, tracker?: TypeTracker): string;
 /**
- * Convert a CleanTypeRef to a nullable TypeScript type string
+ * Convert a TypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
  *
  * @param typeRef - The GraphQL type reference
  * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToNullableTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
+export declare function typeRefToNullableTsType(typeRef: TypeRef, tracker?: TypeTracker): string;
 /**
  * Check if a type reference is required (wrapped in NON_NULL)
  */
-export declare function isTypeRequired(typeRef: CleanTypeRef): boolean;
+export declare function isTypeRequired(typeRef: TypeRef): boolean;
 /**
  * Check if a type reference is a list
  */
-export declare function isTypeList(typeRef: CleanTypeRef): boolean;
+export declare function isTypeList(typeRef: TypeRef): boolean;
 /**
  * Get the base type name from a type reference (unwrapping wrappers)
  */
-export declare function getTypeBaseName(typeRef: CleanTypeRef): string | null;
+export declare function getTypeBaseName(typeRef: TypeRef): string | null;
 /**
  * Get the base type kind (unwrapping LIST and NON_NULL)
  */
-export declare function getBaseTypeKind(typeRef: CleanTypeRef): CleanTypeRef['kind'];
+export declare function getBaseTypeKind(typeRef: TypeRef): TypeRef['kind'];
 /**
  * Check if a field should be skipped in selections
  */

package/core/codegen/type-resolver.js

@@ -80,10 +80,10 @@ function scalarToTsType(scalarName) {
     return (0, scalars_1.scalarToTsType)(scalarName, { unknownScalar: 'unknown' });
 }
 // ============================================================================
-// CleanTypeRef to TypeScript
+// TypeRef to TypeScript
 // ============================================================================
 /**
- * Convert a CleanTypeRef to a TypeScript type string
+ * Convert a TypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
  *
  * @param typeRef - The GraphQL type reference
@@ -125,7 +125,7 @@ function typeRefToTsType(typeRef, tracker) {
     }
 }
 /**
- * Convert a CleanTypeRef to a nullable TypeScript type string
+ * Convert a TypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
  *
  * @param typeRef - The GraphQL type reference

package/core/codegen/types.d.ts

@@ -1,4 +1,4 @@
-import type { CleanTable } from '../../types/schema';
+import type { Table } from '../../types/schema';
 /**
  * Options for generating types.ts
  */
@@ -9,4 +9,4 @@ export interface GenerateTypesOptions {
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
-export declare function generateTypesFile(tables: CleanTable[], options?: GenerateTypesOptions): string;
+export declare function generateTypesFile(tables: Table[], options?: GenerateTypesOptions): string;

package/core/codegen/utils.d.ts

@@ -1,4 +1,4 @@
-import type { CleanField, CleanFieldType, CleanTable, TypeRegistry } from '../../types/schema';
+import type { Field, FieldType, Table, TypeRegistry } from '../../types/schema';
 /** Lowercase first character */
 export declare function lcFirst(str: string): string;
 /** Uppercase first character */
@@ -22,118 +22,118 @@ export interface TableNames {
 /**
  * Derive all naming variants from a table
  */
-export declare function getTableNames(table: CleanTable): TableNames;
+export declare function getTableNames(table: Table): TableNames;
 /**
  * Generate hook function name for list query
  * e.g., "useCarsQuery"
  */
-export declare function getListQueryHookName(table: CleanTable): string;
+export declare function getListQueryHookName(table: Table): string;
 /**
  * Generate hook function name for single item query
  * e.g., "useCarQuery"
  */
-export declare function getSingleQueryHookName(table: CleanTable): string;
+export declare function getSingleQueryHookName(table: Table): string;
 /**
  * Generate hook function name for create mutation
  * e.g., "useCreateCarMutation"
  */
-export declare function getCreateMutationHookName(table: CleanTable): string;
+export declare function getCreateMutationHookName(table: Table): string;
 /**
  * Generate hook function name for update mutation
  * e.g., "useUpdateCarMutation"
  */
-export declare function getUpdateMutationHookName(table: CleanTable): string;
+export declare function getUpdateMutationHookName(table: Table): string;
 /**
  * Generate hook function name for delete mutation
  * e.g., "useDeleteCarMutation"
  */
-export declare function getDeleteMutationHookName(table: CleanTable): string;
+export declare function getDeleteMutationHookName(table: Table): string;
 /**
  * Generate file name for list query hook
  * e.g., "useCarsQuery.ts"
  */
-export declare function getListQueryFileName(table: CleanTable): string;
+export declare function getListQueryFileName(table: Table): string;
 /**
  * Generate file name for single query hook
  * e.g., "useCarQuery.ts"
  */
-export declare function getSingleQueryFileName(table: CleanTable): string;
+export declare function getSingleQueryFileName(table: Table): string;
 /**
  * Generate file name for create mutation hook
  */
-export declare function getCreateMutationFileName(table: CleanTable): string;
+export declare function getCreateMutationFileName(table: Table): string;
 /**
  * Generate file name for update mutation hook
  */
-export declare function getUpdateMutationFileName(table: CleanTable): string;
+export declare function getUpdateMutationFileName(table: Table): string;
 /**
  * Generate file name for delete mutation hook
  */
-export declare function getDeleteMutationFileName(table: CleanTable): string;
+export declare function getDeleteMutationFileName(table: Table): string;
 /**
  * Get the GraphQL query name for fetching all rows
  * Uses inflection from introspection, falls back to convention
  */
-export declare function getAllRowsQueryName(table: CleanTable): string;
+export declare function getAllRowsQueryName(table: Table): string;
 /**
  * Get the GraphQL query name for fetching single row
  */
-export declare function getSingleRowQueryName(table: CleanTable): string;
+export declare function getSingleRowQueryName(table: Table): string;
 /**
  * Get the GraphQL mutation name for creating
  */
-export declare function getCreateMutationName(table: CleanTable): string;
+export declare function getCreateMutationName(table: Table): string;
 /**
  * Get the GraphQL mutation name for updating
  */
-export declare function getUpdateMutationName(table: CleanTable): string;
+export declare function getUpdateMutationName(table: Table): string;
 /**
  * Get the GraphQL mutation name for deleting
  */
-export declare function getDeleteMutationName(table: CleanTable): string;
+export declare function getDeleteMutationName(table: Table): string;
 /**
  * Get PostGraphile filter type name
  * e.g., "CarFilter"
  */
-export declare function getFilterTypeName(table: CleanTable): string;
+export declare function getFilterTypeName(table: Table): string;
 /**
  * Get PostGraphile OrderBy enum type name
  * e.g., "CarsOrderBy", "AddressesOrderBy"
  */
-export declare function getOrderByTypeName(table: CleanTable): string;
+export declare function getOrderByTypeName(table: Table): string;
 /**
  * Get PostGraphile Condition type name (simple equality filter)
  * e.g., "CarCondition", "AddressCondition"
  */
-export declare function getConditionTypeName(table: CleanTable): string;
+export declare function getConditionTypeName(table: Table): string;
 /**
  * Get PostGraphile create input type name
  * e.g., "CreateCarInput"
  */
-export declare function getCreateInputTypeName(table: CleanTable): string;
+export declare function getCreateInputTypeName(table: Table): string;
 /**
  * Get PostGraphile patch type name for updates
  * e.g., "CarPatch"
  */
-export declare function getPatchTypeName(table: CleanTable): string;
+export declare function getPatchTypeName(table: Table): string;
 /**
  * Get PostGraphile update input type name
  * e.g., "UpdateCarInput"
  */
-export declare function getUpdateInputTypeName(table: CleanTable): string;
+export declare function getUpdateInputTypeName(table: Table): string;
 /**
  * Get PostGraphile delete input type name
  * e.g., "DeleteCarInput"
  */
-export declare function getDeleteInputTypeName(table: CleanTable): string;
+export declare function getDeleteInputTypeName(table: Table): string;
 /**
  * Convert GraphQL type to TypeScript type
  */
 export declare function gqlTypeToTs(gqlType: string, isArray?: boolean): string;
 /**
- * Convert CleanFieldType to TypeScript type string
+ * Convert FieldType to TypeScript type string
  */
-export declare function fieldTypeToTs(fieldType: CleanFieldType): string;
+export declare function fieldTypeToTs(fieldType: FieldType): string;
 /**
  * Get the PostGraphile filter type for a GraphQL scalar
  * @param gqlType - The GraphQL type string (e.g., "String", "UUID")
@@ -143,11 +143,11 @@ export declare function getScalarFilterType(gqlType: string, isArray?: boolean):
 /**
  * Check if a field is a relation field (not a scalar)
  */
-export declare function isRelationField(fieldName: string, table: CleanTable): boolean;
+export declare function isRelationField(fieldName: string, table: Table): boolean;
 /**
  * Get only scalar fields (non-relation fields)
  */
-export declare function getScalarFields(table: CleanTable): CleanField[];
+export declare function getScalarFields(table: Table): Field[];
 /**
  * Resolve the inner input type from a CreateXInput.
  * PostGraphile create inputs wrap the actual field definitions in an inner type
@@ -164,7 +164,7 @@ export declare function resolveInnerInputType(inputTypeName: string, typeRegistr
  * are plugin-added computed fields that don't correspond to real database columns.
  * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
  */
-export declare function getWritableFieldNames(table: CleanTable, typeRegistry?: TypeRegistry): Set<string> | null;
+export declare function getWritableFieldNames(table: Table, typeRegistry?: TypeRegistry): Set<string> | null;
 /**
  * Get scalar fields that represent actual database columns (not computed/plugin-added).
  * When a TypeRegistry is provided, filters out fields that don't exist in the
@@ -172,7 +172,7 @@ export declare function getWritableFieldNames(table: CleanTable, typeRegistry?:
  * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
  * Without a TypeRegistry, falls back to all scalar fields.
  */
-export declare function getSelectableScalarFields(table: CleanTable, typeRegistry?: TypeRegistry): CleanField[];
+export declare function getSelectableScalarFields(table: Table, typeRegistry?: TypeRegistry): Field[];
 /**
  * Primary key field information
  */
@@ -188,22 +188,22 @@ export interface PrimaryKeyField {
  * Get primary key field information from table constraints
  * Returns array to support composite primary keys
  */
-export declare function getPrimaryKeyInfo(table: CleanTable): PrimaryKeyField[];
+export declare function getPrimaryKeyInfo(table: Table): PrimaryKeyField[];
 /**
  * Get primary key field names (convenience wrapper)
  */
-export declare function getPrimaryKeyFields(table: CleanTable): string[];
+export declare function getPrimaryKeyFields(table: Table): string[];
 /**
  * Check if table has a valid single-field primary key
  * Used to determine if a single query hook can be generated
  * Tables with composite keys return false (handled as custom queries)
  */
-export declare function hasValidPrimaryKey(table: CleanTable): boolean;
+export declare function hasValidPrimaryKey(table: Table): boolean;
 /**
  * Generate query key prefix for a table
  * e.g., "cars" for list queries, "car" for detail queries
  */
-export declare function getQueryKeyPrefix(table: CleanTable): string;
+export declare function getQueryKeyPrefix(table: Table): string;
 /**
  * Strip PostGraphile smart comments and boilerplate from a description string.
  *

package/core/codegen/utils.js

@@ -270,7 +270,7 @@ function gqlTypeToTs(gqlType, isArray = false) {
     return isArray ? `${tsType}[]` : tsType;
 }
 /**
- * Convert CleanFieldType to TypeScript type string
+ * Convert FieldType to TypeScript type string
  */
 function fieldTypeToTs(fieldType) {
     return gqlTypeToTs(fieldType.gqlType, fieldType.isArray);

package/core/generate.d.ts

@@ -1,5 +1,5 @@
 import type { CliConfig, GraphQLSDKConfigTarget, SchemaConfig } from '../types/config';
-import type { CleanOperation, CleanTable, TypeRegistry } from '../types/schema';
+import type { Operation, Table, TypeRegistry } from '../types/schema';
 export interface GenerateOptions extends GraphQLSDKConfigTarget {
     authorization?: string;
     verbose?: boolean;
@@ -14,10 +14,10 @@ export interface GenerateResult {
     filesWritten?: string[];
     errors?: string[];
     pipelineData?: {
-        tables: CleanTable[];
+        tables: Table[];
         customOperations: {
-            queries: CleanOperation[];
-            mutations: CleanOperation[];
+            queries: Operation[];
+            mutations: Operation[];
             typeRegistry?: TypeRegistry;
         };
     };

package/core/introspect/index.d.ts

@@ -4,7 +4,7 @@
 export type { InferTablesOptions } from './infer-tables';
 export { inferTablesFromIntrospection } from './infer-tables';
 export { pluralize, singularize } from 'inflekt';
-export type { CreateSchemaSourceOptions, SchemaSource, SchemaSourceResult, } from './source';
+export type { CreateSchemaSourceOptions, MetaTableInfo, SchemaSource, SchemaSourceResult, } from './source';
 export { createSchemaSource, EndpointSchemaSource, FileSchemaSource, SchemaSourceError, validateSourceOptions, } from './source';
 export type { FetchSchemaOptions, FetchSchemaResult } from './fetch-schema';
 export { fetchSchema } from './fetch-schema';

package/core/introspect/source/database.js

@@ -6,6 +6,7 @@ exports.DatabaseSchemaSource = void 0;
  *
  * Loads GraphQL schema directly from a PostgreSQL database using PostGraphile
  * introspection and converts it to introspection format.
+ * Also returns _meta table metadata when available (via MetaSchemaPlugin cache).
  */
 const graphql_1 = require("graphql");
 const graphile_schema_1 = require("graphile-schema");
@@ -45,7 +46,7 @@ class DatabaseSchemaSource {
         else {
             schemas = this.options.schemas ?? ['public'];
         }
-        // Build SDL from database
+        // Build SDL from database (MetaSchemaPlugin populates _cachedTablesMeta as a side-effect)
         let sdl;
         try {
             sdl = await (0, graphile_schema_1.buildSchemaSDL)({
@@ -78,7 +79,10 @@ class DatabaseSchemaSource {
         }
         // Convert graphql-js introspection result to our mutable type
         const introspection = JSON.parse(JSON.stringify(introspectionResult));
-        return { introspection };
+        return {
+            introspection,
+            tablesMeta: [...graphile_schema_1._cachedTablesMeta],
+        };
     }
     describe() {
         const { database, schemas, apiNames } = this.options;

package/core/introspect/source/types.d.ts

@@ -5,6 +5,38 @@
  * to work with both live GraphQL endpoints and static schema files.
  */
 import type { IntrospectionQueryResponse } from '../../../types/introspection';
+/**
+ * Minimal table metadata from the _meta query, used to enrich M:N relations
+ * with junction key field information that isn't available from introspection alone.
+ */
+export interface MetaTableInfo {
+    name: string;
+    schemaName: string;
+    relations: {
+        manyToMany: Array<{
+            fieldName: string | null;
+            type: string | null;
+            junctionTable: {
+                name: string;
+            };
+            junctionLeftKeyAttributes: Array<{
+                name: string;
+            }>;
+            junctionRightKeyAttributes: Array<{
+                name: string;
+            }>;
+            leftKeyAttributes: Array<{
+                name: string;
+            }>;
+            rightKeyAttributes: Array<{
+                name: string;
+            }>;
+            rightTable: {
+                name: string;
+            };
+        }>;
+    };
+}
 /**
  * Result from fetching a schema source
  */
@@ -13,6 +45,11 @@ export interface SchemaSourceResult {
      * The GraphQL introspection data
      */
     introspection: IntrospectionQueryResponse;
+    /**
+     * Optional table metadata from _meta query (provides M:N junction key details).
+     * Present when the source supports _meta (database mode or endpoints with MetaSchemaPlugin).
+     */
+    tablesMeta?: MetaTableInfo[];
 }
 /**
  * Abstract interface for schema sources

package/core/pipeline/index.d.ts

@@ -9,7 +9,7 @@
  * - Filtering
  */
 import type { GraphQLSDKConfigTarget } from '../../types/config';
-import type { CleanOperation, CleanTable, TypeRegistry } from '../../types/schema';
+import type { Operation, Table, TypeRegistry } from '../../types/schema';
 import type { SchemaSource } from '../introspect/source';
 export type { SchemaSource } from '../introspect/source';
 export { createSchemaSource, validateSourceOptions, } from '../introspect/source';
@@ -35,13 +35,13 @@ export interface CodegenPipelineResult {
     /**
      * Inferred table metadata
      */
-    tables: CleanTable[];
+    tables: Table[];
     /**
      * Custom operations (queries and mutations not covered by tables)
      */
     customOperations: {
-        queries: CleanOperation[];
-        mutations: CleanOperation[];
+        queries: Operation[];
+        mutations: Operation[];
         typeRegistry: TypeRegistry;
     };
     /**
@@ -70,7 +70,7 @@ export declare function runCodegenPipeline(options: CodegenPipelineOptions): Pro
 /**
  * Validate that tables were found
  */
-export declare function validateTablesFound(tables: CleanTable[]): {
+export declare function validateTablesFound(tables: Table[]): {
     valid: boolean;
     error?: string;
 };

package/esm/core/codegen/barrel.d.ts

@@ -1,12 +1,12 @@
-import type { CleanTable } from '../../types/schema';
+import type { Table } from '../../types/schema';
 /**
  * Generate the queries/index.ts barrel file
  */
-export declare function generateQueriesBarrel(tables: CleanTable[]): string;
+export declare function generateQueriesBarrel(tables: Table[]): string;
 /**
  * Generate the mutations/index.ts barrel file
  */
-export declare function generateMutationsBarrel(tables: CleanTable[]): string;
+export declare function generateMutationsBarrel(tables: Table[]): string;
 /**
  * Generate the main index.ts barrel file
  *
@@ -22,7 +22,7 @@ export interface MainBarrelOptions {
     /** Whether invalidation.ts was generated */
     hasInvalidation?: boolean;
 }
-export declare function generateMainBarrel(tables: CleanTable[], options?: MainBarrelOptions): string;
+export declare function generateMainBarrel(tables: Table[], options?: MainBarrelOptions): string;
 export interface RootBarrelOptions {
     hasTypes?: boolean;
     hasHooks?: boolean;
@@ -37,8 +37,8 @@ export declare function generateRootBarrel(options?: RootBarrelOptions): string;
 /**
  * Generate queries barrel including custom query operations
  */
-export declare function generateCustomQueriesBarrel(tables: CleanTable[], customQueryNames: string[]): string;
+export declare function generateCustomQueriesBarrel(tables: Table[], customQueryNames: string[]): string;
 /**
  * Generate mutations barrel including custom mutation operations
  */
-export declare function generateCustomMutationsBarrel(tables: CleanTable[], customMutationNames: string[]): string;
+export declare function generateCustomMutationsBarrel(tables: Table[], customMutationNames: string[]): string;

package/esm/core/codegen/cli/arg-mapper.d.ts

@@ -1,4 +1,4 @@
 import * as t from '@babel/types';
-import type { CleanArgument } from '../../../types/schema';
-export declare function buildQuestionObject(arg: CleanArgument, namePrefix?: string): t.ObjectExpression;
-export declare function buildQuestionsArray(args: CleanArgument[]): t.ArrayExpression;
+import type { Argument } from '../../../types/schema';
+export declare function buildQuestionObject(arg: Argument, namePrefix?: string): t.ObjectExpression;
+export declare function buildQuestionsArray(args: Argument[]): t.ArrayExpression;

package/esm/core/codegen/cli/command-map-generator.d.ts

@@ -1,6 +1,6 @@
-import type { CleanTable, CleanOperation } from '../../../types/schema';
+import type { Table, Operation } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
-export declare function generateCommandMap(tables: CleanTable[], customOperations: CleanOperation[], toolName: string): GeneratedFile;
+export declare function generateCommandMap(tables: Table[], customOperations: Operation[], toolName: string): GeneratedFile;
 export interface MultiTargetCommandMapInput {
     toolName: string;
     builtinNames: {
@@ -10,8 +10,8 @@ export interface MultiTargetCommandMapInput {
     };
     targets: Array<{
         name: string;
-        tables: CleanTable[];
-        customOperations: CleanOperation[];
+        tables: Table[];
+        customOperations: Operation[];
     }>;
 }
 export declare function generateMultiTargetCommandMap(input: MultiTargetCommandMapInput): GeneratedFile;

package/esm/core/codegen/cli/custom-command-generator.d.ts

@@ -1,8 +1,8 @@
-import type { CleanOperation } from '../../../types/schema';
+import type { Operation } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
 export interface CustomCommandOptions {
     targetName?: string;
     executorImportPath?: string;
     saveToken?: boolean;
 }
-export declare function generateCustomCommand(op: CleanOperation, options?: CustomCommandOptions): GeneratedFile;
+export declare function generateCustomCommand(op: Operation, options?: CustomCommandOptions): GeneratedFile;

package/esm/core/codegen/cli/docs-generator.d.ts

@@ -1,11 +1,11 @@
-import type { CleanTable, CleanOperation, TypeRegistry } from '../../../types/schema';
+import type { Table, Operation, TypeRegistry } from '../../../types/schema';
 import type { GeneratedDocFile, McpTool } from '../docs-utils';
 export { resolveDocsConfig } from '../docs-utils';
 export type { GeneratedDocFile, McpTool } from '../docs-utils';
-export declare function generateReadme(tables: CleanTable[], customOperations: CleanOperation[], toolName: string, registry?: TypeRegistry): GeneratedDocFile;
-export declare function generateAgentsDocs(tables: CleanTable[], customOperations: CleanOperation[], toolName: string, _registry?: TypeRegistry): GeneratedDocFile;
-export declare function getCliMcpTools(tables: CleanTable[], customOperations: CleanOperation[], toolName: string, registry?: TypeRegistry): McpTool[];
-export declare function generateSkills(tables: CleanTable[], customOperations: CleanOperation[], toolName: string, targetName: string, registry?: TypeRegistry): GeneratedDocFile[];
+export declare function generateReadme(tables: Table[], customOperations: Operation[], toolName: string, registry?: TypeRegistry): GeneratedDocFile;
+export declare function generateAgentsDocs(tables: Table[], customOperations: Operation[], toolName: string, _registry?: TypeRegistry): GeneratedDocFile;
+export declare function getCliMcpTools(tables: Table[], customOperations: Operation[], toolName: string, registry?: TypeRegistry): McpTool[];
+export declare function generateSkills(tables: Table[], customOperations: Operation[], toolName: string, targetName: string, registry?: TypeRegistry): GeneratedDocFile[];
 export interface MultiTargetDocsInput {
     toolName: string;
     builtinNames: {
@@ -17,8 +17,8 @@ export interface MultiTargetDocsInput {
     targets: Array<{
         name: string;
         endpoint: string;
-        tables: CleanTable[];
-        customOperations: CleanOperation[];
+        tables: Table[];
+        customOperations: Operation[];
         isAuthTarget?: boolean;
     }>;
 }

package/esm/core/codegen/cli/index.d.ts

@@ -1,11 +1,11 @@
 import type { BuiltinNames, GraphQLSDKConfigTarget } from '../../../types/config';
-import type { CleanOperation, CleanTable, TypeRegistry } from '../../../types/schema';
+import type { Operation, Table, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
 export interface GenerateCliOptions {
-    tables: CleanTable[];
+    tables: Table[];
     customOperations?: {
-        queries: CleanOperation[];
-        mutations: CleanOperation[];
+        queries: Operation[];
+        mutations: Operation[];
     };
     config: GraphQLSDKConfigTarget;
     /** TypeRegistry from introspection, used to check field defaults */
@@ -26,10 +26,10 @@ export interface MultiTargetCliTarget {
     name: string;
     endpoint: string;
     ormImportPath: string;
-    tables: CleanTable[];
+    tables: Table[];
     customOperations: {
-        queries: CleanOperation[];
-        mutations: CleanOperation[];
+        queries: Operation[];
+        mutations: Operation[];
     };
     isAuthTarget?: boolean;
     /** TypeRegistry from introspection, used to check field defaults */

package/esm/core/codegen/cli/table-command-generator.d.ts

@@ -1,10 +1,10 @@
-import type { CleanTable, TypeRegistry } from '../../../types/schema';
+import type { Table, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
-export declare function getFieldsWithDefaults(table: CleanTable, typeRegistry?: TypeRegistry): Set<string>;
+export declare function getFieldsWithDefaults(table: Table, typeRegistry?: TypeRegistry): Set<string>;
 export interface TableCommandOptions {
     targetName?: string;
     executorImportPath?: string;
     /** TypeRegistry from introspection, used to check field defaults */
     typeRegistry?: TypeRegistry;
 }
-export declare function generateTableCommand(table: CleanTable, options?: TableCommandOptions): GeneratedFile;
+export declare function generateTableCommand(table: Table, options?: TableCommandOptions): GeneratedFile;

package/esm/core/codegen/custom-mutations.d.ts

@@ -1,11 +1,11 @@
-import type { CleanOperation, TypeRegistry } from '../../types/schema';
+import type { Operation, TypeRegistry } from '../../types/schema';
 export interface GeneratedCustomMutationFile {
     fileName: string;
     content: string;
     operationName: string;
 }
 export interface GenerateCustomMutationHookOptions {
-    operation: CleanOperation;
+    operation: Operation;
     typeRegistry: TypeRegistry;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;
@@ -14,7 +14,7 @@ export interface GenerateCustomMutationHookOptions {
 }
 export declare function generateCustomMutationHook(options: GenerateCustomMutationHookOptions): GeneratedCustomMutationFile | null;
 export interface GenerateAllCustomMutationHooksOptions {
-    operations: CleanOperation[];
+    operations: Operation[];
     typeRegistry: TypeRegistry;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;