@noodleseed/one 0.172.1 → 0.174.0

package/node_modules/@noodle-borg/service/dist/routes/business-workspaces.js

@@ -0,0 +1,106 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { BusinessWorkspaceAcceptRequestSchema, BusinessWorkspaceInvitationRequestSchema, BusinessWorkspaceIssuedInvitationResponseSchema, BusinessWorkspaceMutationResponseSchema, BusinessWorkspaceResponseSchema, BusinessWorkspaceRevisionRequestSchema, BusinessWorkspaceRoleChangeRequestSchema, } from '@noodle-borg/wire-contracts';
+import { admitBusinessTarget, authorizeBusinessApi } from '../business-api-admission.js';
+import { BusinessWorkspaceError } from '../business-workspaces/contracts.js';
+import { businessWorkspaceMethod, parseBusinessWorkspacePath, } from '../business-workspaces/paths.js';
+export async function handleBusinessWorkspaceRoute(req, res, url, deps) {
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        await handle(req, res, url, deps);
+    }
+    catch (error) {
+        if (error instanceof BusinessWorkspaceError) {
+            const status = error.code === 'forbidden'
+                ? 403
+                : error.code === 'invalid_request'
+                    ? 400
+                    : error.code === 'not_found'
+                        ? 404
+                        : 409;
+            return sendJson(res, status, {
+                error: error.code.replaceAll('_', ' '),
+                code: error.code,
+                ...(error.currentRevision === undefined ? {} : { currentRevision: error.currentRevision }),
+            });
+        }
+        sendJson(res, 503, {
+            error: 'Workspace access is temporarily unavailable.',
+            code: 'workspace_unavailable',
+        });
+    }
+}
+async function handle(req, res, url, deps) {
+    const ref = parseBusinessWorkspacePath(url.pathname);
+    if (!ref)
+        return sendJson(res, 404, { error: 'not found' });
+    const identity = await authorizeBusinessApi(req, res, deps);
+    if (!identity)
+        return;
+    const method = businessWorkspaceMethod(ref);
+    if (req.method !== method) {
+        res.setHeader('allow', method);
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    if ([...url.searchParams].length)
+        return invalid(res);
+    const { org } = ref;
+    if (ref.action !== 'accept') {
+        const state = await deps.workspaces.inspect(org, identity.subject);
+        if (ref.action && !state.permissions.includes('team:manage'))
+            throw new BusinessWorkspaceError('forbidden');
+        if (!(await admitBusinessTarget(res, { org })))
+            return;
+        if (!ref.action)
+            return sendJson(res, 200, BusinessWorkspaceResponseSchema.parse({ ok: true, data: state }));
+    }
+    const body = await readJsonBody(req, Math.min(deps.maxBody, 16 * 1024));
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    if (ref.action === 'accept') {
+        const input = BusinessWorkspaceAcceptRequestSchema.safeParse(body.value);
+        if (!input.success)
+            return invalid(res);
+        const email = await deps.verifiedEmail?.(identity.subject, identity.email);
+        if (!email)
+            return sendJson(res, 403, {
+                error: 'Sign in with a verified invited email address.',
+                code: 'verified_email_required',
+            });
+        // Subject admission already ran. The opaque one-use invitation supplies authority, not the org in the URL.
+        const result = await deps.workspaces.accept({
+            org,
+            subject: identity.subject,
+            verifiedEmail: email,
+            token: input.data.token,
+        });
+        return sendJson(res, 200, BusinessWorkspaceMutationResponseSchema.parse({ ok: true, data: result }));
+    }
+    if (ref.action === 'invitations' && !ref.id) {
+        const input = BusinessWorkspaceInvitationRequestSchema.safeParse(body.value);
+        if (!input.success)
+            return invalid(res);
+        const result = await deps.workspaces.invite({ ...input.data, org, actor: identity.subject });
+        return sendJson(res, 201, BusinessWorkspaceIssuedInvitationResponseSchema.parse({ ok: true, data: result }));
+    }
+    if (ref.action === 'invitations' && ref.id) {
+        const input = BusinessWorkspaceRevisionRequestSchema.safeParse(body.value);
+        if (!input.success)
+            return invalid(res);
+        const result = await deps.workspaces.revokeInvitation({
+            ...input.data,
+            org,
+            actor: identity.subject,
+            invitationId: ref.id,
+        });
+        return sendJson(res, 200, BusinessWorkspaceMutationResponseSchema.parse({ ok: true, data: result }));
+    }
+    const input = BusinessWorkspaceRoleChangeRequestSchema.safeParse(body.value);
+    if (!input.success)
+        return invalid(res);
+    const result = await deps.workspaces.changeRole({ ...input.data, org, actor: identity.subject });
+    return sendJson(res, 200, BusinessWorkspaceMutationResponseSchema.parse({ ok: true, data: result }));
+}
+function invalid(res) {
+    return sendJson(res, 400, { error: 'Invalid workspace request.', code: 'invalid_request' });
+}
+//# sourceMappingURL=business-workspaces.js.map

package/node_modules/@noodle-borg/service/dist/routes/service-probes.js

@@ -0,0 +1,32 @@
+import { applySecurityHeaders, sendJson } from '@noodle-borg/transport-http';
+import { serviceInfoPayload } from '../build-info.js';
+export function createServiceProbeDispatcher(deps) {
+    return (req, res, url) => {
+        if (req.method !== 'GET' || !['/healthz', '/readyz', '/v1/service/info'].includes(url.pathname))
+            return false;
+        handleServiceProbe(req, res, url, deps);
+        return true;
+    };
+}
+function handleServiceProbe(req, res, url, { tls, moduleHost, buildInfo, options, whatsapp }) {
+    // Liveness/readiness probes: un-gated and **not** HTTPS-enforced — Cloud Run's internal probe is plain
+    // HTTP, so enforcing HTTPS here would `426` the probe and the revision would never go healthy (ADR 0034).
+    // `/healthz` is a pure liveness 200 (no store touch); `/readyz` reflects the injected readiness probe.
+    if (req.method === 'GET' && (url.pathname === '/healthz' || url.pathname === '/readyz')) {
+        applySecurityHeaders(res, tls);
+        if (url.pathname === '/healthz')
+            return sendJson(res, 200, { status: 'ok' });
+        void Promise.resolve()
+            .then(() => moduleHost.ready())
+            .then((ready) => sendJson(res, ready ? 200 : 503, { status: ready ? 'ready' : 'unready' }))
+            .catch(() => sendJson(res, 503, { status: 'unready' }));
+        return;
+    }
+    // Deployed-version visibility (ADR 0080): un-gated, non-HTTPS-enforced like the probes so the
+    // post-deploy smoke can confirm exactly which commit is live. Non-sensitive fields only.
+    if (req.method === 'GET' && url.pathname === '/v1/service/info') {
+        applySecurityHeaders(res, tls);
+        return sendJson(res, 200, serviceInfoPayload(buildInfo, options.developerMcp === true, whatsapp !== undefined));
+    }
+}
+//# sourceMappingURL=service-probes.js.map

package/node_modules/@noodle-borg/service/dist/service.js

@@ -12,7 +12,7 @@ import { createArchivePreflight } from './archive-preflight.js';
 import { ArchiveSweeper, resolveArchiveRetentionDays } from './archive-sweeper.js';
 import { serveLocalAsset } from './assets.js';
 import { assistantRouteDependencies } from './assistant-composition.js';
-import { resolveBuildInfo, serviceInfoPayload } from './build-info.js';
+import { resolveBuildInfo } from './build-info.js';
 import { createBusinessInformationRuntime, resolvePrivateInstallationDefinition, } from './business-information-runtime.js';
 import { serviceCapabilityReport } from './capabilities.js';
 import { createWhatsAppRuntime } from './channels/composition.js';
@@ -36,6 +36,7 @@ import { handleAppArchive, handleAppRestore } from './routes/archive.js';
 import { handleAssetPreflight } from './routes/asset-control-plane.js';
 import { dispatchAssistantRoutes } from './routes/assistant-dispatch.js';
 import { dispatchAuthDiscoveryRoute } from './routes/auth-discovery.js';
+import { dispatchBusinessAuthoringRoutes } from './routes/business-authoring-dispatch.js';
 import { dispatchBusinessInformationRoutes } from './routes/business-information-dispatch.js';
 import { dispatchConfigValueRequest } from './routes/config-values-dispatch.js';
 import { authorizeTenantControl, handleDeploymentStatus, handleWhoami, } from './routes/control-plane.js';
@@ -52,6 +53,7 @@ import { dispatchProtectedResourceMetadata } from './routes/protected-resource-m
 import { dispatchResourceReads } from './routes/resource-read-dispatch.js';
 import { handleRollback } from './routes/rollback.js';
 import { createServicePrincipalDispatcher } from './routes/service-principals-dispatch.js';
+import { createServiceProbeDispatcher } from './routes/service-probes.js';
 import { dispatchWhatsAppRoutes } from './routes/whatsapp.js';
 import { servicePrincipalDataPlaneHooks } from './service-principal-data-plane.js';
 import { InMemoryAlertRuleStore } from './store/alert-rules.js';
@@ -201,20 +203,17 @@ export function createServiceHandler(registry, options = {}) {
         installations: businessInformationStore,
         activity,
     });
+    const dispatchProbe = createServiceProbeDispatcher({
+        tls,
+        moduleHost,
+        buildInfo,
+        options,
+        whatsapp,
+    });
     return (req, res) => {
         const url = new URL(req.url ?? '/', 'http://localhost');
-        // Liveness/readiness probes: un-gated and **not** HTTPS-enforced — Cloud Run's internal probe is plain
-        // HTTP, so enforcing HTTPS here would `426` the probe and the revision would never go healthy (ADR 0034).
-        // `/healthz` is a pure liveness 200 (no store touch); `/readyz` reflects the injected readiness probe.
-        if (req.method === 'GET' && (url.pathname === '/healthz' || url.pathname === '/readyz')) {
-            applySecurityHeaders(res, tls);
-            if (url.pathname === '/healthz')
-                return sendJson(res, 200, { status: 'ok' });
-            void Promise.resolve(moduleHost.ready())
-                .then((ready) => sendJson(res, ready ? 200 : 503, { status: ready ? 'ready' : 'unready' }))
-                .catch(() => sendJson(res, 503, { status: 'unready' }));
+        if (dispatchProbe(req, res, url))
             return;
-        }
         if (options.developerMcp === true && url.pathname === DEVELOPER_MCP_PATH) {
             const mount = createDeveloperMcpMountOptions({
                 registry,
@@ -228,12 +227,6 @@ export function createServiceHandler(registry, options = {}) {
             void handleDeveloperMcpRequest(req, res, mount).catch((error) => respondRouteError(logger, res, 'developer.mcp.failed', error));
             return;
         }
-        // Deployed-version visibility (ADR 0080): un-gated, non-HTTPS-enforced like the probes so the
-        // post-deploy smoke can confirm exactly which commit is live. Non-sensitive fields only.
-        if (req.method === 'GET' && url.pathname === '/v1/service/info') {
-            applySecurityHeaders(res, tls);
-            return sendJson(res, 200, serviceInfoPayload(buildInfo, options.developerMcp === true, whatsapp !== undefined));
-        }
         if (url.pathname.startsWith('/v1/') && rejectIncompatibleCli(req, res, buildInfo, tls))
             return;
         if (req.method === 'GET' || req.method === 'HEAD') {
@@ -302,9 +295,18 @@ export function createServiceHandler(registry, options = {}) {
         }
         if (servicePrincipalDispatcher?.(req, res, url))
             return;
+        if (dispatchBusinessAuthoringRoutes(req, res, url, options.businessAuthoring, {
+            gate,
+            publicCounters,
+            maxBody: maxDeployBody,
+            tls,
+        }))
+            return;
         if (businessInformationStore !== undefined &&
             options.businessInformationEnabled !== false &&
             dispatchBusinessInformationRoutes(req, res, url, {
+                pageOrigin: options.businessPageOrigin,
+                pageServiceUrl: options.publicBaseUrl,
                 ...(whatsapp ? { readWhatsApp: whatsapp.projection.bind(whatsapp) } : {}),
                 store: businessInformationStore,
                 ...(businessOnboarding ? { businessOnboarding } : {}),

package/node_modules/@noodle-borg/service/dist/solution-installation-activation.js

@@ -95,7 +95,7 @@ export async function activateSolutionInstallation(input, dependencies) {
         }
         return { ok: true, deploymentId };
     };
-    const source = await executableSource(installation, dependencies.registry);
+    const source = await executableSource(installation, dependencies.registry, dependencies.options.businessPageOrigin);
     if (!source.ok)
         return source;
     const current = await dependencies.registry.getActiveByTenant(tenant);
@@ -152,13 +152,13 @@ export async function activateSolutionInstallation(input, dependencies) {
         };
     return bind(deployed.result.deploymentId, false);
 }
-async function executableSource(installation, registry) {
+async function executableSource(installation, registry, hostedPageOrigin) {
     const reference = installation.definition.reference;
     if (reference.kind === 'managed') {
         return {
             ok: true,
             value: {
-                manifest: JSON.stringify(managedSolutionManifest(installation.definition)),
+                manifest: JSON.stringify(managedSolutionManifest(installation.definition, hostedPageOrigin)),
                 accessMode: 'public',
                 serverVersion: '1',
             },

package/node_modules/@noodle-borg/wire-contracts/dist/application-channels.d.ts

@@ -3,6 +3,7 @@ export declare const ApplicationChannelsProjectionSchema: z.ZodObject<{
     revision: z.ZodNumber;
     active: z.ZodBoolean;
     canEdit: z.ZodBoolean;
+    businessPageUrl: z.ZodOptional<z.ZodURL>;
     deploymentId: z.ZodOptional<z.ZodString>;
     mcp: z.ZodObject<{
         status: z.ZodEnum<{
@@ -56,6 +57,7 @@ export declare const ApplicationChannelsResponseSchema: z.ZodObject<{
         revision: z.ZodNumber;
         active: z.ZodBoolean;
         canEdit: z.ZodBoolean;
+        businessPageUrl: z.ZodOptional<z.ZodURL>;
         deploymentId: z.ZodOptional<z.ZodString>;
         mcp: z.ZodObject<{
             status: z.ZodEnum<{
@@ -109,6 +111,7 @@ export declare const ApplicationChannelsClientResponseSchema: z.ZodObject<{
         revision: z.ZodNumber;
         active: z.ZodBoolean;
         canEdit: z.ZodBoolean;
+        businessPageUrl: z.ZodOptional<z.ZodURL>;
         deploymentId: z.ZodOptional<z.ZodString>;
         mcp: z.ZodObject<{
             status: z.ZodEnum<{

package/node_modules/@noodle-borg/wire-contracts/dist/application-channels.js

@@ -51,6 +51,7 @@ export const ApplicationChannelsProjectionSchema = z
     revision: z.number().int().positive(),
     active: z.boolean(),
     canEdit: z.boolean(),
+    businessPageUrl: httpUrl.optional(),
     deploymentId: z.string().min(1).max(256).optional(),
     mcp,
     assistant,

package/node_modules/@noodle-borg/wire-contracts/dist/application-drafts.d.ts

@@ -0,0 +1,322 @@
+import { z } from 'zod';
+/** Bounded browser-authoring input; not the compiled deployment artifact allowance. */
+export declare const APPLICATION_DRAFT_LIMITS: Readonly<{
+    draftsPerApp: 10;
+    draftsPerWorkspace: 50;
+    sourceBytesPerWorkspace: number;
+    receiptsPerWorkspace: 10000;
+    retryWindowMs: number;
+    revisionsPerDraft: 100;
+    files: 64;
+    pathChars: 240;
+    fileBytes: number;
+    totalBytes: number;
+}>;
+export declare const ApplicationDraftSourceSchema: z.ZodObject<{
+    entrypoint: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ApplicationDraftSource = z.infer<typeof ApplicationDraftSourceSchema>;
+export declare const ApplicationDraftIdSchema: z.ZodString;
+export declare const ApplicationDraftCreateRequestSchema: z.ZodObject<{
+    environment: z.ZodString;
+    source: z.ZodObject<{
+        entrypoint: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    baseRelease: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ApplicationDraftEditRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    source: z.ZodObject<{
+        entrypoint: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftUndoRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    targetRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ApplicationDraftRevisionRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ApplicationDraftSchema: z.ZodObject<{
+    id: z.ZodString;
+    org: z.ZodString;
+    app: z.ZodString;
+    environment: z.ZodString;
+    revision: z.ZodNumber;
+    sourceDigest: z.ZodString;
+    source: z.ZodObject<{
+        entrypoint: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    baseRelease: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    createdBySubject: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+    updatedBySubject: z.ZodString;
+    origin: z.ZodEnum<{
+        manual: "manual";
+        guided: "guided";
+        ai: "ai";
+        undo: "undo";
+        import: "import";
+    }>;
+}, z.core.$strict>;
+export type ApplicationDraft = z.infer<typeof ApplicationDraftSchema>;
+export declare const ApplicationDraftSummarySchema: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    org: z.ZodString;
+    app: z.ZodString;
+    origin: z.ZodEnum<{
+        manual: "manual";
+        guided: "guided";
+        ai: "ai";
+        undo: "undo";
+        import: "import";
+    }>;
+    environment: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    baseRelease: z.ZodOptional<z.ZodString>;
+    sourceDigest: z.ZodString;
+    createdBySubject: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+    updatedBySubject: z.ZodString;
+}, z.core.$strict>;
+export type ApplicationDraftSummary = z.infer<typeof ApplicationDraftSummarySchema>;
+export declare const ApplicationDraftResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        draft: z.ZodObject<{
+            id: z.ZodString;
+            org: z.ZodString;
+            app: z.ZodString;
+            environment: z.ZodString;
+            revision: z.ZodNumber;
+            sourceDigest: z.ZodString;
+            source: z.ZodObject<{
+                entrypoint: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodISODateTime;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftHistoryResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revisions: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            org: z.ZodString;
+            app: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+            environment: z.ZodString;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            sourceDigest: z.ZodString;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftHistoryClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revisions: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            org: z.ZodString;
+            app: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+            environment: z.ZodString;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            sourceDigest: z.ZodString;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftDiffSchema: z.ZodObject<{
+    draftId: z.ZodString;
+    fromRevision: z.ZodNumber;
+    toRevision: z.ZodNumber;
+    fromDigest: z.ZodString;
+    toDigest: z.ZodString;
+    fromEntrypoint: z.ZodString;
+    toEntrypoint: z.ZodString;
+    changes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        before: z.ZodNullable<z.ZodString>;
+        after: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ApplicationDraftDiff = z.infer<typeof ApplicationDraftDiffSchema>;
+export declare const ApplicationDraftDiffResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        diff: z.ZodObject<{
+            draftId: z.ZodString;
+            fromRevision: z.ZodNumber;
+            toRevision: z.ZodNumber;
+            fromDigest: z.ZodString;
+            toDigest: z.ZodString;
+            fromEntrypoint: z.ZodString;
+            toEntrypoint: z.ZodString;
+            changes: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                before: z.ZodNullable<z.ZodString>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftDiffClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        diff: z.ZodObject<{
+            draftId: z.ZodString;
+            fromRevision: z.ZodNumber;
+            toRevision: z.ZodNumber;
+            fromDigest: z.ZodString;
+            toDigest: z.ZodString;
+            fromEntrypoint: z.ZodString;
+            toEntrypoint: z.ZodString;
+            changes: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                before: z.ZodNullable<z.ZodString>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationDraftDiffRequestSchema: z.ZodObject<{
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ApplicationDraftClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        draft: z.ZodObject<{
+            id: z.ZodString;
+            org: z.ZodString;
+            app: z.ZodString;
+            environment: z.ZodString;
+            revision: z.ZodNumber;
+            sourceDigest: z.ZodString;
+            source: z.ZodObject<{
+                entrypoint: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodISODateTime;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationDraftListResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        drafts: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            org: z.ZodString;
+            app: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+            environment: z.ZodString;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            sourceDigest: z.ZodString;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationDraftListClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        drafts: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            org: z.ZodString;
+            app: z.ZodString;
+            origin: z.ZodEnum<{
+                manual: "manual";
+                guided: "guided";
+                ai: "ai";
+                undo: "undo";
+                import: "import";
+            }>;
+            environment: z.ZodString;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            baseRelease: z.ZodOptional<z.ZodString>;
+            sourceDigest: z.ZodString;
+            createdBySubject: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+            updatedBySubject: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=application-drafts.d.ts.map