@cloudhal/cli 0.0.0-stage → 0.1.1

package/dist/src/commands/deploy/resources.js

@@ -0,0 +1,157 @@
+/** Cloudflare resources a deploy needs (D1, R2, KV, the bundle lifecycle rule), the health wait and the cache purge. */
+
+import { BUNDLE_PREFIX } from "@cloudhal/core-ts";
+                                                              
+                                                                   
+                                               
+
+export async function ensureResources(
+  run                ,
+  {
+    cwd,
+    names,
+    log,
+    where,
+  }   
+                
+                                          
+                             
+                                                                   
+                                       
+   ,
+)                                                          {
+  const info = async () => {
+    const r = await run(["d1", "info", names.database, "--json"], { cwd, quiet: true });
+    if (r.code !== 0) return undefined;
+    try {
+      return (JSON.parse(r.stdout)                     ).uuid;
+    } catch {
+      return undefined;
+    }
+  };
+  let databaseId = await info();
+  let made                          ;
+  if (!databaseId) {
+    made = await where();
+    log(
+      made === "eu"
+        ? `creating D1 database ${names.database} in the EU jurisdiction (this cannot be changed later)`
+        : `creating D1 database ${names.database}`,
+    );
+    const created = await run(
+      ["d1", "create", names.database, ...(made === "eu" ? ["--jurisdiction", "eu"] : [])],
+      { cwd },
+    );
+    // A failed `d1 info` (e.g. a transient API error) must not stop a redeploy: the database is
+    // already there, so read its id again.
+    if (created.code !== 0 && !/already exists/i.test(created.stderr + created.stdout))
+      throw new Error(
+        `wrangler d1 create ${names.database} failed:\n${created.stderr.slice(-2000)}`,
+      );
+    databaseId = await info();
+    if (!databaseId) throw new Error(`could not read the id of D1 database ${names.database}`);
+  }
+  const bucket = await run(["r2", "bucket", "create", names.bucket], { cwd });
+  if (bucket.code !== 0 && !/already exists|already own/i.test(bucket.stderr + bucket.stdout))
+    throw new Error(`could not create R2 bucket ${names.bucket}:\n${bucket.stderr.slice(-2000)}`);
+  await ensureBundleLifecycle(run, cwd, names.bucket, log);
+  // RFC-0029 §3: the bucket the AI Search instance reads (the instance itself is made by hand).
+  if (names.searchBucket) {
+    const search = await run(["r2", "bucket", "create", names.searchBucket], { cwd });
+    if (search.code !== 0 && !/already exists|already own/i.test(search.stderr + search.stdout))
+      throw new Error(
+        `could not create R2 bucket ${names.searchBucket}:\n${search.stderr.slice(-2000)}`,
+      );
+  }
+  return { databaseId, ...(made ? { created: made } : {}) };
+}
+
+/** The R2 lifecycle rule that expires snapshot bundles (RFC-0010 "Retention"). */
+export const BUNDLE_LIFECYCLE_RULE = "cloudhal-bundles";
+export const BUNDLE_LIFECYCLE_DAYS = 30;
+
+/**
+ * Expires `bundles/` after 30 days, once per bucket. Bundles are a cache the site Worker rewrites
+ * when one is missing, so a rule that cannot be read or set is a warning, never a failed deploy.
+ * `lifecycle add` appends without checking names, hence the list first.
+ */
+export async function ensureBundleLifecycle(
+  run                ,
+  cwd        ,
+  bucket        ,
+  log                     ,
+)                {
+  const warn = (why        ) =>
+    log(
+      `could not set the R2 lifecycle rule for ${BUNDLE_PREFIX} (${why}); snapshot bundles stay until deleted. Add it with \`wrangler r2 bucket lifecycle add ${bucket} ${BUNDLE_LIFECYCLE_RULE} ${BUNDLE_PREFIX} --expire-days ${BUNDLE_LIFECYCLE_DAYS}\``,
+    );
+  const rule = new RegExp(`\\b${BUNDLE_LIFECYCLE_RULE}\\b`);
+  const listed = await run(["r2", "bucket", "lifecycle", "list", bucket], { cwd, quiet: true });
+  if (listed.code !== 0) return warn("listing the rules failed");
+  if (rule.test(listed.stdout)) return;
+  const added = await run(
+    [
+      "r2",
+      "bucket",
+      "lifecycle",
+      "add",
+      bucket,
+      BUNDLE_LIFECYCLE_RULE,
+      BUNDLE_PREFIX,
+      "--expire-days",
+      String(BUNDLE_LIFECYCLE_DAYS),
+      "--force",
+    ],
+    { cwd, quiet: true },
+  );
+  if (added.code !== 0) return warn(added.stderr.trim().split("\n").at(-1) || "wrangler failed");
+  log(`R2: snapshot bundles under ${BUNDLE_PREFIX} expire after ${BUNDLE_LIFECYCLE_DAYS} days`);
+}
+
+export async function waitForHealth(
+  adminUrl        ,
+  f              ,
+  log                        ,
+  timeoutMs        ,
+)                {
+  const url = new URL("/api/health", adminUrl);
+  const deadline = Date.now() + timeoutMs;
+  let announced = false;
+  for (;;) {
+    try {
+      const res = await f(url);
+      if (res.ok) return;
+    } catch {
+      // DNS/TLS not ready yet
+    }
+    if (Date.now() > deadline)
+      throw new Error(
+        `${adminUrl} did not answer within ${Math.round(timeoutMs / 1000)}s; run \`cloudhal push\` once it is up`,
+      );
+    if (!announced) {
+      log(`waiting for ${new URL(adminUrl).hostname} to come online…`);
+      announced = true;
+    }
+    await new Promise((r) => setTimeout(r, 3000));
+  }
+}
+
+/** Purges the site Worker's whole cache once (the script tag lives in cached HTML). */
+export async function purgeSite(
+  siteUrl        ,
+  token        ,
+  f              ,
+  log                        ,
+)                   {
+  try {
+    const res = await f(new URL("/__cloudhal/purge", siteUrl), {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}` },
+    });
+    if (res.ok) return true;
+    log(`could not purge the site cache (${res.status}); pages pick up the change as they expire`);
+  } catch (e) {
+    log(`could not purge the site cache: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return false;
+}

package/dist/src/commands/deploy/schedules-guard.d.ts

@@ -0,0 +1,24 @@
+import type { DeployOptions } from "./options.js";
+/** The RFC's words when Cloudflare refuses the trigger (§16). */
+export declare const CRON_REFUSED_MESSAGE = "Cloudflare refused the cron trigger: this account uses all its cron triggers (Workers Free allows 5). The scheduler runs on a Durable Object alarm instead.";
+/**
+ * The schedules level of the code this project deploys: `cloudhal.schedulesLevel` of the
+ * `@cloudhal/core-ts` its admin Worker bundles (0 before RFC-0008), else the CLI's own.
+ */
+export declare function projectSchedulesLevel(projectDir: string): Promise<number>;
+export interface SchedulesStatus {
+    engine?: {
+        schedulesLevel?: number;
+    };
+    sites?: {
+        siteId: string;
+        openReleases?: unknown[];
+        gatedNodes?: number;
+    }[];
+}
+/**
+ * The downgrade guard (RFC-0008 Compatibility): older code ignores holds (an ordinary publish
+ * would release held nodes) and older site Workers ignore gates. A deployment that answers no
+ * schedules status predates schedules and has nothing to protect.
+ */
+export declare function downgradeGuard(options: DeployOptions, adminUrl: string, token: string, log: (line: string) => void): Promise<void>;

package/dist/src/commands/deploy/schedules-guard.js

@@ -0,0 +1,95 @@
+/** RFC-0008: never deploy code that ignores holds and gates over open releases (the downgrade guard). */
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { SCHEDULES_ENGINE_LEVEL } from "@cloudhal/core-ts/releases";
+                                                  
+
+/** The RFC's words when Cloudflare refuses the trigger (§16). */
+export const CRON_REFUSED_MESSAGE =
+  "Cloudflare refused the cron trigger: this account uses all its cron triggers (Workers Free allows 5). The scheduler runs on a Durable Object alarm instead.";
+
+/**
+ * The schedules level of the code this project deploys: `cloudhal.schedulesLevel` of the
+ * `@cloudhal/core-ts` its admin Worker bundles (0 before RFC-0008), else the CLI's own.
+ */
+export async function projectSchedulesLevel(projectDir        )                  {
+  const require = createRequire(path.join(projectDir, "package.json"));
+  const candidates           = [];
+  try {
+    candidates.push(require.resolve("@cloudhal/core-ts/package.json"));
+  } catch {
+    // not a direct dependency of the project
+  }
+  try {
+    const cf = require.resolve("@cloudhal/cloudflare/package.json");
+    candidates.push(createRequire(cf).resolve("@cloudhal/core-ts/package.json"));
+  } catch {
+    // resolved through the CLI below
+  }
+  for (const file of candidates) {
+    try {
+      const pkg = JSON.parse(await readFile(file, "utf8"))     
+                                                
+       ;
+      const level = pkg.cloudhal?.schedulesLevel;
+      return typeof level === "number" ? level : 0;
+    } catch {
+      // try the next
+    }
+  }
+  return SCHEDULES_ENGINE_LEVEL;
+}
+
+                                  
+                                       
+                                                                              
+ 
+
+/**
+ * The downgrade guard (RFC-0008 Compatibility): older code ignores holds (an ordinary publish
+ * would release held nodes) and older site Workers ignore gates. A deployment that answers no
+ * schedules status predates schedules and has nothing to protect.
+ */
+export async function downgradeGuard(
+  options               ,
+  adminUrl        ,
+  token        ,
+  log                        ,
+)                {
+  let status                 ;
+  try {
+    const res = await (options.fetch ?? fetch)(new URL("/api/admin/schedules/status", adminUrl), {
+      headers: { authorization: `Bearer ${token}` },
+    });
+    if (res.status === 404) return;
+    if (!res.ok) {
+      log(
+        `could not read the deployment's schedules (${res.status}); the downgrade check is skipped`,
+      );
+      return;
+    }
+    status = (await res.json())                   ;
+  } catch (e) {
+    log(
+      `could not reach the deployment to check its schedules (${e instanceof Error ? e.message : String(e)}); the downgrade check is skipped`,
+    );
+    return;
+  }
+  const remote = status.engine?.schedulesLevel ?? 0;
+  const local = await projectSchedulesLevel(options.projectDir);
+  if (remote <= local) return;
+  const open = (status.sites ?? []).reduce((n, s) => n + (s.openReleases?.length ?? 0), 0);
+  const gated = (status.sites ?? []).reduce((n, s) => n + (s.gatedNodes ?? 0), 0);
+  if (open + gated === 0) return;
+  const what = `${open} open release(s) and ${gated} page(s) or entr(ies) with time gates`;
+  if (options.forceDowngrade) {
+    log(
+      `--force-downgrade: deploying schedules level ${local} over level ${remote} with ${what}; held content and embargoes are no longer enforced`,
+    );
+    return;
+  }
+  throw new Error(
+    `This deploy would downgrade the deployment's schedules (level ${remote} → ${local}) while it has ${what}. Older code ignores scheduled holds and time gates, so they could go live early. Upgrade the @cloudhal packages of this project, cancel the releases and remove the gates (\`cloudhal schedules status --remote\` lists them), or deploy with --force-downgrade.`,
+  );
+}

package/dist/src/commands/deploy/served-sites.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RFC-0034 §4–5: the sites a multi-site deployment serves (`cloudhal.json` `sites`). Before the
+ * site Worker is built, the deployment is asked for those sites (`GET /api/admin/sites`): each
+ * must exist there and be designed for the deployed theme (invariant 6), and every hostname they
+ * hold becomes a Custom Domain route. On the first deploy there is no deployment to ask yet: the
+ * other sites' routes follow on the next deploy, once they exist.
+ */
+import type { DeployContext } from "./context.js";
+export interface ServedSites {
+    /** The site ids for `CLOUDHAL_SITE_IDS`; undefined for a single-site deployment. */
+    readonly siteIds?: readonly string[];
+    /** Hostnames of the served sites besides `domains.site` (workers.dev hosts excluded). */
+    readonly hosts: readonly string[];
+}
+export declare function servedSites(ctx: DeployContext): Promise<ServedSites>;
+/** A site Worker another project attached to this installation (`/api/admin/site-workers`). */
+export interface AttachedWorker {
+    readonly name: string;
+    readonly url: string;
+    readonly theme: string;
+    readonly siteIds: readonly string[];
+}
+/**
+ * The site Workers attached to this installation, so the admin Worker gets a service binding to
+ * each and routes their sites' purges there (RFC-0034 §4). None before the first deploy, or when
+ * the deployment predates the registry.
+ */
+export declare function attachedWorkers(ctx: DeployContext): Promise<AttachedWorker[]>;

package/dist/src/commands/deploy/served-sites.js

@@ -0,0 +1,86 @@
+/**
+ * RFC-0034 §4–5: the sites a multi-site deployment serves (`cloudhal.json` `sites`). Before the
+ * site Worker is built, the deployment is asked for those sites (`GET /api/admin/sites`): each
+ * must exist there and be designed for the deployed theme (invariant 6), and every hostname they
+ * hold becomes a Custom Domain route. On the first deploy there is no deployment to ask yet: the
+ * other sites' routes follow on the next deploy, once they exist.
+ */
+
+import { listSites } from "../site.js";
+import { deployment } from "../sync.js";
+                                                  
+
+                              
+                                                                                      
+                                       
+                                                                                           
+                                    
+ 
+
+export async function servedSites(ctx               )                       {
+  const { cfg, site, previous, options, log } = ctx;
+  if (!cfg.sites) return { hosts: [] };
+  if (!previous?.adminUrl) {
+    log(
+      `sites: serving ${cfg.sites.length} sites by hostname; deploy again after \`cloudhal site create --remote\` to route the others' domains`,
+    );
+    return { siteIds: cfg.sites, hosts: [] };
+  }
+  const remote = await listSites({
+    projectDir: options.projectDir,
+    remote: true,
+    adminUrl: previous.adminUrl,
+    ...(options.fetch ? { fetch: options.fetch } : {}),
+  });
+  const missing = cfg.sites.filter((id) => id !== cfg.siteId && !remote.some((s) => s.id === id));
+  if (missing.length > 0)
+    throw new Error(
+      `cloudhal.json sites: ${missing.join(", ")} not found on the deployment (create them with \`cloudhal site create --remote\`)`,
+    );
+  const theme = site.theme.name;
+  const other = remote.filter((s) => cfg.sites?.includes(s.id) && s.theme !== theme);
+  if (other.length > 0)
+    throw new Error(
+      `cloudhal.json sites: ${other.map((s) => `${s.slug} (${s.theme})`).join(", ")} use another theme than this Worker's ${theme}; serve them from a site Worker with that theme`,
+    );
+  const hosts = remote
+    .filter((s) => cfg.sites?.includes(s.id))
+    .flatMap((s) => s.hosts)
+    .filter((h) => !h.endsWith(".workers.dev") && h !== cfg.domains?.site);
+  return { siteIds: cfg.sites, hosts: [...new Set(hosts)] };
+}
+
+/** A site Worker another project attached to this installation (`/api/admin/site-workers`). */
+                                 
+                        
+                       
+                         
+                                      
+ 
+
+/**
+ * The site Workers attached to this installation, so the admin Worker gets a service binding to
+ * each and routes their sites' purges there (RFC-0034 §4). None before the first deploy, or when
+ * the deployment predates the registry.
+ */
+export async function attachedWorkers(ctx               )                            {
+  const { previous, options, log } = ctx;
+  if (!previous?.adminUrl) return [];
+  try {
+    const { token, fetch: f } = await deployment({
+      projectDir: options.projectDir,
+      adminUrl: previous.adminUrl,
+      ...(options.fetch ? { fetch: options.fetch } : {}),
+    });
+    const res = await f(new URL("/api/admin/site-workers", previous.adminUrl), {
+      headers: { authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) return [];
+    const workers = ((await res.json())                                 ).workers;
+    for (const w of workers)
+      log(`site Worker ${w.name} (${w.theme}) serves ${w.siteIds.length} site(s): binding it`);
+    return workers;
+  } catch {
+    return [];
+  }
+}

package/dist/src/commands/deploy/settings.d.ts

@@ -0,0 +1,24 @@
+/** What `cloudhal.json` and the flags turn into for the generated configs: analytics, comments, jurisdiction, observability. */
+import { type AnalyticsDeployment, type CommentsDeployment, type ObservabilityDeployment, type SchedulerTicker } from "../../cloudflare/config.js";
+import { type ProjectConfig } from "../../config.js";
+import type { DeployOptions, DeployResult } from "./options.js";
+import type { Jurisdiction } from "./state.js";
+/** Default daily budget of uncached live analytics queries (RFC-0006 §7.7, open question 6). */
+export declare const DEFAULT_QUERY_BUDGET = 8000;
+/** `analytics.rateLimit` as the generated config needs it (RFC-0006 §5.5); `{}` when off. */
+export declare function rateLimitDeployment(cfg: Pick<ProjectConfig, "analytics">, dataset: string): Pick<AnalyticsDeployment, "rateLimit">;
+/** `comments.rateLimit` as the generated config needs it (RFC-0007 §6.5); `{}` when off. */
+export declare function commentsRateLimitDeployment(cfg: Pick<ProjectConfig, "comments">, name: string): Pick<CommentsDeployment, "rateLimit">;
+/**
+ * Whether this deploy records analytics: `cloudhal.json` decides; a project without the key is
+ * asked once in a terminal and the answer is written back (RFC-0006 §11, open question 1).
+ */
+export declare function decideAnalytics(options: DeployOptions, cfg: ProjectConfig, siteName: string, log: (line: string) => void): Promise<ProjectConfig>;
+/**
+ * Where a database this deploy creates should live (RFC-0007 D7): the flag, else the terminal
+ * question, else (non-interactive) the automatic location, saying how to choose.
+ */
+export declare function jurisdictionChooser(options: DeployOptions, log: (line: string) => void): () => Promise<Jurisdiction>;
+export declare function commentsResult(c: CommentsDeployment, scheduler: SchedulerTicker, purged?: boolean): DeployResult["comments"];
+/** `cloudhal.json` `observability` as the generated configs need it. */
+export declare function observabilityOf(cfg: Pick<ProjectConfig, "observability">): ObservabilityDeployment;

package/dist/src/commands/deploy/settings.js

@@ -0,0 +1,115 @@
+/** What `cloudhal.json` and the flags turn into for the generated configs: analytics, comments, jurisdiction, observability. */
+
+import {
+                           
+                          
+  DEFAULT_BEACON_RATE_LIMIT,
+  DEFAULT_COMMENTS_RATE_LIMIT,
+                               
+  rateLimitNamespaceId,
+                       
+} from "../../cloudflare/config.js";
+import {                     writeProjectConfig } from "../../config.js";
+                                                                
+                                               
+
+/** Default daily budget of uncached live analytics queries (RFC-0006 §7.7, open question 6). */
+export const DEFAULT_QUERY_BUDGET = 8000;
+
+/** `analytics.rateLimit` as the generated config needs it (RFC-0006 §5.5); `{}` when off. */
+export function rateLimitDeployment(
+  cfg                                  ,
+  dataset        ,
+)                                         {
+  const r = cfg.analytics?.rateLimit;
+  if (!r) return {};
+  const o = r === true ? {} : r;
+  return {
+    rateLimit: {
+      namespaceId: o.namespaceId ?? rateLimitNamespaceId(dataset),
+      limit: o.limit ?? DEFAULT_BEACON_RATE_LIMIT,
+    },
+  };
+}
+
+/** `comments.rateLimit` as the generated config needs it (RFC-0007 §6.5); `{}` when off. */
+export function commentsRateLimitDeployment(
+  cfg                                 ,
+  name        ,
+)                                        {
+  const r = cfg.comments?.rateLimit;
+  if (!r) return {};
+  const o = r === true ? {} : r;
+  return {
+    rateLimit: {
+      namespaceId: o.namespaceId ?? rateLimitNamespaceId(name, "comments"),
+      limit: o.limit ?? DEFAULT_COMMENTS_RATE_LIMIT,
+    },
+  };
+}
+
+/**
+ * Whether this deploy records analytics: `cloudhal.json` decides; a project without the key is
+ * asked once in a terminal and the answer is written back (RFC-0006 §11, open question 1).
+ */
+export async function decideAnalytics(
+  options               ,
+  cfg               ,
+  siteName        ,
+  log                        ,
+)                         {
+  if (cfg.analytics !== undefined) return cfg;
+  if (!options.prompt) {
+    log(
+      'analytics: off. Turn on cookie-less analytics with "analytics": { "enabled": true } in cloudhal.json, then deploy again.',
+    );
+    return cfg;
+  }
+  const yes = await options.prompt(`Turn on cookie-less analytics for ${siteName}? (Y/n) `);
+  const next                = { ...cfg, analytics: { enabled: yes } };
+  await writeProjectConfig(options.projectDir, next);
+  log(`analytics: ${yes ? "on" : "off"} (saved in cloudhal.json)`);
+  return next;
+}
+
+/**
+ * Where a database this deploy creates should live (RFC-0007 D7): the flag, else the terminal
+ * question, else (non-interactive) the automatic location, saying how to choose.
+ */
+export function jurisdictionChooser(
+  options               ,
+  log                        ,
+)                              {
+  return async () => {
+    if (options.jurisdiction) return options.jurisdiction;
+    if (options.askJurisdiction) return options.askJurisdiction();
+    log(
+      "D1 database: automatic location (non-interactive). To keep the data in the EU, create it with `cloudhal deploy --jurisdiction eu` instead: a jurisdiction cannot be changed once the database exists.",
+    );
+    return "auto";
+  };
+}
+
+export function commentsResult(
+  c                    ,
+  scheduler                 ,
+  purged          ,
+)                           {
+  return {
+    available: c.available,
+    ...(c.available ? { cron: scheduler === "cron" } : {}),
+    ...(c.rateLimit ? { rateLimit: true } : {}),
+    ...(purged ? { purged } : {}),
+  };
+}
+
+/** `cloudhal.json` `observability` as the generated configs need it. */
+export function observabilityOf(
+  cfg                                      ,
+)                          {
+  const t = cfg.observability?.traces;
+  return {
+    logs: cfg.observability?.logs ?? 1,
+    traces: t === true ? 1 : typeof t === "number" && t > 0 ? t : false,
+  };
+}

package/dist/src/commands/deploy/ship.d.ts

@@ -0,0 +1,46 @@
+import type { prepareAdminWorker } from "../../cloudflare/admin.js";
+import type { AnalyticsDeployment, CommentsDeployment, SchedulerTicker } from "../../cloudflare/config.js";
+import type { DeployContext } from "./context.js";
+import type { DeploySecrets } from "./state.js";
+type PreparedAdmin = Awaited<ReturnType<typeof prepareAdminWorker>>;
+/**
+ * `wrangler deploy` for the site Worker, then the admin Worker. When Cloudflare refuses the cron
+ * trigger (RFC-0008 §8.3: Workers Free allows 5 per account), the same Worker goes without it and
+ * the SchedulerClock alarm ticks instead.
+ */
+export declare function shipWorkers(ctx: DeployContext, input: {
+    secrets: DeploySecrets;
+    admin: PreparedAdmin;
+    prepareAdmin: (ticker: SchedulerTicker) => Promise<PreparedAdmin>;
+    scheduler: SchedulerTicker;
+}): Promise<{
+    siteUrl: string | undefined;
+    adminUrl: string | undefined;
+    scheduler: SchedulerTicker;
+}>;
+/**
+ * 5. first deploy: push the local site, and make the site's hostname primary (the custom domain
+ * when there is one). Returns whether the site was pushed.
+ */
+export declare function afterDeploy(ctx: DeployContext, { siteUrl, adminUrl }: {
+    siteUrl: string | undefined;
+    adminUrl: string | undefined;
+}): Promise<boolean>;
+/**
+ * Analytics switched on (or off): purge the site's cache once, so cached pages gain (or lose)
+ * the script tag. The admin Worker ran migration 0014 on the health check; until it has, the Site
+ * Worker counts analytics as off (fail closed). Comments availability likewise (RFC-0007): pages
+ * cached before carry no `cloudhal-comments-<id>` tag, so a site turning comments on later could
+ * not reach them.
+ */
+export declare function purgeIfSwitched(ctx: DeployContext, input: {
+    siteUrl: string | undefined;
+    analytics: AnalyticsDeployment | undefined;
+    comments: CommentsDeployment;
+    purgeToken: string;
+}): Promise<{
+    purged: boolean;
+    analyticsChanged: boolean;
+    commentsChanged: boolean;
+}>;
+export {};