@constructive-sdk/cli 0.25.15 → 0.25.17

package/config/cli/executor.d.ts

@@ -0,0 +1,52 @@
+export declare const getStore: () => import("appstash").ConfigStore;
+export declare function getClient(contextName?: string): {
+    platformConfigDefinition: import("../orm").PlatformConfigDefinitionModel;
+    platformConfig: import("../orm").PlatformConfigModel;
+    mutation: {
+        platformSecretsDel: <S extends import("../orm/input-types").PlatformSecretsDelPayloadSelect>(args: import("../orm/mutation").PlatformSecretsDelVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").PlatformSecretsDelPayloadSelect>) => import("../orm").QueryBuilder<{
+            platformSecretsDel: import("../orm").InferSelectResult<import("../orm/input-types").PlatformSecretsDelPayload, S> | null;
+        }>;
+        orgSecretsDel: <S extends import("../orm/input-types").OrgSecretsDelPayloadSelect>(args: import("../orm/mutation").OrgSecretsDelVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").OrgSecretsDelPayloadSelect>) => import("../orm").QueryBuilder<{
+            orgSecretsDel: import("../orm").InferSelectResult<import("../orm/input-types").OrgSecretsDelPayload, S> | null;
+        }>;
+        platformSecretsRemoveArray: <S extends import("../orm/input-types").PlatformSecretsRemoveArrayPayloadSelect>(args: import("../orm/mutation").PlatformSecretsRemoveArrayVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").PlatformSecretsRemoveArrayPayloadSelect>) => import("../orm").QueryBuilder<{
+            platformSecretsRemoveArray: import("../orm").InferSelectResult<import("../orm/input-types").PlatformSecretsRemoveArrayPayload, S> | null;
+        }>;
+        orgSecretsRemoveArray: <S extends import("../orm/input-types").OrgSecretsRemoveArrayPayloadSelect>(args: import("../orm/mutation").OrgSecretsRemoveArrayVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").OrgSecretsRemoveArrayPayloadSelect>) => import("../orm").QueryBuilder<{
+            orgSecretsRemoveArray: import("../orm").InferSelectResult<import("../orm/input-types").OrgSecretsRemoveArrayPayload, S> | null;
+        }>;
+        platformSecretsRotate: <S extends import("../orm/input-types").PlatformSecretsRotatePayloadSelect>(args: import("../orm/mutation").PlatformSecretsRotateVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").PlatformSecretsRotatePayloadSelect>) => import("../orm").QueryBuilder<{
+            platformSecretsRotate: import("../orm").InferSelectResult<import("../orm/input-types").PlatformSecretsRotatePayload, S> | null;
+        }>;
+        platformSecretsSet: <S extends import("../orm/input-types").PlatformSecretsSetPayloadSelect>(args: import("../orm/mutation").PlatformSecretsSetVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").PlatformSecretsSetPayloadSelect>) => import("../orm").QueryBuilder<{
+            platformSecretsSet: import("../orm").InferSelectResult<import("../orm/input-types").PlatformSecretsSetPayload, S> | null;
+        }>;
+        orgSecretsRotate: <S extends import("../orm/input-types").OrgSecretsRotatePayloadSelect>(args: import("../orm/mutation").OrgSecretsRotateVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").OrgSecretsRotatePayloadSelect>) => import("../orm").QueryBuilder<{
+            orgSecretsRotate: import("../orm").InferSelectResult<import("../orm/input-types").OrgSecretsRotatePayload, S> | null;
+        }>;
+        orgSecretsSet: <S extends import("../orm/input-types").OrgSecretsSetPayloadSelect>(args: import("../orm/mutation").OrgSecretsSetVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").OrgSecretsSetPayloadSelect>) => import("../orm").QueryBuilder<{
+            orgSecretsSet: import("../orm").InferSelectResult<import("../orm/input-types").OrgSecretsSetPayload, S> | null;
+        }>;
+        provisionBucket: <S extends import("../orm/input-types").ProvisionBucketPayloadSelect>(args: import("../orm/mutation").ProvisionBucketVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").ProvisionBucketPayloadSelect>) => import("../orm").QueryBuilder<{
+            provisionBucket: import("../orm").InferSelectResult<import("../orm/input-types").ProvisionBucketPayload, S> | null;
+        }>;
+    };
+};

package/config/cli/executor.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStore = void 0;
+exports.getClient = getClient;
+/**
+ * Executor and config store for CLI
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const appstash_1 = require("appstash");
+const orm_1 = require("../orm");
+const store = (0, appstash_1.createConfigStore)('csdk');
+const getStore = () => store;
+exports.getStore = getStore;
+function getClient(contextName) {
+    let ctx = null;
+    if (contextName) {
+        ctx = store.loadContext(contextName);
+        if (!ctx) {
+            throw new Error(`Context "${contextName}" not found.`);
+        }
+    }
+    else {
+        ctx = store.getCurrentContext();
+        if (!ctx) {
+            throw new Error('No active context. Run "context create" or "context use" first.');
+        }
+    }
+    const headers = {};
+    if (store.hasValidCredentials(ctx.name)) {
+        const creds = store.getCredentials(ctx.name);
+        if (creds?.token) {
+            headers.Authorization = `Bearer ${creds.token}`;
+        }
+    }
+    return (0, orm_1.createClient)({
+        endpoint: ctx.endpoint,
+        headers: headers,
+    });
+}

package/config/cli/index.d.ts

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

package/config/cli/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CLI entry point
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const inquirerer_1 = require("inquirerer");
+const commands_1 = require("./commands");
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    const pkg = (0, inquirerer_1.getPackageJson)(__dirname);
+    console.log(pkg.version);
+    process.exit(0);
+}
+// Check for --tty false or --no-tty to enable non-interactive mode (noTty)
+const ttyIdx = process.argv.indexOf('--tty');
+const noTty = (ttyIdx !== -1 && process.argv[ttyIdx + 1] === 'false') || process.argv.includes('--no-tty');
+const options = {
+    noTty,
+    minimistOpts: { alias: { v: 'version', h: 'help' } },
+};
+const app = new inquirerer_1.CLI(commands_1.commands, options);
+app.run().catch((e) => {
+    console.error('Unexpected error:', e);
+    process.exit(1);
+});

package/config/cli/utils.d.ts

@@ -0,0 +1,88 @@
+export type FieldType = 'string' | 'boolean' | 'int' | 'float' | 'json' | 'uuid' | 'enum';
+export interface FieldSchema {
+    [fieldName: string]: FieldType;
+}
+/**
+ * Coerce CLI string arguments to their proper GraphQL types based on a field schema.
+ * CLI args always arrive as strings from minimist, but GraphQL expects
+ * Boolean, Int, Float, JSON, etc.
+ */
+export declare function coerceAnswers(answers: Record<string, unknown>, schema: FieldSchema): Record<string, unknown>;
+/**
+ * Strip undefined values and filter to only schema-defined keys.
+ * This removes extra fields injected by minimist (like _, tty, etc.)
+ * and any fields that were coerced to undefined.
+ */
+export declare function stripUndefined(obj: Record<string, unknown>, schema?: FieldSchema): Record<string, unknown>;
+/**
+ * Parse mutation input from CLI.
+ * Custom mutation commands receive an `input` field as a JSON string
+ * from the CLI prompt. This parses it into a proper object.
+ */
+export declare function parseMutationInput(answers: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Reconstruct nested objects from dot-notation CLI answers.
+ * When INPUT_OBJECT args are flattened to dot-notation questions
+ * (e.g. `--input.email foo --input.password bar`), this function
+ * rebuilds the nested structure expected by the ORM:
+ *
+ *   { 'input.email': 'foo', 'input.password': 'bar' }
+ *   → { input: { email: 'foo', password: 'bar' } }
+ *
+ * Non-dotted keys are passed through unchanged.
+ * Uses `nested-obj` for safe nested property setting.
+ */
+export declare function unflattenDotNotation(answers: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build a select object from a comma-separated list of dot-notation paths.
+ * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'
+ * into the nested structure expected by the ORM:
+ *
+ *   { clientMutationId: true, result: { select: { accessToken: true, userId: true } } }
+ *
+ * Paths without dots set the key to `true` (scalar select).
+ * Paths with dots create nested `{ select: { ... } }` wrappers, matching the
+ * ORM's expected structure for OBJECT sub-fields (e.g. `SignUpPayloadSelect.result`).
+ *
+ * @param paths - Comma-separated dot-notation field paths (e.g. 'clientMutationId,result.accessToken')
+ * @returns The nested select object for the ORM
+ */
+/**
+ * Parse a CLI flag as an integer.
+ * Handles minimist delivering numbers or strings depending on the input.
+ * Returns undefined when the flag is missing or not a valid number.
+ */
+export declare function parseIntFlag(argv: Record<string, unknown>, name: string): number | undefined;
+/**
+ * Parse a CLI flag as a string.
+ * Returns undefined when the flag is missing or not a string.
+ */
+export declare function parseStringFlag(argv: Record<string, unknown>, name: string): string | undefined;
+/**
+ * Parse --orderBy flag as a comma-separated list of enum values.
+ * e.g. --orderBy NAME_ASC,CREATED_AT_DESC → ['NAME_ASC', 'CREATED_AT_DESC']
+ */
+export declare function parseOrderByFlag(argv: Record<string, unknown>): string[] | undefined;
+/**
+ * Parse --select flag into a select object, falling back to a default.
+ * e.g. --select id,name → { id: true, name: true }
+ */
+export declare function parseSelectFlag(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build the full findManyArgs object from CLI argv.
+ * Parses all pagination, filtering, ordering, and field selection flags
+ * in one call.  Accepts an optional `extraWhere` to merge with dot-notation
+ * --where flags (used by the search handler to inject search clauses).
+ *
+ * @example
+ *   const findManyArgs = parseFindManyArgs(argv, { id: true, name: true });
+ *   const result = await client.user.findMany(findManyArgs).execute();
+ */
+export declare function parseFindManyArgs<T = Record<string, unknown>>(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>, extraWhere?: Record<string, unknown>): T;
+/**
+ * Build findFirst args from CLI argv.
+ * Like parseFindManyArgs but without pagination flags (no limit/offset/after/before/last)
+ * — findFirst returns the first matching record. Supports select, where, and orderBy.
+ */
+export declare function parseFindFirstArgs<T = Record<string, unknown>>(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>): T;
+export declare function buildSelectFromPaths(paths: string): Record<string, unknown>;

package/config/cli/utils.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceAnswers = coerceAnswers;
+exports.stripUndefined = stripUndefined;
+exports.parseMutationInput = parseMutationInput;
+exports.unflattenDotNotation = unflattenDotNotation;
+exports.parseIntFlag = parseIntFlag;
+exports.parseStringFlag = parseStringFlag;
+exports.parseOrderByFlag = parseOrderByFlag;
+exports.parseSelectFlag = parseSelectFlag;
+exports.parseFindManyArgs = parseFindManyArgs;
+exports.parseFindFirstArgs = parseFindFirstArgs;
+exports.buildSelectFromPaths = buildSelectFromPaths;
+/**
+ * CLI utility functions for type coercion and input handling
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const nested_obj_1 = __importDefault(require("nested-obj"));
+/**
+ * Coerce CLI string arguments to their proper GraphQL types based on a field schema.
+ * CLI args always arrive as strings from minimist, but GraphQL expects
+ * Boolean, Int, Float, JSON, etc.
+ */
+function coerceAnswers(answers, schema) {
+    const result = { ...answers };
+    for (const [key, value] of Object.entries(result)) {
+        const fieldType = schema[key];
+        if (!fieldType || value === undefined || value === null)
+            continue;
+        const strValue = String(value);
+        // Empty strings become undefined for non-string types
+        if (strValue === '' && fieldType !== 'string') {
+            result[key] = undefined;
+            continue;
+        }
+        switch (fieldType) {
+            case 'boolean':
+                if (typeof value === 'boolean')
+                    break;
+                result[key] = strValue === 'true' || strValue === '1' || strValue === 'yes';
+                break;
+            case 'int':
+                if (typeof value === 'number')
+                    break;
+                {
+                    const parsed = parseInt(strValue, 10);
+                    result[key] = isNaN(parsed) ? undefined : parsed;
+                }
+                break;
+            case 'float':
+                if (typeof value === 'number')
+                    break;
+                {
+                    const parsed = parseFloat(strValue);
+                    result[key] = isNaN(parsed) ? undefined : parsed;
+                }
+                break;
+            case 'json':
+                if (typeof value === 'object')
+                    break;
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                else {
+                    try {
+                        result[key] = JSON.parse(strValue);
+                    }
+                    catch {
+                        result[key] = undefined;
+                    }
+                }
+                break;
+            case 'uuid':
+                // Empty UUIDs become undefined
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+            case 'enum':
+                // Enums stay as strings but empty ones become undefined
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+            default:
+                // String type: empty strings also become undefined to avoid
+                // sending empty strings for optional fields
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Strip undefined values and filter to only schema-defined keys.
+ * This removes extra fields injected by minimist (like _, tty, etc.)
+ * and any fields that were coerced to undefined.
+ */
+function stripUndefined(obj, schema) {
+    const result = {};
+    const allowedKeys = schema ? new Set(Object.keys(schema)) : null;
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined)
+            continue;
+        if (allowedKeys && !allowedKeys.has(key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Parse mutation input from CLI.
+ * Custom mutation commands receive an `input` field as a JSON string
+ * from the CLI prompt. This parses it into a proper object.
+ */
+function parseMutationInput(answers) {
+    if (typeof answers.input === 'string') {
+        try {
+            const parsed = JSON.parse(answers.input);
+            return { ...answers, input: parsed };
+        }
+        catch {
+            return answers;
+        }
+    }
+    return answers;
+}
+/**
+ * Reconstruct nested objects from dot-notation CLI answers.
+ * When INPUT_OBJECT args are flattened to dot-notation questions
+ * (e.g. `--input.email foo --input.password bar`), this function
+ * rebuilds the nested structure expected by the ORM:
+ *
+ *   { 'input.email': 'foo', 'input.password': 'bar' }
+ *   → { input: { email: 'foo', password: 'bar' } }
+ *
+ * Non-dotted keys are passed through unchanged.
+ * Uses `nested-obj` for safe nested property setting.
+ */
+function unflattenDotNotation(answers) {
+    const result = {};
+    for (const [key, value] of Object.entries(answers)) {
+        if (key.includes('.')) {
+            nested_obj_1.default.set(result, key, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Build a select object from a comma-separated list of dot-notation paths.
+ * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'
+ * into the nested structure expected by the ORM:
+ *
+ *   { clientMutationId: true, result: { select: { accessToken: true, userId: true } } }
+ *
+ * Paths without dots set the key to `true` (scalar select).
+ * Paths with dots create nested `{ select: { ... } }` wrappers, matching the
+ * ORM's expected structure for OBJECT sub-fields (e.g. `SignUpPayloadSelect.result`).
+ *
+ * @param paths - Comma-separated dot-notation field paths (e.g. 'clientMutationId,result.accessToken')
+ * @returns The nested select object for the ORM
+ */
+/**
+ * Parse a CLI flag as an integer.
+ * Handles minimist delivering numbers or strings depending on the input.
+ * Returns undefined when the flag is missing or not a valid number.
+ */
+function parseIntFlag(argv, name) {
+    const val = argv[name];
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string') {
+        const n = parseInt(val, 10);
+        return isNaN(n) ? undefined : n;
+    }
+    return undefined;
+}
+/**
+ * Parse a CLI flag as a string.
+ * Returns undefined when the flag is missing or not a string.
+ */
+function parseStringFlag(argv, name) {
+    const val = argv[name];
+    return typeof val === 'string' ? val : undefined;
+}
+/**
+ * Parse --orderBy flag as a comma-separated list of enum values.
+ * e.g. --orderBy NAME_ASC,CREATED_AT_DESC → ['NAME_ASC', 'CREATED_AT_DESC']
+ */
+function parseOrderByFlag(argv) {
+    const val = argv.orderBy;
+    return typeof val === 'string' ? val.split(',') : undefined;
+}
+/**
+ * Parse --select flag into a select object, falling back to a default.
+ * e.g. --select id,name → { id: true, name: true }
+ */
+function parseSelectFlag(argv, defaultSelect) {
+    const raw = argv.select;
+    return typeof raw === 'string' ? buildSelectFromPaths(raw) : defaultSelect;
+}
+/**
+ * Build the full findManyArgs object from CLI argv.
+ * Parses all pagination, filtering, ordering, and field selection flags
+ * in one call.  Accepts an optional `extraWhere` to merge with dot-notation
+ * --where flags (used by the search handler to inject search clauses).
+ *
+ * @example
+ *   const findManyArgs = parseFindManyArgs(argv, { id: true, name: true });
+ *   const result = await client.user.findMany(findManyArgs).execute();
+ */
+function parseFindManyArgs(argv, defaultSelect, extraWhere) {
+    const limit = parseIntFlag(argv, 'limit');
+    const last = parseIntFlag(argv, 'last');
+    const offset = parseIntFlag(argv, 'offset');
+    const after = parseStringFlag(argv, 'after');
+    const before = parseStringFlag(argv, 'before');
+    const select = parseSelectFlag(argv, defaultSelect);
+    const parsed = unflattenDotNotation(argv);
+    const where = (parsed.where ?? extraWhere)
+        ? { ...(extraWhere ?? {}), ...(parsed.where ?? {}) }
+        : undefined;
+    const orderBy = parseOrderByFlag(argv);
+    return {
+        select,
+        ...(limit !== undefined ? { first: limit } : {}),
+        ...(after !== undefined ? { after } : {}),
+        ...(last !== undefined ? { last } : {}),
+        ...(before !== undefined ? { before } : {}),
+        ...(offset !== undefined ? { offset } : {}),
+        ...(where !== undefined ? { where } : {}),
+        ...(orderBy !== undefined ? { orderBy } : {}),
+    };
+}
+/**
+ * Build findFirst args from CLI argv.
+ * Like parseFindManyArgs but without pagination flags (no limit/offset/after/before/last)
+ * — findFirst returns the first matching record. Supports select, where, and orderBy.
+ */
+function parseFindFirstArgs(argv, defaultSelect) {
+    const select = parseSelectFlag(argv, defaultSelect);
+    const parsed = unflattenDotNotation(argv);
+    const where = parsed.where;
+    const orderBy = parseOrderByFlag(argv);
+    return {
+        select,
+        ...(where !== undefined ? { where } : {}),
+        ...(orderBy !== undefined ? { orderBy } : {}),
+    };
+}
+function buildSelectFromPaths(paths) {
+    const result = {};
+    const trimmedPaths = paths
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    for (const path of trimmedPaths) {
+        if (!path.includes('.')) {
+            // Simple scalar field: clientMutationId -> { clientMutationId: true }
+            result[path] = true;
+        }
+        else {
+            // Nested path: result.accessToken -> { result: { select: { accessToken: true } } }
+            // Convert dot-notation to ORM's { select: { ... } } nesting pattern
+            const parts = path.split('.');
+            let current = result;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (i === parts.length - 1) {
+                    // Leaf node: set to true
+                    nested_obj_1.default.set(current, part, true);
+                }
+                else {
+                    // Intermediate node: ensure { select: { ... } } wrapper exists
+                    if (!current[part] || typeof current[part] !== 'object') {
+                        current[part] = { select: {} };
+                    }
+                    const wrapper = current[part];
+                    if (!wrapper.select || typeof wrapper.select !== 'object') {
+                        wrapper.select = {};
+                    }
+                    current = wrapper.select;
+                }
+            }
+        }
+    }
+    return result;
+}

package/config/index.d.ts

@@ -1,2 +1,6 @@
-export { getAppDirs, getConfigStore } from './app-dirs';
-export type { AppDirOptions } from './app-dirs';
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+export * from './orm';
+export * from './cli';

package/config/index.js

@@ -1,6 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigStore = exports.getAppDirs = void 0;
-var app_dirs_1 = require("./app-dirs");
-Object.defineProperty(exports, "getAppDirs", { enumerable: true, get: function () { return app_dirs_1.getAppDirs; } });
-Object.defineProperty(exports, "getConfigStore", { enumerable: true, get: function () { return app_dirs_1.getConfigStore; } });
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+__exportStar(require("./orm"), exports);
+__exportStar(require("./cli"), exports);

package/config/orm/client.d.ts

@@ -0,0 +1,97 @@
+/**
+ * ORM Client - Runtime GraphQL executor
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { GraphQLAdapter, GraphQLError, QueryResult } from '@constructive-io/graphql-query/runtime';
+import type { ConnectionState, ConnectionStateListener, RealtimeConfig, SubscriptionEvent, SubscriptionFieldMeta, Unsubscribe } from './realtime';
+export type { GraphQLAdapter, GraphQLError, QueryResult, } from '@constructive-io/graphql-query/runtime';
+export type { ConnectionState, ConnectionStateListener, RealtimeConfig, SubscribeOptions, SubscriptionEvent, SubscriptionFieldMeta, SubscriptionOperation, Unsubscribe, WsClient, } from './realtime';
+export { RealtimeManager } from './realtime';
+/**
+ * Default adapter that uses fetch for HTTP requests.
+ *
+ * When no custom fetch is provided, uses @constructive-io/fetch which
+ * handles *.localhost DNS rewriting and Host header preservation in
+ * Node.js. Pass a custom fetch to override for test mocking or custom
+ * proxy/credentials.
+ */
+export declare class FetchAdapter implements GraphQLAdapter {
+    private endpoint;
+    private headers;
+    private fetchFn;
+    constructor(endpoint: string, headers?: Record<string, string>, fetchFn?: typeof globalThis.fetch);
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    setHeaders(headers: Record<string, string>): void;
+    getEndpoint(): string;
+}
+/**
+ * Configuration for creating an ORM client.
+ * Either provide endpoint (and optional headers/fetch) for HTTP requests,
+ * or provide a custom adapter for alternative execution strategies.
+ */
+export interface OrmClientConfig {
+    /** GraphQL endpoint URL (required if adapter not provided) */
+    endpoint?: string;
+    /** Default headers for HTTP requests (only used with endpoint) */
+    headers?: Record<string, string>;
+    /**
+     * Custom fetch implementation. Defaults to createFetch() from
+     * @constructive-io/graphql-query/runtime which handles *.localhost
+     * DNS and Host headers in Node.js. Pass your own for test mocking
+     * or custom proxy/credentials.
+     */
+    fetch?: typeof globalThis.fetch;
+    /** Custom adapter for GraphQL execution (overrides endpoint/headers/fetch) */
+    adapter?: GraphQLAdapter;
+    /**
+     * Optional realtime (WebSocket) configuration.
+     * When provided, enables subscription methods on models.
+     * The WebSocket connection is created lazily on first subscribe().
+     */
+    realtime?: RealtimeConfig;
+}
+/**
+ * Error thrown when GraphQL request fails
+ */
+export declare class GraphQLRequestError extends Error {
+    readonly errors: GraphQLError[];
+    readonly data: unknown;
+    constructor(errors: GraphQLError[], data?: unknown);
+}
+export declare class OrmClient {
+    private adapter;
+    private realtimeManager?;
+    constructor(config: OrmClientConfig);
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Used by generated model subscribe() methods.
+     * @throws Error if realtime is not configured
+     */
+    subscribe<T>(meta: SubscriptionFieldMeta, document: string, variables: Record<string, unknown>, options: {
+        onEvent: (event: SubscriptionEvent<T>) => void;
+        onError?: (error: Error) => void;
+        onComplete?: () => void;
+    }): Unsubscribe;
+    /**
+     * Set headers for requests.
+     * Only works if the adapter supports headers.
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Get the endpoint URL.
+     * Returns empty string if the adapter doesn't have an endpoint.
+     */
+    getEndpoint(): string;
+    /** Get current WebSocket connection state */
+    getConnectionState(): ConnectionState;
+    /** Register a listener for WebSocket connection state changes */
+    onConnectionStateChange(listener: ConnectionStateListener): Unsubscribe;
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount(): number;
+    /** Whether realtime is configured */
+    get isRealtimeEnabled(): boolean;
+    /** Dispose the realtime manager (close WebSocket) */
+    dispose(): void;
+}