@constructive-io/graphql-codegen 4.6.0 → 4.7.0

package/core/types.d.ts

@@ -1,139 +1,9 @@
-import type { DocumentNode, FieldNode, SelectionSetNode, VariableDefinitionNode } from 'graphql';
-import type { CleanField } from '../types/schema';
-export type ASTNode = DocumentNode | FieldNode | SelectionSetNode | VariableDefinitionNode;
-export interface NestedProperties {
-    [key: string]: QueryProperty | NestedProperties;
-}
-export interface QueryProperty {
-    name: string;
-    type: string;
-    isNotNull: boolean;
-    isArray: boolean;
-    isArrayNotNull: boolean;
-    properties?: NestedProperties;
-}
-export interface QueryDefinition {
-    model: string;
-    qtype: 'getMany' | 'getOne' | 'mutation';
-    mutationType?: 'create' | 'patch' | 'delete';
-    selection: string[];
-    properties: Record<string, QueryProperty>;
-}
-export interface MutationDefinition extends QueryDefinition {
-    qtype: 'mutation';
-    mutationType: 'create' | 'patch' | 'delete';
-}
-export interface IntrospectionSchema {
-    [key: string]: QueryDefinition | MutationDefinition;
-}
-export interface MetaFieldType {
-    gqlType: string;
-    isArray: boolean;
-    modifier?: string | number | null;
-    pgAlias?: string | null;
-    pgType?: string | null;
-    subtype?: string | null;
-    typmod?: number | null;
-}
-export interface MetaField {
-    name: string;
-    type: MetaFieldType;
-}
-export interface MetaConstraint {
-    name: string;
-    type: MetaFieldType;
-    alias?: string;
-}
-export interface MetaForeignConstraint {
-    fromKey: MetaConstraint;
-    refTable: string;
-    toKey: MetaConstraint;
-}
-export interface MetaTable {
-    name: string;
-    fields: MetaField[];
-    primaryConstraints: MetaConstraint[];
-    uniqueConstraints: MetaConstraint[];
-    foreignConstraints: MetaForeignConstraint[];
-}
-export interface MetaObject {
-    tables: MetaTable[];
-}
-export type GraphQLVariableValue = string | number | boolean | null;
-export interface GraphQLVariables {
-    [key: string]: GraphQLVariableValue | GraphQLVariableValue[] | GraphQLVariables | GraphQLVariables[];
-}
-export interface QueryFieldSelection {
-    name: string;
-    isObject: boolean;
-    fieldDefn?: MetaField | CleanField;
-    selection?: QueryFieldSelection[];
-    variables?: GraphQLVariables;
-    isBelongTo?: boolean;
-}
-export interface QuerySelectionOptions {
-    [fieldName: string]: boolean | {
-        select: Record<string, boolean>;
-        variables?: GraphQLVariables;
-    };
-}
-export interface QueryBuilderInstance {
-    _introspection: IntrospectionSchema;
-    _meta: MetaObject;
-    _edges?: boolean;
-}
-export interface ASTFunctionParams {
-    queryName: string;
-    operationName: string;
-    query: QueryDefinition;
-    selection: QueryFieldSelection[];
-    builder?: QueryBuilderInstance;
-}
-export interface MutationASTParams {
-    mutationName: string;
-    operationName: string;
-    mutation: MutationDefinition;
-    selection?: QueryFieldSelection[];
-}
-export interface QueryBuilderOptions {
-    meta: MetaObject;
-    introspection: IntrospectionSchema;
-}
-export interface QueryBuilderResult {
-    _hash: string;
-    _queryName: string;
-    _ast: DocumentNode;
-}
-export interface IQueryBuilder {
-    query(model: string): IQueryBuilder;
-    getMany(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    getOne(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    all(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    count(): IQueryBuilder;
-    create(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    update(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    delete(options?: {
-        select?: QuerySelectionOptions;
-    }): IQueryBuilder;
-    edges(useEdges: boolean): IQueryBuilder;
-    print(): QueryBuilderResult;
-}
-export interface ObjectArrayItem extends QueryProperty {
-    name: string;
-    key?: string;
-}
-export declare function isGraphQLVariableValue(value: unknown): value is GraphQLVariableValue;
-export declare function isGraphQLVariables(obj: unknown): obj is GraphQLVariables;
-export type StrictRecord<K extends PropertyKey, V> = Record<K, V> & {
-    [P in PropertyKey]: P extends K ? V : never;
-};
+/**
+ * Re-export core types from @constructive-io/graphql-query.
+ *
+ * This file used to contain the canonical type definitions. They now live in
+ * the `graphql-query` package and are re-exported here for backward
+ * compatibility so existing codegen consumers continue to work unchanged.
+ */
+export { type ASTNode, type NestedProperties, type QueryProperty, type QueryDefinition, type MutationDefinition, type MetaFieldType, type MetaField, type MetaConstraint, type MetaForeignConstraint, type MetaTable, type MetaObject, type GraphQLVariableValue, type GraphQLVariables, type QueryFieldSelection, type QuerySelectionOptions, type QueryBuilderInstance, type ASTFunctionParams, type MutationASTParams, type QueryBuilderOptions, type QueryBuilderResult, type IQueryBuilder, type ObjectArrayItem, isGraphQLVariableValue, isGraphQLVariables, type StrictRecord, } from '@constructive-io/graphql-query';
+export { type QueryIntrospectionSchema as IntrospectionSchema } from '@constructive-io/graphql-query';

package/core/types.js

@@ -1,28 +1,14 @@
 "use strict";
+/**
+ * Re-export core types from @constructive-io/graphql-query.
+ *
+ * This file used to contain the canonical type definitions. They now live in
+ * the `graphql-query` package and are re-exported here for backward
+ * compatibility so existing codegen consumers continue to work unchanged.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGraphQLVariableValue = isGraphQLVariableValue;
-exports.isGraphQLVariables = isGraphQLVariables;
-// Type guards for runtime validation
-function isGraphQLVariableValue(value) {
-    return (value === null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean');
-}
-function isGraphQLVariables(obj) {
-    if (!obj || typeof obj !== 'object')
-        return false;
-    for (const [key, value] of Object.entries(obj)) {
-        if (typeof key !== 'string')
-            return false;
-        if (Array.isArray(value)) {
-            if (!value.every((item) => isGraphQLVariableValue(item) || isGraphQLVariables(item))) {
-                return false;
-            }
-        }
-        else if (!isGraphQLVariableValue(value) && !isGraphQLVariables(value)) {
-            return false;
-        }
-    }
-    return true;
-}
+exports.isGraphQLVariables = exports.isGraphQLVariableValue = void 0;
+// Re-export everything from the canonical source
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "isGraphQLVariableValue", { enumerable: true, get: function () { return graphql_query_1.isGraphQLVariableValue; } });
+Object.defineProperty(exports, "isGraphQLVariables", { enumerable: true, get: function () { return graphql_query_1.isGraphQLVariables; } });

package/esm/client/error.d.ts

@@ -1,95 +1,4 @@
 /**
- * Error handling for GraphQL operations
- * Provides consistent error types and parsing for PostGraphile responses
+ * Re-export error handling utilities from @constructive-io/graphql-query.
  */
-export declare const DataErrorType: {
-    readonly NETWORK_ERROR: "NETWORK_ERROR";
-    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
-    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
-    readonly REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING";
-    readonly INVALID_MUTATION_DATA: "INVALID_MUTATION_DATA";
-    readonly QUERY_GENERATION_FAILED: "QUERY_GENERATION_FAILED";
-    readonly QUERY_EXECUTION_FAILED: "QUERY_EXECUTION_FAILED";
-    readonly UNAUTHORIZED: "UNAUTHORIZED";
-    readonly FORBIDDEN: "FORBIDDEN";
-    readonly TABLE_NOT_FOUND: "TABLE_NOT_FOUND";
-    readonly BAD_REQUEST: "BAD_REQUEST";
-    readonly NOT_FOUND: "NOT_FOUND";
-    readonly GRAPHQL_ERROR: "GRAPHQL_ERROR";
-    readonly UNIQUE_VIOLATION: "UNIQUE_VIOLATION";
-    readonly FOREIGN_KEY_VIOLATION: "FOREIGN_KEY_VIOLATION";
-    readonly NOT_NULL_VIOLATION: "NOT_NULL_VIOLATION";
-    readonly CHECK_VIOLATION: "CHECK_VIOLATION";
-    readonly EXCLUSION_VIOLATION: "EXCLUSION_VIOLATION";
-    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
-};
-export type DataErrorType = (typeof DataErrorType)[keyof typeof DataErrorType];
-export interface DataErrorOptions {
-    tableName?: string;
-    fieldName?: string;
-    constraint?: string;
-    originalError?: Error;
-    code?: string;
-    context?: Record<string, unknown>;
-}
-/**
- * Standard error class for data layer operations
- */
-export declare class DataError extends Error {
-    readonly type: DataErrorType;
-    readonly code?: string;
-    readonly originalError?: Error;
-    readonly context?: Record<string, unknown>;
-    readonly tableName?: string;
-    readonly fieldName?: string;
-    readonly constraint?: string;
-    constructor(type: DataErrorType, message: string, options?: DataErrorOptions);
-    getUserMessage(): string;
-    isRetryable(): boolean;
-}
-export declare const PG_ERROR_CODES: {
-    readonly UNIQUE_VIOLATION: "23505";
-    readonly FOREIGN_KEY_VIOLATION: "23503";
-    readonly NOT_NULL_VIOLATION: "23502";
-    readonly CHECK_VIOLATION: "23514";
-    readonly EXCLUSION_VIOLATION: "23P01";
-    readonly NUMERIC_VALUE_OUT_OF_RANGE: "22003";
-    readonly STRING_DATA_RIGHT_TRUNCATION: "22001";
-    readonly INVALID_TEXT_REPRESENTATION: "22P02";
-    readonly DATETIME_FIELD_OVERFLOW: "22008";
-    readonly UNDEFINED_TABLE: "42P01";
-    readonly UNDEFINED_COLUMN: "42703";
-    readonly INSUFFICIENT_PRIVILEGE: "42501";
-};
-export declare const createError: {
-    network: (originalError?: Error) => DataError;
-    timeout: (originalError?: Error) => DataError;
-    unauthorized: (message?: string) => DataError;
-    forbidden: (message?: string) => DataError;
-    badRequest: (message: string, code?: string) => DataError;
-    notFound: (message?: string) => DataError;
-    graphql: (message: string, code?: string) => DataError;
-    uniqueViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
-    foreignKeyViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
-    notNullViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
-    unknown: (originalError: Error) => DataError;
-};
-export interface GraphQLError {
-    message: string;
-    extensions?: {
-        code?: string;
-    } & Record<string, unknown>;
-    locations?: Array<{
-        line: number;
-        column: number;
-    }>;
-    path?: Array<string | number>;
-}
-/**
- * Parse any error into a DataError
- */
-export declare function parseGraphQLError(error: unknown): DataError;
-/**
- * Check if value is a DataError
- */
-export declare function isDataError(error: unknown): error is DataError;
+export { DataError, DataErrorType, PG_ERROR_CODES, createError, parseGraphQLError, isDataError, type DataErrorOptions, type GraphQLError, } from '@constructive-io/graphql-query';

package/esm/client/error.js

@@ -1,271 +1,4 @@
 /**
- * Error handling for GraphQL operations
- * Provides consistent error types and parsing for PostGraphile responses
+ * Re-export error handling utilities from @constructive-io/graphql-query.
  */
-// ============================================================================
-// Error Types
-// ============================================================================
-export const DataErrorType = {
-    // Network/Connection errors
-    NETWORK_ERROR: 'NETWORK_ERROR',
-    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
-    // Validation errors
-    VALIDATION_FAILED: 'VALIDATION_FAILED',
-    REQUIRED_FIELD_MISSING: 'REQUIRED_FIELD_MISSING',
-    INVALID_MUTATION_DATA: 'INVALID_MUTATION_DATA',
-    // Query errors
-    QUERY_GENERATION_FAILED: 'QUERY_GENERATION_FAILED',
-    QUERY_EXECUTION_FAILED: 'QUERY_EXECUTION_FAILED',
-    // Permission errors
-    UNAUTHORIZED: 'UNAUTHORIZED',
-    FORBIDDEN: 'FORBIDDEN',
-    // Schema errors
-    TABLE_NOT_FOUND: 'TABLE_NOT_FOUND',
-    // Request errors
-    BAD_REQUEST: 'BAD_REQUEST',
-    NOT_FOUND: 'NOT_FOUND',
-    // GraphQL-specific errors
-    GRAPHQL_ERROR: 'GRAPHQL_ERROR',
-    // PostgreSQL constraint errors (surfaced via PostGraphile)
-    UNIQUE_VIOLATION: 'UNIQUE_VIOLATION',
-    FOREIGN_KEY_VIOLATION: 'FOREIGN_KEY_VIOLATION',
-    NOT_NULL_VIOLATION: 'NOT_NULL_VIOLATION',
-    CHECK_VIOLATION: 'CHECK_VIOLATION',
-    EXCLUSION_VIOLATION: 'EXCLUSION_VIOLATION',
-    // Generic errors
-    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
-};
-/**
- * Standard error class for data layer operations
- */
-export class DataError extends Error {
-    type;
-    code;
-    originalError;
-    context;
-    tableName;
-    fieldName;
-    constraint;
-    constructor(type, message, options = {}) {
-        super(message);
-        this.name = 'DataError';
-        this.type = type;
-        this.code = options.code;
-        this.originalError = options.originalError;
-        this.context = options.context;
-        this.tableName = options.tableName;
-        this.fieldName = options.fieldName;
-        this.constraint = options.constraint;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, DataError);
-        }
-    }
-    getUserMessage() {
-        switch (this.type) {
-            case DataErrorType.NETWORK_ERROR:
-                return 'Network error. Please check your connection and try again.';
-            case DataErrorType.TIMEOUT_ERROR:
-                return 'Request timed out. Please try again.';
-            case DataErrorType.UNAUTHORIZED:
-                return 'You are not authorized. Please log in and try again.';
-            case DataErrorType.FORBIDDEN:
-                return 'You do not have permission to access this resource.';
-            case DataErrorType.VALIDATION_FAILED:
-                return 'Validation failed. Please check your input and try again.';
-            case DataErrorType.REQUIRED_FIELD_MISSING:
-                return this.fieldName
-                    ? `The field "${this.fieldName}" is required.`
-                    : 'A required field is missing.';
-            case DataErrorType.UNIQUE_VIOLATION:
-                return this.fieldName
-                    ? `A record with this ${this.fieldName} already exists.`
-                    : 'A record with this value already exists.';
-            case DataErrorType.FOREIGN_KEY_VIOLATION:
-                return 'This record references a record that does not exist.';
-            case DataErrorType.NOT_NULL_VIOLATION:
-                return this.fieldName
-                    ? `The field "${this.fieldName}" cannot be empty.`
-                    : 'A required field cannot be empty.';
-            case DataErrorType.CHECK_VIOLATION:
-                return this.fieldName
-                    ? `The value for "${this.fieldName}" is not valid.`
-                    : 'The value does not meet the required constraints.';
-            default:
-                return this.message || 'An unexpected error occurred.';
-        }
-    }
-    isRetryable() {
-        return (this.type === DataErrorType.NETWORK_ERROR ||
-            this.type === DataErrorType.TIMEOUT_ERROR);
-    }
-}
-// ============================================================================
-// PostgreSQL Error Codes
-// ============================================================================
-export const PG_ERROR_CODES = {
-    UNIQUE_VIOLATION: '23505',
-    FOREIGN_KEY_VIOLATION: '23503',
-    NOT_NULL_VIOLATION: '23502',
-    CHECK_VIOLATION: '23514',
-    EXCLUSION_VIOLATION: '23P01',
-    NUMERIC_VALUE_OUT_OF_RANGE: '22003',
-    STRING_DATA_RIGHT_TRUNCATION: '22001',
-    INVALID_TEXT_REPRESENTATION: '22P02',
-    DATETIME_FIELD_OVERFLOW: '22008',
-    UNDEFINED_TABLE: '42P01',
-    UNDEFINED_COLUMN: '42703',
-    INSUFFICIENT_PRIVILEGE: '42501',
-};
-// ============================================================================
-// Error Factory
-// ============================================================================
-export const createError = {
-    network: (originalError) => new DataError(DataErrorType.NETWORK_ERROR, 'Network error occurred', {
-        originalError,
-    }),
-    timeout: (originalError) => new DataError(DataErrorType.TIMEOUT_ERROR, 'Request timed out', {
-        originalError,
-    }),
-    unauthorized: (message = 'Authentication required') => new DataError(DataErrorType.UNAUTHORIZED, message),
-    forbidden: (message = 'Access forbidden') => new DataError(DataErrorType.FORBIDDEN, message),
-    badRequest: (message, code) => new DataError(DataErrorType.BAD_REQUEST, message, { code }),
-    notFound: (message = 'Resource not found') => new DataError(DataErrorType.NOT_FOUND, message),
-    graphql: (message, code) => new DataError(DataErrorType.GRAPHQL_ERROR, message, { code }),
-    uniqueViolation: (message, fieldName, constraint) => new DataError(DataErrorType.UNIQUE_VIOLATION, message, {
-        fieldName,
-        constraint,
-        code: '23505',
-    }),
-    foreignKeyViolation: (message, fieldName, constraint) => new DataError(DataErrorType.FOREIGN_KEY_VIOLATION, message, {
-        fieldName,
-        constraint,
-        code: '23503',
-    }),
-    notNullViolation: (message, fieldName, constraint) => new DataError(DataErrorType.NOT_NULL_VIOLATION, message, {
-        fieldName,
-        constraint,
-        code: '23502',
-    }),
-    unknown: (originalError) => new DataError(DataErrorType.UNKNOWN_ERROR, originalError.message, {
-        originalError,
-    }),
-};
-function parseGraphQLErrorCode(code) {
-    if (!code)
-        return DataErrorType.UNKNOWN_ERROR;
-    const normalized = code.toUpperCase();
-    // GraphQL standard codes
-    if (normalized === 'UNAUTHENTICATED')
-        return DataErrorType.UNAUTHORIZED;
-    if (normalized === 'FORBIDDEN')
-        return DataErrorType.FORBIDDEN;
-    if (normalized === 'GRAPHQL_VALIDATION_FAILED')
-        return DataErrorType.QUERY_GENERATION_FAILED;
-    // PostgreSQL SQLSTATE codes
-    if (code === PG_ERROR_CODES.UNIQUE_VIOLATION)
-        return DataErrorType.UNIQUE_VIOLATION;
-    if (code === PG_ERROR_CODES.FOREIGN_KEY_VIOLATION)
-        return DataErrorType.FOREIGN_KEY_VIOLATION;
-    if (code === PG_ERROR_CODES.NOT_NULL_VIOLATION)
-        return DataErrorType.NOT_NULL_VIOLATION;
-    if (code === PG_ERROR_CODES.CHECK_VIOLATION)
-        return DataErrorType.CHECK_VIOLATION;
-    if (code === PG_ERROR_CODES.EXCLUSION_VIOLATION)
-        return DataErrorType.EXCLUSION_VIOLATION;
-    return DataErrorType.UNKNOWN_ERROR;
-}
-function classifyByMessage(message) {
-    const lower = message.toLowerCase();
-    if (lower.includes('timeout') || lower.includes('timed out')) {
-        return DataErrorType.TIMEOUT_ERROR;
-    }
-    if (lower.includes('network') ||
-        lower.includes('fetch') ||
-        lower.includes('failed to fetch')) {
-        return DataErrorType.NETWORK_ERROR;
-    }
-    if (lower.includes('unauthorized') ||
-        lower.includes('authentication required')) {
-        return DataErrorType.UNAUTHORIZED;
-    }
-    if (lower.includes('forbidden') || lower.includes('permission')) {
-        return DataErrorType.FORBIDDEN;
-    }
-    if (lower.includes('duplicate key') || lower.includes('already exists')) {
-        return DataErrorType.UNIQUE_VIOLATION;
-    }
-    if (lower.includes('foreign key constraint')) {
-        return DataErrorType.FOREIGN_KEY_VIOLATION;
-    }
-    if (lower.includes('not-null constraint') ||
-        lower.includes('null value in column')) {
-        return DataErrorType.NOT_NULL_VIOLATION;
-    }
-    return DataErrorType.UNKNOWN_ERROR;
-}
-function extractFieldFromError(message, constraint, column) {
-    if (column)
-        return column;
-    const columnMatch = message.match(/column\s+"?([a-z_][a-z0-9_]*)"?/i);
-    if (columnMatch)
-        return columnMatch[1];
-    if (constraint) {
-        const constraintMatch = constraint.match(/_([a-z_][a-z0-9_]*)_(?:key|fkey|check|pkey)$/i);
-        if (constraintMatch)
-            return constraintMatch[1];
-    }
-    const keyMatch = message.match(/Key\s+\(([a-z_][a-z0-9_]*)\)/i);
-    if (keyMatch)
-        return keyMatch[1];
-    return undefined;
-}
-/**
- * Parse any error into a DataError
- */
-export function parseGraphQLError(error) {
-    if (error instanceof DataError) {
-        return error;
-    }
-    // GraphQL error object
-    if (error &&
-        typeof error === 'object' &&
-        'message' in error &&
-        typeof error.message === 'string') {
-        const gqlError = error;
-        const extCode = gqlError.extensions?.code;
-        const mappedType = parseGraphQLErrorCode(extCode);
-        const column = gqlError.extensions?.column;
-        const constraint = gqlError.extensions?.constraint;
-        const fieldName = extractFieldFromError(gqlError.message, constraint, column);
-        if (mappedType !== DataErrorType.UNKNOWN_ERROR) {
-            return new DataError(mappedType, gqlError.message, {
-                code: extCode,
-                fieldName,
-                constraint,
-                context: gqlError.extensions,
-            });
-        }
-        // Fallback: classify by message
-        const fallbackType = classifyByMessage(gqlError.message);
-        return new DataError(fallbackType, gqlError.message, {
-            code: extCode,
-            fieldName,
-            constraint,
-            context: gqlError.extensions,
-        });
-    }
-    // Standard Error
-    if (error instanceof Error) {
-        const type = classifyByMessage(error.message);
-        return new DataError(type, error.message, { originalError: error });
-    }
-    // Unknown
-    const message = typeof error === 'string' ? error : 'Unknown error occurred';
-    return new DataError(DataErrorType.UNKNOWN_ERROR, message);
-}
-/**
- * Check if value is a DataError
- */
-export function isDataError(error) {
-    return error instanceof DataError;
-}
+export { DataError, DataErrorType, PG_ERROR_CODES, createError, parseGraphQLError, isDataError, } from '@constructive-io/graphql-query';

package/esm/client/execute.d.ts

@@ -1,57 +1,4 @@
 /**
- * GraphQL execution utilities
+ * Re-export GraphQL execution utilities from @constructive-io/graphql-query.
  */
-import type { DocumentNode } from 'graphql';
-import { TypedDocumentString } from './typed-document';
-type ExecutableDocument = TypedDocumentString<unknown, unknown> | DocumentNode | string;
-type ResultOf<TDocument> = TDocument extends TypedDocumentString<infer TResult, unknown> ? TResult : unknown;
-type VariablesOf<TDocument> = TDocument extends TypedDocumentString<unknown, infer TVariables> ? TVariables : Record<string, unknown>;
-export interface ExecuteOptions {
-    /** Custom headers to include */
-    headers?: Record<string, string>;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-    /** Signal for request cancellation */
-    signal?: AbortSignal;
-}
-export interface GraphQLResponse<T = unknown> {
-    data?: T;
-    errors?: Array<{
-        message: string;
-        extensions?: {
-            code?: string;
-        } & Record<string, unknown>;
-        locations?: Array<{
-            line: number;
-            column: number;
-        }>;
-        path?: Array<string | number>;
-    }>;
-}
-/**
- * Execute a GraphQL operation against an endpoint
- */
-export declare function execute<TDocument extends ExecutableDocument>(endpoint: string, document: TDocument, variables?: VariablesOf<TDocument>, options?: ExecuteOptions): Promise<ResultOf<TDocument>>;
-export interface GraphQLClientOptions {
-    /** GraphQL endpoint URL */
-    endpoint: string;
-    /** Default headers to include with every request */
-    headers?: Record<string, string>;
-    /** Default timeout in milliseconds */
-    timeout?: number;
-}
-/**
- * Create a GraphQL client instance
- */
-export declare function createGraphQLClient(options: GraphQLClientOptions): {
-    /**
-     * Execute a GraphQL operation
-     */
-    execute<TDocument extends ExecutableDocument>(document: TDocument, variables?: VariablesOf<TDocument>, options?: ExecuteOptions): Promise<ResultOf<TDocument>>;
-    /**
-     * Get the endpoint URL
-     */
-    getEndpoint(): string;
-};
-export type GraphQLClient = ReturnType<typeof createGraphQLClient>;
-export {};
+export { execute, createGraphQLClient, type ExecuteOptions, type GraphQLResponse, type GraphQLClientOptions, type GraphQLClient, } from '@constructive-io/graphql-query';