@noodleseed/one 0.176.0 → 0.178.0

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

@@ -0,0 +1,90 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ConversationReviewRequestSchema } from '@noodle-borg/wire-contracts';
+import { ConversationHistoryError, } from '../conversation-history/operator.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+/**
+ * ADR 0241 decision 10: readers see text; reviewing and noting need the record-handling permissions an
+ * Operator holds; only export and erasure need Owner/Administrator authority.
+ */
+const PERMISSIONS = {
+    list: 'records:read',
+    show: 'records:read',
+    export: 'records:export',
+    forget: 'records:delete',
+};
+const METHODS = { list: ['GET'], show: ['GET', 'PATCH'], export: ['GET'], forget: ['POST'] };
+export async function handleApplicationConversations(req, res, url, ref, deps) {
+    const route = ref.conversationAction ?? 'list';
+    const methods = METHODS[route];
+    if (!methods.includes(req.method ?? '')) {
+        res.setHeader('allow', methods.join(', '));
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const action = req.method === 'PATCH' ? 'review' : route;
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    // A review's permissions follow its fields, so it is read-authorized before its body is parsed.
+    let permissions = [PERMISSIONS[route]];
+    const authorize = async () => {
+        const [last = PERMISSIONS[route], ...earlier] = [...permissions].reverse();
+        for (const permission of earlier)
+            if (!(await requireInstallationPermission(res, ref, identity, permission, deps)))
+                return false;
+        return requireInstallationPermission(res, ref, identity, last, deps);
+    };
+    const authorized = await authorize();
+    if (!authorized)
+        return;
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        if (!deps.conversations)
+            throw new ConversationHistoryError('conversation_unavailable');
+        let body;
+        if (req.method !== 'GET') {
+            const parsed = await readJsonBody(req, deps.maxBody);
+            if (!parsed.ok)
+                return sendJson(res, parsed.status, { error: parsed.error });
+            body = parsed.value;
+            if (action === 'review') {
+                const review = ConversationReviewRequestSchema.safeParse(body);
+                if (!review.success)
+                    throw new ConversationHistoryError('conversation_invalid');
+                permissions = [
+                    ...(review.data.reviewStatus === undefined ? [] : ['records:status']),
+                    ...(review.data.note === undefined ? [] : ['records:note']),
+                ];
+            }
+            if (!(await authorize()))
+                return;
+        }
+        const fence = permissions.at(-1) ?? PERMISSIONS[route];
+        const result = await deps.conversations.project(authorized.scope, action, {
+            parameters: [...url.searchParams.entries()],
+            ...(ref.conversationId === undefined ? {} : { conversationId: ref.conversationId }),
+            body,
+            actor: identity.subject,
+            ...(deps.forgetWhatsApp ? { forgetWorkingMemory: deps.forgetWhatsApp } : {}),
+        }, (operation) => deps.store.staff.run(authorized.scope, identity.subject, fence, operation));
+        for (const event of result.audits)
+            await deps.audit?.emit({
+                ...event,
+                org: ref.org,
+                app: authorized.scope.app,
+                env: authorized.scope.env,
+                actorSubject: identity.subject,
+            });
+        if (await authorize())
+            sendJson(res, 200, result.response);
+    }
+    catch (error) {
+        if (!(error instanceof ConversationHistoryError))
+            throw error;
+        sendJson(res, error.code === 'conversation_not_found'
+            ? 404
+            : error.code === 'conversation_unavailable'
+                ? 503
+                : 400, { code: error.code, error: error.message });
+    }
+}
+//# sourceMappingURL=business-information-conversations.js.map

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

@@ -9,9 +9,10 @@ import { SourceCapacityError } from '../business-information/source-custody-budg
 import { BusinessWorkspaceError } from '../business-workspaces/contracts.js';
 import { respondRouteError } from '../http-util.js';
 import { handleBusinessGrants, handleManagedRecords, handleSolutionCatalog, handleSolutionInstallations, } from './business-information.js';
-import { handleApplicationActivity, } from './business-information-activity.js';
+import { handleApplicationActivity } from './business-information-activity.js';
 import { handleBusinessChannels, } from './business-information-channels.js';
 import { handleApplicationConnectionCallback, handleApplicationConnections, } from './business-information-connections.js';
+import { handleApplicationConversations, } from './business-information-conversations.js';
 import { handleBusinessNotice, handleOrganizationAgreement, } from './business-information-notice.js';
 import { handleSolutionInstallationOptions } from './business-information-onboarding.js';
 import { handleBusinessPage, handlePublicBusinessPage } from './business-information-pages.js';
@@ -78,9 +79,13 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
         return run(req, res, deps, () => handleNativeRecordLifecycle(req, res, installationRef, deps));
     if (installationRef.action === 'notice')
         return run(req, res, deps, () => handleBusinessNotice(req, res, installationRef, deps));
-    if ((installationRef.action === 'activity' || installationRef.action === 'coordination') &&
+    if ((installationRef.action === 'activity' ||
+        installationRef.action === 'history' ||
+        installationRef.action === 'coordination') &&
         installationRef.collection === undefined)
         return run(req, res, deps, () => handleApplicationActivity(req, res, url, installationRef, deps));
+    if (installationRef.action === 'conversations')
+        return run(req, res, deps, () => handleApplicationConversations(req, res, url, installationRef, deps));
     if (installationRef.action === 'connections')
         return run(req, res, deps, () => handleApplicationConnections(req, res, installationRef, deps));
     if (installationRef.action === 'settings') {

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

@@ -27,7 +27,23 @@ export function parseSolutionInstallationPath(pathname) {
                 ...(connectionAction === undefined ? {} : { connectionAction }),
             };
     }
-    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
+    const conversations = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/conversations(?:\/(export|forget|cv_[A-Za-z0-9_-]{8,64}))?$/.exec(pathname);
+    if (conversations !== null) {
+        const org = decoded(conversations, 1), installationId = decoded(conversations, 2), segment = conversations[3];
+        return org === undefined || installationId === undefined
+            ? undefined
+            : {
+                org,
+                installationId,
+                action: 'conversations',
+                ...(segment === undefined
+                    ? { conversationAction: 'list' }
+                    : segment === 'export' || segment === 'forget'
+                        ? { conversationAction: segment }
+                        : { conversationAction: 'show', conversationId: segment }),
+            };
+    }
+    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|history\/settings|activity(?:\/(?:export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);
         const installationId = decoded(application, 2);
@@ -40,7 +56,9 @@ export function parseSolutionInstallationPath(pathname) {
                     ? 'coordination'
                     : application[3]?.startsWith('activity')
                         ? 'activity'
-                        : application[3],
+                        : application[3] === 'history/settings'
+                            ? 'history'
+                            : application[3],
             };
     }
     let match = /^\/v1\/orgs\/([^/]+)\/solution-installations$/.exec(pathname);

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

@@ -68,6 +68,10 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
                 code: 'installation_conflict',
             });
         }
+        // Only a created installation opts in (ADR 0241 decision 8), before activation can read the setting.
+        // Without a verified allowance it stays not enabled: recording nothing is the safe failure.
+        if (result.disposition === 'created')
+            await deps.activity?.initializeHistory(result.installation.scope).catch(() => false);
         const grant = await resolveBusinessStaffGrant(deps, result.installation.scope, identity.subject);
         if (grant === undefined || grant.revokedAt !== undefined) {
             return sendForbidden(res, 'business grant required');

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

@@ -209,16 +209,6 @@ async function operate(req, res, url, tenant, path, runtime, grants) {
         }
         return respond(res, wire.WhatsAppCooldownResponseSchema, await channels.cooldown(id, value));
     }
-    if (kind === 'participants' &&
-        value &&
-        participant.test(value) &&
-        action === 'forget' &&
-        req.method === 'POST') {
-        await body(req, wire.WhatsAppEmptyRequestSchema);
-        await channels.forget(id, value, identity.subject, idempotency);
-        await audit('conversation_forgotten');
-        return sendJson(res, 200, { ok: true });
-    }
     if (kind === 'events' &&
         (!value || eventId.test(value)) &&
         (read || (action === 'reconcile' && req.method === 'POST'))) {

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

@@ -0,0 +1,52 @@
+import { randomBytes } from 'node:crypto';
+import { ActivityPolicyError, ApplicationActivity } from './application-activity.js';
+import { historyDisabledSurfaces } from './application-history-settings.js';
+import { ApplicationConversations } from './conversation-history/operator.js';
+/** Installation history projections over the optional durable stores the service was given. */
+export function createHistoryProjections(options, moduleHost, installations, registry) {
+    const history = options.conversationHistory;
+    const activity = options.operationEvidence === undefined
+        ? undefined
+        : new ApplicationActivity({
+            ...options.operationEvidence,
+            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
+            ...(history === undefined ? {} : { conversationHistory: history.store }),
+            historyDisabledSurfaces: async (scope) => historyDisabledSurfaces((await registry.getActiveByTenant(scope))?.served.artifact.server.assistant),
+        });
+    const conversationPolicy = history?.policy ?? settingsConversationPolicy(installations, activity);
+    const conversations = history === undefined
+        ? undefined
+        : new ApplicationConversations({
+            store: history.store,
+            policy: conversationPolicy,
+            identityKey: history.identityKey ?? randomBytes(32).toString('hex'),
+            ...(options.clock === undefined
+                ? {}
+                : { now: () => options.clock?.().getTime() ?? Date.now() }),
+        });
+    return { activity, conversations, conversationPolicy };
+}
+/**
+ * Capture follows the installation history setting under the live plan allowance (ADR 0241). A tenant
+ * with no single installation, setting opt-in or verified allowance records nothing, and the read never
+ * creates a setting.
+ */
+function settingsConversationPolicy(installations, activity) {
+    return async (tenant) => {
+        if (!installations || !activity)
+            return undefined;
+        const matching = (await installations.listInstallations(tenant.org)).filter((item) => item.scope.app === tenant.app && item.scope.env === tenant.env);
+        const installation = matching.length === 1 ? matching[0] : undefined;
+        if (!installation)
+            return undefined;
+        try {
+            return await activity.conversationPolicy(installation.scope);
+        }
+        catch (error) {
+            if (error instanceof ActivityPolicyError)
+                return undefined;
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=service-history-projections.js.map

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

@@ -24,6 +24,38 @@ export async function closeServiceResources(input) {
     if (errors.length > 0)
         throw new AggregateError(errors, 'service resource cleanup failed');
 }
+/**
+ * Clean up after a failed boot without letting a cleanup failure replace the error that aborted startup:
+ * operators must see the bind or boot cause, while the cleanup failure is still logged.
+ */
+export async function cleanupAfterStartupFailure(logger, phase, cleanup) {
+    try {
+        await cleanup();
+    }
+    catch (error) {
+        const code = firstErrorCode(error);
+        logger.error('service.startup_cleanup_failed', {
+            phase,
+            name: error instanceof Error ? error.name : 'unknown',
+            ...(code === undefined ? {} : { code }),
+        });
+    }
+}
+/** The first scalar driver/system code, searching nested cleanup aggregates depth-first. */
+function firstErrorCode(error, depth = 0) {
+    if (typeof error !== 'object' || error === null || depth > 4)
+        return undefined;
+    if ('code' in error && typeof error.code === 'string')
+        return error.code;
+    if (!(error instanceof AggregateError))
+        return undefined;
+    for (const nested of error.errors) {
+        const code = firstErrorCode(nested, depth + 1);
+        if (code !== undefined)
+            return code;
+    }
+    return undefined;
+}
 export function listenHttpServer(http, port, host) {
     return new Promise((resolve, reject) => {
         const onError = (error) => {

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

@@ -6,7 +6,6 @@ import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
 import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
-import { ApplicationActivity } from './application-activity.js';
 import { createApplicationServingRuntime } from './application-runtime-target.js';
 import { createArchivePreflight } from './archive-preflight.js';
 import { ArchiveSweeper, resolveArchiveRetentionDays } from './archive-sweeper.js';
@@ -15,7 +14,7 @@ import { assistantRouteDependencies } from './assistant-composition.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';
+import { createWhatsAppRuntime, whatsappBusinessRoutes } from './channels/composition.js';
 import { rejectIncompatibleCli } from './client-compatibility.js';
 import { createDataPlaneMembershipAuthorizer } from './data-plane-membership.js';
 import { DEVELOPER_MCP_PATH, handleDeveloperMcpRequest } from './developer-mcp/mount.js';
@@ -55,6 +54,7 @@ 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 { createHistoryProjections } from './service-history-projections.js';
 import { servicePrincipalDataPlaneHooks } from './service-principal-data-plane.js';
 import { InMemoryAlertRuleStore } from './store/alert-rules.js';
 import { StdoutAuditSink } from './store/audit.js';
@@ -95,12 +95,7 @@ export function createServiceHandler(registry, options = {}) {
     activeAudit = audit;
     const { publicTenantRouting } = mcp.mcpRoutingOptions(options, controlPlane);
     const resolveEndpointOptions = (org) => mcp.endpointUrlOptionsForOrg(options, controlPlane, org);
-    const activity = options.operationEvidence === undefined
-        ? undefined
-        : new ApplicationActivity({
-            ...options.operationEvidence,
-            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
-        });
+    const { activity, conversations, conversationPolicy } = createHistoryProjections(options, moduleHost, businessInformationStore, registry);
     const withIntentMode = createIntentTargetResolver(intentSettings, intentPreviewOrgs);
     const { activateInstallation, readInstallationActivation, resolveRuntimeTarget, businessOnboarding, } = createApplicationServingRuntime(registry, providerOptions, controlPlane, audit, activity);
     const runtimeTarget = async (target) => target === undefined ? undefined : resolveRuntimeTarget(target);
@@ -197,6 +192,7 @@ export function createServiceHandler(registry, options = {}) {
         maxBody,
         serviceBase: (request) => options.publicBaseUrl ?? baseFromRequest(request, tls),
         logger,
+        conversationPolicy,
     });
     const whatsapp = createWhatsAppRuntime(options.whatsapp, assistantDeps, {
         allowance: moduleHost.resolveActivityHistoryAllowance,
@@ -307,13 +303,14 @@ export function createServiceHandler(registry, options = {}) {
             dispatchBusinessInformationRoutes(req, res, url, {
                 pageOrigin: options.businessPageOrigin,
                 pageServiceUrl: options.publicBaseUrl,
-                ...(whatsapp ? { readWhatsApp: whatsapp.projection.bind(whatsapp) } : {}),
+                ...whatsappBusinessRoutes(whatsapp),
                 store: businessInformationStore,
                 ...(options.businessAuthoring ? { workspaces: options.businessAuthoring.workspaces } : {}),
                 ...(businessOnboarding ? { businessOnboarding } : {}),
                 activateInstallation,
                 readInstallationActivation,
                 ...(activity === undefined ? {} : { activity }),
+                ...(conversations === undefined ? {} : { conversations }),
                 ...(options.connectionRuntime === undefined
                     ? {}
                     : {

package/node_modules/@noodle-borg/service/package.json

@@ -41,7 +41,7 @@
     "@noodle-borg/managed-capabilities": "0.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.107.0",
+    "@noodle-borg/agent-kit": "0.108.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

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

@@ -42,25 +42,6 @@ export declare const ApplicationActivityListResponseSchema: z.ZodObject<{
         historyDays: z.ZodNumber;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const ApplicationActivitySettingsSchema: z.ZodObject<{
-    revision: z.ZodString;
-    retentionDays: z.ZodNumber;
-    maximumDays: z.ZodNumber;
-    canEdit: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const ApplicationActivitySettingsResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    data: z.ZodObject<{
-        revision: z.ZodString;
-        retentionDays: z.ZodNumber;
-        maximumDays: z.ZodNumber;
-        canEdit: z.ZodBoolean;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const ApplicationActivitySettingsSaveRequestSchema: z.ZodObject<{
-    expectedRevision: z.ZodString;
-    retentionDays: z.ZodNumber;
-}, z.core.$strict>;
 /** Clients tolerate additive response fields; writes and server output remain strict. */
 export declare const ApplicationActivityListClientResponseSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
@@ -87,15 +68,6 @@ export declare const ApplicationActivityListClientResponseSchema: z.ZodObject<{
         historyDays: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const ApplicationActivitySettingsClientResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    data: z.ZodObject<{
-        revision: z.ZodString;
-        retentionDays: z.ZodNumber;
-        maximumDays: z.ZodNumber;
-        canEdit: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
 export declare const ApplicationActivityPreviewResponseSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
     data: z.ZodDiscriminatedUnion<[z.ZodObject<{

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

@@ -18,20 +18,6 @@ export const ApplicationActivityListResponseSchema = z.strictObject({
         historyDays: z.number().int().min(1).max(365),
     }),
 });
-export const ApplicationActivitySettingsSchema = z.strictObject({
-    revision: z.string().regex(/^[a-f0-9]{64}$/),
-    retentionDays: z.number().int().min(1).max(365),
-    maximumDays: z.number().int().min(1).max(365),
-    canEdit: z.boolean(),
-});
-export const ApplicationActivitySettingsResponseSchema = z.strictObject({
-    ok: z.literal(true),
-    data: ApplicationActivitySettingsSchema,
-});
-export const ApplicationActivitySettingsSaveRequestSchema = z.strictObject({
-    expectedRevision: z.string().regex(/^[a-f0-9]{64}$/),
-    retentionDays: z.number().int().min(1).max(365),
-});
 /** Clients tolerate additive response fields; writes and server output remain strict. */
 export const ApplicationActivityListClientResponseSchema = z.object({
     ok: z.literal(true),
@@ -45,10 +31,6 @@ export const ApplicationActivityListClientResponseSchema = z.object({
             .max(100),
     }),
 });
-export const ApplicationActivitySettingsClientResponseSchema = z.object({
-    ok: z.literal(true),
-    data: z.object(ApplicationActivitySettingsSchema.shape),
-});
 const ActivityPreviewScenarioSchema = z.strictObject({
     id: z.string().min(1).max(128),
     label: z.string().min(1).max(128),

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

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+export declare const HistorySourcesSchema: z.ZodObject<{
+    websiteVisitors: z.ZodBoolean;
+    signedInCustomers: z.ZodBoolean;
+    whatsapp: z.ZodBoolean;
+}, z.core.$strict>;
+/** A surface the application declared `history: false` on, named by its authoring constructor. */
+export declare const ApplicationHistoryDisabledSurfaceSchema: z.ZodEnum<{
+    publicWebsite: "publicWebsite";
+    authenticatedWebsite: "authenticatedWebsite";
+    publicMessaging: "publicMessaging";
+}>;
+export declare const ApplicationHistorySettingsSchema: z.ZodObject<{
+    revision: z.ZodString;
+    canEdit: z.ZodBoolean;
+    activity: z.ZodObject<{
+        retentionDays: z.ZodNumber;
+        maximumDays: z.ZodNumber;
+        defaultDays: z.ZodNumber;
+    }, z.core.$strict>;
+    conversations: z.ZodObject<{
+        state: z.ZodEnum<{
+            not_enabled: "not_enabled";
+            off: "off";
+            on: "on";
+        }>;
+        retentionDays: z.ZodOptional<z.ZodNumber>;
+        sources: z.ZodObject<{
+            websiteVisitors: z.ZodBoolean;
+            signedInCustomers: z.ZodBoolean;
+            whatsapp: z.ZodBoolean;
+        }, z.core.$strict>;
+        disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            publicWebsite: "publicWebsite";
+            authenticatedWebsite: "authenticatedWebsite";
+            publicMessaging: "publicMessaging";
+        }>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        canEdit: z.ZodBoolean;
+        activity: z.ZodObject<{
+            retentionDays: z.ZodNumber;
+            maximumDays: z.ZodNumber;
+            defaultDays: z.ZodNumber;
+        }, z.core.$strict>;
+        conversations: z.ZodObject<{
+            state: z.ZodEnum<{
+                not_enabled: "not_enabled";
+                off: "off";
+                on: "on";
+            }>;
+            retentionDays: z.ZodOptional<z.ZodNumber>;
+            sources: z.ZodObject<{
+                websiteVisitors: z.ZodBoolean;
+                signedInCustomers: z.ZodBoolean;
+                whatsapp: z.ZodBoolean;
+            }, z.core.$strict>;
+            disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                publicWebsite: "publicWebsite";
+                authenticatedWebsite: "authenticatedWebsite";
+                publicMessaging: "publicMessaging";
+            }>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Omitted fields keep their value; `dryRun` reports the effect without saving. */
+export declare const ApplicationHistorySettingsSaveRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodString;
+    activityDays: z.ZodOptional<z.ZodNumber>;
+    conversations: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        retentionDays: z.ZodNumber;
+    }, z.core.$strict>, z.ZodLiteral<"off">]>>;
+    sources: z.ZodOptional<z.ZodObject<{
+        websiteVisitors: z.ZodOptional<z.ZodBoolean>;
+        signedInCustomers: z.ZodOptional<z.ZodBoolean>;
+        whatsapp: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsSaveResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        dryRun: z.ZodBoolean;
+        shortensConversations: z.ZodBoolean;
+        impact: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strict>;
+        settings: z.ZodObject<{
+            revision: z.ZodString;
+            canEdit: z.ZodBoolean;
+            activity: z.ZodObject<{
+                retentionDays: z.ZodNumber;
+                maximumDays: z.ZodNumber;
+                defaultDays: z.ZodNumber;
+            }, z.core.$strict>;
+            conversations: z.ZodObject<{
+                state: z.ZodEnum<{
+                    not_enabled: "not_enabled";
+                    off: "off";
+                    on: "on";
+                }>;
+                retentionDays: z.ZodOptional<z.ZodNumber>;
+                sources: z.ZodObject<{
+                    websiteVisitors: z.ZodBoolean;
+                    signedInCustomers: z.ZodBoolean;
+                    whatsapp: z.ZodBoolean;
+                }, z.core.$strict>;
+                disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    publicWebsite: "publicWebsite";
+                    authenticatedWebsite: "authenticatedWebsite";
+                    publicMessaging: "publicMessaging";
+                }>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        activity: z.ZodObject<{
+            retentionDays: z.ZodNumber;
+            maximumDays: z.ZodNumber;
+            defaultDays: z.ZodNumber;
+        }, z.core.$strip>;
+        conversations: z.ZodObject<{
+            sources: z.ZodObject<{
+                websiteVisitors: z.ZodBoolean;
+                signedInCustomers: z.ZodBoolean;
+                whatsapp: z.ZodBoolean;
+            }, z.core.$strip>;
+            state: z.ZodEnum<{
+                not_enabled: "not_enabled";
+                off: "off";
+                on: "on";
+            }>;
+            retentionDays: z.ZodOptional<z.ZodNumber>;
+            disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                publicWebsite: "publicWebsite";
+                authenticatedWebsite: "authenticatedWebsite";
+                publicMessaging: "publicMessaging";
+            }>>>;
+        }, z.core.$strip>;
+        revision: z.ZodString;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationHistorySettingsSaveClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        impact: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strip>;
+        settings: z.ZodObject<{
+            activity: z.ZodObject<{
+                retentionDays: z.ZodNumber;
+                maximumDays: z.ZodNumber;
+                defaultDays: z.ZodNumber;
+            }, z.core.$strip>;
+            conversations: z.ZodObject<{
+                sources: z.ZodObject<{
+                    websiteVisitors: z.ZodBoolean;
+                    signedInCustomers: z.ZodBoolean;
+                    whatsapp: z.ZodBoolean;
+                }, z.core.$strip>;
+                state: z.ZodEnum<{
+                    not_enabled: "not_enabled";
+                    off: "off";
+                    on: "on";
+                }>;
+                retentionDays: z.ZodOptional<z.ZodNumber>;
+                disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    publicWebsite: "publicWebsite";
+                    authenticatedWebsite: "authenticatedWebsite";
+                    publicMessaging: "publicMessaging";
+                }>>>;
+            }, z.core.$strip>;
+            revision: z.ZodString;
+            canEdit: z.ZodBoolean;
+        }, z.core.$strip>;
+        dryRun: z.ZodBoolean;
+        shortensConversations: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=application-history-settings.d.ts.map