@agentic-kit/db-tools 0.11.5 → 0.12.1

package/esm/db-probe.d.ts

@@ -1,30 +1,38 @@
+import { postGraphQL } from './graphql-http';
+export type UnreachableCause = 'network' | 'server' | 'auth' | 'error';
 export type DatabaseProbe = {
-    outcome: 'found';
+    status: 'found';
+    databaseId: string;
+    name?: string;
+    ownerId?: string;
+    hash?: string;
+} | {
+    status: 'suspended';
+    databaseId: string;
     name?: string;
     ownerId?: string;
+    hash?: string;
+    suspendedAt: string;
+    suspendedReason?: string;
 } | {
-    outcome: 'missing';
+    status: 'missing';
+    databaseId: string;
 } | {
-    outcome: 'unreachable';
+    status: 'unreachable';
+    databaseId: string;
+    cause: UnreachableCause;
     detail: string;
 };
-export type ProbeExecutor = {
-    execute<T>(document: string, variables?: Record<string, unknown>): Promise<{
-        ok: true;
-        data: T;
-        errors: undefined;
-    } | {
-        ok: false;
-        data: null;
-        errors: {
-            message: string;
-        }[];
-    }>;
-};
 export declare function probeDatabase(args: {
     endpoint: string;
     bearer: string;
     databaseId: string;
-    executor?: ProbeExecutor;
     signInHint?: string;
+    post?: typeof postGraphQL;
 }): Promise<DatabaseProbe>;
+/**
+ * Probe a database with the host's account bearer on its configured control
+ * endpoint (never a project-pinned one). Without a bearer the answer is
+ * unreachable with cause 'auth'.
+ */
+export declare function probeBoundDatabase(databaseId: string): Promise<DatabaseProbe>;

package/esm/db-probe.js

@@ -1,47 +1,106 @@
-import { api } from '@constructive-io/sdk';
-const AUTH_ERROR_RE = /unauthenticated|unauthorized|permission denied|jwt|http 401|http 403/i;
-// Liveness probe for a bound database. The split drives recovery: 'missing'
-// means the backend answered and the binding is dead (database deleted,
-// backend refreshed) — recovery is reprovision. 'unreachable' means no usable
-// answer (backend down, network error, rejected credential) — recovery is
-// retry/re-sign-in, never reprovision.
+import { classifyBackendErrors, errorsText, postGraphQL } from './graphql-http';
+import { getHost } from './host';
+const DEFAULT_API_ENDPOINT = 'http://api.localhost:3000/graphql';
+const FIELDS = 'id name ownerId hash suspendedAt suspendedReason';
+// A backend from before `hash` and the suspension columns.
+const BASIC_FIELDS = 'id name ownerId';
+const NEWER_FIELD_RE = /\b(hash|suspended_?at|suspended_?reason)\b/i;
+const document = (databaseId, fields) => `
+    query ProbeDatabase {
+      databases(where: { id: { equalTo: ${JSON.stringify(databaseId)} } }, first: 1) {
+        nodes { ${fields} }
+      }
+    }`;
+// Liveness probe for a bound database, on the platform api. Only 'missing'
+// means the binding is dead: the backend answered and the account can't see
+// the database (deleted, or access to it lost). 'suspended' means it exists
+// and is held, so its data must not be replaced. 'unreachable' is any answer
+// that says nothing about the database (no response, a failing backend, a
+// rejected account credential, an error this probe doesn't know); recovery is
+// a retry or a sign-in, never a reprovision.
 //
 // The probe authenticates with the ACCOUNT bearer, not the project's .env key:
 // the platform api rejects per-database keys, and the singular `database(id:)`
 // field is gone from the current contract, so the lookup goes through the
-// `databases` collection filter via the SDK's raw FetchAdapter.
+// `databases` collection filter.
 export async function probeDatabase(args) {
-    const executor = args.executor ??
-        new api.FetchAdapter(args.endpoint, { Authorization: `Bearer ${args.bearer}` });
-    const document = `
-    query ProbeDatabase {
-      databases(where: { id: { equalTo: ${JSON.stringify(args.databaseId)} } }) {
-        nodes { id name ownerId }
-      }
-    }`;
-    try {
-        const result = await executor.execute(document);
-        if (result.ok) {
-            const node = result.data.databases?.nodes?.[0];
-            if (!node)
-                return { outcome: 'missing' };
-            return { outcome: 'found', name: node.name ?? undefined, ownerId: node.ownerId ?? undefined };
-        }
-        const detail = result.errors?.[0]?.message ?? 'unknown error';
-        // A 5xx is the backend failing, not an answer about this database. An auth
-        // rejection is a dead ACCOUNT credential — never evidence the binding is
-        // dead, so it must not push toward reprovision.
-        if (/^HTTP 5\d\d/i.test(detail))
-            return { outcome: 'unreachable', detail };
-        if (AUTH_ERROR_RE.test(detail)) {
+    const post = args.post ?? postGraphQL;
+    const { databaseId } = args;
+    const ask = (fields) => post({
+        endpoint: args.endpoint,
+        headers: { Authorization: `Bearer ${args.bearer}` },
+        query: document(databaseId, fields),
+    });
+    let result = await ask(FIELDS);
+    if (result.errors.length > 0 && result.errors.some((e) => NEWER_FIELD_RE.test(e?.message ?? ''))) {
+        result = await ask(BASIC_FIELDS);
+    }
+    if (result.errors.length > 0)
+        return unreachable(databaseId, result.errors, args.signInHint);
+    const nodes = result.data?.databases?.nodes;
+    if (!Array.isArray(nodes)) {
+        return { status: 'unreachable', databaseId, cause: 'error', detail: 'the backend answered without a databases list' };
+    }
+    const node = nodes[0];
+    if (!node)
+        return { status: 'missing', databaseId };
+    const found = {
+        databaseId,
+        name: node.name ?? undefined,
+        ownerId: node.ownerId ?? undefined,
+        hash: node.hash ?? undefined,
+    };
+    if (node.suspendedAt) {
+        return {
+            status: 'suspended',
+            ...found,
+            suspendedAt: node.suspendedAt,
+            suspendedReason: node.suspendedReason ?? undefined,
+        };
+    }
+    return { status: 'found', ...found };
+}
+function unreachable(databaseId, errors, signInHint) {
+    const detail = errorsText(errors);
+    switch (classifyBackendErrors(errors)) {
+        case 'network':
+            return { status: 'unreachable', databaseId, cause: 'network', detail };
+        case 'server':
+            return { status: 'unreachable', databaseId, cause: 'server', detail };
+        case 'auth':
+        case 'forbidden':
+            // A rejected ACCOUNT credential is never evidence the binding is dead.
             return {
-                outcome: 'unreachable',
-                detail: `${detail} — the account credential was rejected. ${args.signInHint ?? 'Sign in again, then retry.'}`,
+                status: 'unreachable',
+                databaseId,
+                cause: 'auth',
+                detail: `${detail}: the account credential was rejected. ${signInHint ?? 'Sign in again, then retry.'}`,
             };
-        }
-        return { outcome: 'missing' };
+        default:
+            return { status: 'unreachable', databaseId, cause: 'error', detail };
     }
-    catch (err) {
-        return { outcome: 'unreachable', detail: err instanceof Error ? err.message : String(err) };
+}
+/**
+ * Probe a database with the host's account bearer on its configured control
+ * endpoint (never a project-pinned one). Without a bearer the answer is
+ * unreachable with cause 'auth'.
+ */
+export async function probeBoundDatabase(databaseId) {
+    const host = getHost();
+    const account = host.account();
+    const bearer = account?.apiKey ?? account?.accessToken;
+    if (!bearer) {
+        return {
+            status: 'unreachable',
+            databaseId,
+            cause: 'auth',
+            detail: `No usable account credential. ${host.signInHint ?? 'Sign in to the app, then retry.'}`,
+        };
     }
+    return probeDatabase({
+        endpoint: host.backendConfig()?.apiEndpoint || DEFAULT_API_ENDPOINT,
+        bearer,
+        databaseId,
+        signInHint: host.signInHint,
+    });
 }

package/esm/graphql-http.d.ts

@@ -0,0 +1,35 @@
+import { type GraphQLAdapter, type GraphQLError } from '@constructive-io/graphql-query/runtime';
+export type { GraphQLError };
+export type HttpGraphQLResponse<T> = {
+    /** The response status, or null when no response arrived. */
+    httpStatus: number | null;
+    data: T | null;
+    /**
+     * Body errors, each with `extensions.httpStatus` added. A non-2xx without
+     * body errors becomes one `{ code: 'HTTP_ERROR', httpStatus }` error, and a
+     * fetch that threw becomes one `{ code: 'NETWORK' }` error.
+     */
+    errors: GraphQLError[];
+};
+export type PostGraphQLArgs = {
+    endpoint: string;
+    headers?: Record<string, string>;
+    query: string;
+    variables?: Record<string, unknown>;
+    fetchFn?: typeof fetch;
+};
+export declare function postGraphQL<T>(args: PostGraphQLArgs): Promise<HttpGraphQLResponse<T>>;
+/**
+ * An ORM adapter over `postGraphQL`: the SDK clients take it in place of their
+ * FetchAdapter, and their failures then carry the status and code.
+ */
+export declare function statusAdapter(endpoint: string, headers?: Record<string, string>, fetchFn?: typeof fetch): GraphQLAdapter;
+export type BackendErrorKind = 'suspended' | 'auth' | 'forbidden' | 'server' | 'network' | 'graphql';
+/**
+ * What a failed backend answer says, first match wins: the database is
+ * suspended or gone (`ACCESS_SUSPENDED`), no response, the backend failing
+ * (5xx, 429), a rejected credential (401), a refusal (403), or anything else.
+ */
+export declare function classifyBackendErrors(errors: readonly GraphQLError[]): BackendErrorKind;
+/** The messages of a failed answer, joined for a reason string. */
+export declare function errorsText(errors: readonly GraphQLError[]): string;

package/esm/graphql-http.js

@@ -0,0 +1,134 @@
+// A GraphQL POST that keeps what the SDK's FetchAdapter throws away. That
+// adapter turns any non-2xx into `HTTP 403: Forbidden` and drops the body, so
+// a tenant API's `ACCESS_SUSPENDED` (a 403 with a JSON body, sent for a
+// deleted or suspended database) reads the same as any other refusal. Here
+// the body's errors keep their `extensions.code`, and every error carries the
+// HTTP status it arrived with.
+import { createFetch, } from '@constructive-io/graphql-query/runtime';
+const errorText = (err) => (err instanceof Error ? err.message : String(err));
+export async function postGraphQL(args) {
+    const fetchFn = (args.fetchFn ?? createFetch()).bind(globalThis);
+    let response;
+    try {
+        response = await fetchFn(args.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...args.headers,
+            },
+            body: JSON.stringify({ query: args.query, variables: args.variables ?? {} }),
+        });
+    }
+    catch (err) {
+        const cause = err?.cause?.code;
+        return {
+            httpStatus: null,
+            data: null,
+            errors: [
+                {
+                    message: typeof cause === 'string' ? `${errorText(err)} (${cause})` : errorText(err),
+                    extensions: { code: 'NETWORK' },
+                },
+            ],
+        };
+    }
+    const httpStatus = response.status;
+    let body = null;
+    try {
+        body = (await response.json());
+    }
+    catch {
+        body = null;
+    }
+    const bodyErrors = Array.isArray(body?.errors) ? body.errors : [];
+    if (bodyErrors.length > 0) {
+        return {
+            httpStatus,
+            data: body?.data ?? null,
+            errors: bodyErrors.map((error) => ({
+                ...error,
+                message: error?.message ?? '',
+                extensions: { ...error?.extensions, httpStatus },
+            })),
+        };
+    }
+    if (!response.ok || !body) {
+        const text = response.statusText ? `: ${response.statusText}` : '';
+        return {
+            httpStatus,
+            data: null,
+            errors: [
+                {
+                    message: response.ok ? `HTTP ${httpStatus}${text} (the body was not JSON)` : `HTTP ${httpStatus}${text}`,
+                    extensions: { code: 'HTTP_ERROR', httpStatus },
+                },
+            ],
+        };
+    }
+    return { httpStatus, data: body.data ?? null, errors: [] };
+}
+/**
+ * An ORM adapter over `postGraphQL`: the SDK clients take it in place of their
+ * FetchAdapter, and their failures then carry the status and code.
+ */
+export function statusAdapter(endpoint, headers, fetchFn) {
+    let current = { ...headers };
+    return {
+        async execute(document, variables) {
+            const result = await postGraphQL({ endpoint, headers: current, query: document, variables, fetchFn });
+            return result.errors.length > 0
+                ? { ok: false, data: null, errors: result.errors }
+                : { ok: true, data: result.data, errors: undefined };
+        },
+        setHeaders(next) {
+            current = { ...current, ...next };
+        },
+        getEndpoint: () => endpoint,
+    };
+}
+const codeOf = (error) => {
+    const code = error?.extensions?.code;
+    return typeof code === 'string' ? code : undefined;
+};
+// The status an error arrived with: ours from extensions, or the SDK
+// adapter's `HTTP 503: …` message.
+const statusOf = (error) => {
+    const status = error?.extensions?.httpStatus;
+    if (typeof status === 'number')
+        return status;
+    const match = /^HTTP (\d{3})\b/.exec(error?.message ?? '');
+    return match ? Number(match[1]) : undefined;
+};
+const AUTH_MESSAGE_RE = /jwt|unauthenticated|invalid token/i;
+const FORBIDDEN_MESSAGE_RE = /permission denied/i;
+/**
+ * What a failed backend answer says, first match wins: the database is
+ * suspended or gone (`ACCESS_SUSPENDED`), no response, the backend failing
+ * (5xx, 429), a rejected credential (401), a refusal (403), or anything else.
+ */
+export function classifyBackendErrors(errors) {
+    const list = errors ?? [];
+    const some = (test) => list.some((error) => test(error));
+    if (some((e) => codeOf(e) === 'ACCESS_SUSPENDED'))
+        return 'suspended';
+    if (some((e) => codeOf(e) === 'NETWORK'))
+        return 'network';
+    if (some((e) => {
+        const status = statusOf(e);
+        return status !== undefined && (status >= 500 || status === 429);
+    })) {
+        return 'server';
+    }
+    if (some((e) => statusOf(e) === 401 || codeOf(e) === 'UNAUTHENTICATED' || AUTH_MESSAGE_RE.test(e?.message ?? ''))) {
+        return 'auth';
+    }
+    if (some((e) => statusOf(e) === 403 || codeOf(e) === 'FORBIDDEN' || FORBIDDEN_MESSAGE_RE.test(e?.message ?? ''))) {
+        return 'forbidden';
+    }
+    return 'graphql';
+}
+/** The messages of a failed answer, joined for a reason string. */
+export function errorsText(errors) {
+    return (errors ?? []).map((error) => error?.message || codeOf(error) || 'unknown error').join('; ');
+}

package/esm/host.d.ts

@@ -74,6 +74,23 @@ export type StepUpRequest = {
     databaseName: string;
     apiEndpoint: string;
 };
+/**
+ * The database a project is bound to, handed to the host before provisioning
+ * writes it to the project's `.env`, so a host that keeps its own record of
+ * the binding never ends up with a `.env` it doesn't know about.
+ */
+export type ProjectBinding = {
+    cwd: string;
+    databaseId: string;
+    databaseName: string;
+    ownerId: string;
+    apiEndpoint: string;
+    modulesEndpoint: string;
+    /** The database this binding replaced (replace mode). */
+    replaces?: string;
+    /** True when the existing binding was kept: nothing was provisioned. */
+    skipped?: boolean;
+};
 export interface ToolsHost {
     /** Signed-in platform account, or null/undefined when signed out. */
     account(): HostAccount | null | undefined;
@@ -91,6 +108,13 @@ export interface ToolsHost {
     previewToken?(): Promise<PreviewToken | null>;
     /** Treat tokens expiring within this window as already expired. Default 30s. */
     dataTokenSkewMs?: number;
+    /**
+     * How long provision_database waits for a provision ticket to complete.
+     * Default 240s, which keeps an agent tool call under a 5-minute tool
+     * timeout; a host that calls the tool outside such a timeout (e.g. a
+     * pipeline) can wait longer for a cold provision on a loaded backend.
+     */
+    provisionPollDeadlineMs?: number;
     /**
      * Optional provision overlay: pick a base preset and/or layer module
      * add/remove on top of it. The base module list always comes from the pinned
@@ -109,7 +133,29 @@ export interface ToolsHost {
      * Required for create_api_key — without it the tool refuses to mint.
      */
     deliverSecret?(delivery: SecretDelivery): Promise<void>;
+    /**
+     * What to tell the agent to do about a database that is gone or belongs to
+     * another account, in place of the default advice to call
+     * provision_database with `reprovision: true`.
+     */
+    reprovisionHint?: string;
+    /**
+     * Whether the agent may replace a binding through provision_database's
+     * `reprovision: true`. Default true. A host that replaces databases only
+     * after the user approves (calling `provisionDatabase` in replace mode
+     * itself) sets false, and the tool then refuses.
+     */
+    toolReprovision?: boolean;
+    /**
+     * Save a binding in the host's own store. Provisioning calls it before
+     * writing `.env`, on a new binding and on a kept one (`skipped`). If it
+     * throws, `.env` is left alone, the provision ticket stays recorded, and
+     * the call fails with `binding-not-saved`.
+     */
+    persistBinding?(binding: ProjectBinding): Promise<void>;
 }
 export declare const DEFAULT_DATA_TOKEN_SKEW_MS = 30000;
+/** The advice for a database that is gone or under another account. */
+export declare function reprovisionAdvice(host: ToolsHost): string;
 export declare function configureHost(host: ToolsHost): void;
 export declare function getHost(): ToolsHost;

package/esm/host.js

@@ -11,6 +11,15 @@
  * on behalf of, so the same contract serves whichever adapter runs the tools.
  */
 export const DEFAULT_DATA_TOKEN_SKEW_MS = 30_000;
+const DEFAULT_REPROVISION_ADVICE = 'Re-provision with provision_database (reprovision: true): the schema is rebuilt from the project, and records do not carry over.';
+/** The advice for a database that is gone or under another account. */
+export function reprovisionAdvice(host) {
+    if (host.reprovisionHint)
+        return host.reprovisionHint;
+    if (host.toolReprovision === false)
+        return 'Ask the user to re-provision it from the app.';
+    return DEFAULT_REPROVISION_ADVICE;
+}
 let currentHost = null;
 export function configureHost(host) {
     currentHost = host;

package/esm/index.d.ts

@@ -10,12 +10,21 @@ import { type ToolsHost } from './host';
 export declare const constructiveDbTools: readonly AnyHarnessTool[];
 /** Configure the host and get the tools in one call. */
 export declare function createConstructiveDbTools(host: ToolsHost): readonly AnyHarnessTool[];
-export { CONTEXT_ENV_KEYS, CONTEXT_ENV_PREFIX, type ContextEnvKey, type ContextSource, deriveSubdomainEndpoint, fromEnvFile, fromEnvironment, type ModulesClient, type ProjectContext, type ProjectContextFailureCode, resolveDataToken, resolveProjectContext, } from './context';
+export { BlueprintBuildError, buildBlueprint, CONSTRUCTION_DEADLINE_MS, type ConstructionTableMap, readConstructionFailure, waitForConstruction, type WaitForConstructionOptions, } from './blueprint-construction';
+export { CONTEXT_ENV_KEYS, CONTEXT_ENV_PREFIX, type ContextEnvKey, type ContextSource, deriveSubdomainEndpoint, fromEnvFile, fromEnvironment, type ModulesClient, type ProjectContext, type ProjectContextFailureCode, resolveDataToken, resolveProjectContext, type ResolveResult, } from './context';
+export { type DatabaseProbe, probeBoundDatabase, probeDatabase, type UnreachableCause, } from './db-probe';
 export { constructiveGateDeps, type ConstructiveGateResolvers } from './gate';
-export { type ActiveDataToken, configureHost, type DataAuthBroker, DEFAULT_DATA_TOKEN_SKEW_MS, getHost, type HostAccount, type HostBackendConfig, type HostProvisionOverlay, type PreviewToken, type SecretDelivery, type StepUpRequest, type ToolsHost, } from './host';
+export { type BackendErrorKind, classifyBackendErrors, type HttpGraphQLResponse, postGraphQL, statusAdapter, } from './graphql-http';
+export { type ActiveDataToken, configureHost, type DataAuthBroker, DEFAULT_DATA_TOKEN_SKEW_MS, getHost, type HostAccount, type HostBackendConfig, type HostProvisionOverlay, type PreviewToken, type ProjectBinding, type SecretDelivery, type StepUpRequest, type ToolsHost, } from './host';
+export { archiveBindingKeys, ARCHIVED_BINDING_KEYS, type EnvVars, mergeEnv, provisionEnvVars, readEnv, } from './provision-database/env-file';
 export { loadProvisionManifest, parseProvisionManifest, PROVISION_MANIFEST_FILE, type ProvisionManifest, } from './provision-database/manifest';
 export { allModulePresets, DEFAULT_PROVISION_PRESET, getModulePreset, type ModulePreset, type ProvisionModule, } from './provision-database/presets';
+export { provisionDatabase, type ProvisionDatabaseDetails, type ProvisionFailureCode, type ProvisionInput, } from './provision-database/provision';
 export { moduleKey, type ProvisionOverlay, resolveProvisionModules, } from './provision-database/resolve';
+export { accessOf, type ColumnDefault, type FkAction, type ModelColumn, type ModelForeignKey, type ModelPolicy, type ModelTable, type ObjectCategory, readSchemaModel, type SchemaModel, SchemaReadError, type TableAccess, } from './schema-model';
 export { toolSchema } from './tool-schema';
+export { type AddRecordsDetails } from './tools/add-records';
+export { type CreateApiKeyDetails } from './tools/create-api-key';
+export { type RunCodegenDetails, type RunCodegenTimings } from './tools/run-codegen';
 export { createTemplatePreviewTables } from './tools/templates';
 export default constructiveDbTools;

package/esm/index.js

@@ -42,12 +42,18 @@ export function createConstructiveDbTools(host) {
     configureHost(host);
     return constructiveDbTools;
 }
+export { BlueprintBuildError, buildBlueprint, CONSTRUCTION_DEADLINE_MS, readConstructionFailure, waitForConstruction, } from './blueprint-construction';
 export { CONTEXT_ENV_KEYS, CONTEXT_ENV_PREFIX, deriveSubdomainEndpoint, fromEnvFile, fromEnvironment, resolveDataToken, resolveProjectContext, } from './context';
+export { probeBoundDatabase, probeDatabase, } from './db-probe';
 export { constructiveGateDeps } from './gate';
+export { classifyBackendErrors, postGraphQL, statusAdapter, } from './graphql-http';
 export { configureHost, DEFAULT_DATA_TOKEN_SKEW_MS, getHost, } from './host';
+export { archiveBindingKeys, ARCHIVED_BINDING_KEYS, mergeEnv, provisionEnvVars, readEnv, } from './provision-database/env-file';
 export { loadProvisionManifest, parseProvisionManifest, PROVISION_MANIFEST_FILE, } from './provision-database/manifest';
 export { allModulePresets, DEFAULT_PROVISION_PRESET, getModulePreset, } from './provision-database/presets';
+export { provisionDatabase, } from './provision-database/provision';
 export { moduleKey, resolveProvisionModules, } from './provision-database/resolve';
+export { accessOf, readSchemaModel, SchemaReadError, } from './schema-model';
 export { toolSchema } from './tool-schema';
 export { createTemplatePreviewTables } from './tools/templates';
 export default constructiveDbTools;

package/esm/provision-database/env-file.d.ts

@@ -1,10 +1,31 @@
 export type EnvVars = Record<string, string>;
+/** Parse .env text: quoted values, `export` prefixes and comments; last definition wins. */
+export declare function readEnv(content: string): EnvVars;
 /**
- * Upsert `vars` into the existing `.env` `content`. Existing keys are replaced
- * in place (preserving surrounding lines/comments); new keys are appended.
+ * Upsert `vars` into the existing `.env` `content`. An existing key is
+ * replaced in place (keeping an `export` prefix), and any later definition of
+ * it is dropped so the new value is the one that wins; new keys are appended.
  * Returns the new file body, trailing-newline-terminated.
  */
 export declare function mergeEnv(content: string, vars: EnvVars): string;
+/**
+ * Drop every definition of `keys`. Comments and other entries pass through,
+ * and content without those keys comes back unchanged.
+ */
+export declare function removeEnvKeys(content: string, keys: readonly string[]): string;
+/**
+ * The provision request provision_database is still waiting on, recorded when
+ * it stops waiting so the next call resumes that ticket. It's resumed only
+ * for the same database name, backend and account. Absent whenever no request
+ * is pending.
+ */
+export declare const PENDING_PROVISION_KEYS: {
+    readonly ticketId: "PROVISION_TICKET_ID";
+    readonly databaseName: "PROVISION_TICKET_DATABASE_NAME";
+    readonly apiEndpoint: "PROVISION_TICKET_API_ENDPOINT";
+    readonly userId: "PROVISION_TICKET_USER_ID";
+    readonly attempts: "PROVISION_TICKET_ATTEMPTS";
+};
 /** The credential keys provision_database owns in a project's .env. */
 export declare const PROVISION_ENV_KEYS: readonly ["DATABASE_ID", "DATABASE_NAME", "OWNER_ID", "ACCESS_TOKEN", "PGDATABASE", "API_ENDPOINT", "MODULES_ENDPOINT"];
 /**