@spacefast/common 0.0.5 → 0.0.7

package/dist/contracts/feature-lifecycle-core.js

@@ -0,0 +1,220 @@
+export const FEATURE_STAGES = ["internal", "private_beta", "ga"];
+export const FEATURE_ASSIGNMENT_SCOPES = ["user", "team", "global"];
+export const FEATURE_EXECUTION_ACTOR_POLICIES = [
+    "request_actor",
+    "persisted_request_actor",
+    "resource_team",
+    "global_policy",
+];
+export const FEATURE_OWNER_IDS = [
+    "team:access",
+    "team:build-platform",
+    "team:collaboration",
+    "team:commerce",
+    "team:domains",
+    "team:publishing",
+    "team:runtime",
+    "team:spaces",
+    "team:tag-manager",
+    "team:zero",
+];
+export function freezeFeatureRegistryEntry(definition) {
+    return Object.freeze({
+        ...definition,
+        assignmentScopes: Object.freeze([...definition.assignmentScopes]),
+        docs: definition.docs === null ? null : Object.freeze({ ...definition.docs }),
+        requires: Object.freeze([...definition.requires]),
+        allowedActorPolicies: Object.freeze([...definition.allowedActorPolicies]),
+        downRamp: Object.freeze({ ...definition.downRamp }),
+    });
+}
+function isStrictLifecycleDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function hasCanonicalDocsSlug(channel, slug) {
+    const prefix = channel === "public" ? "/docs/" : "/features/";
+    return (slug.startsWith(prefix) &&
+        slug
+            .slice(prefix.length)
+            .split("/")
+            .every((segment) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(segment)));
+}
+function hasRequiredMetadata(value) {
+    const normalized = value.trim();
+    return normalized.length > 0 && normalized.toUpperCase() !== "TBD";
+}
+function duplicateValues(values) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            duplicates.add(value);
+        seen.add(value);
+    }
+    return [...duplicates].toSorted();
+}
+function isValidUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" || url.protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}
+export function validateFeatureLifecycleRegistry(registry) {
+    const errors = [];
+    const keys = new Set(registry.map(({ key }) => key));
+    const downRampCodes = new Set(registry.map(({ downRamp }) => downRamp.code));
+    if (keys.size !== registry.length)
+        errors.push("registry: duplicate feature key");
+    if (downRampCodes.size !== registry.length)
+        errors.push("registry: duplicate down-ramp code");
+    const byKey = new Map(registry.map((definition) => [definition.key, definition]));
+    for (const [index, definition] of registry.entries()) {
+        const lifecycleAdoptedAtValid = isStrictLifecycleDate(definition.lifecycleAdoptedAt);
+        const reviewAfterValid = definition.reviewAfter === null || isStrictLifecycleDate(definition.reviewAfter);
+        const removeAfterValid = definition.removeAfter === null || isStrictLifecycleDate(definition.removeAfter);
+        const gaAtValid = definition.gaAt === null || isStrictLifecycleDate(definition.gaAt);
+        if (!lifecycleAdoptedAtValid)
+            errors.push(`${definition.key}: lifecycleAdoptedAt must be a real YYYY-MM-DD date`);
+        if (!reviewAfterValid)
+            errors.push(`${definition.key}: reviewAfter must be a real YYYY-MM-DD date`);
+        if (!removeAfterValid)
+            errors.push(`${definition.key}: removeAfter must be a real YYYY-MM-DD date`);
+        if (!gaAtValid)
+            errors.push(`${definition.key}: gaAt must be a real YYYY-MM-DD date`);
+        if (!hasRequiredMetadata(definition.name))
+            errors.push(`${definition.key}: name must not be blank or TBD`);
+        if (!hasRequiredMetadata(definition.description))
+            errors.push(`${definition.key}: description must not be blank or TBD`);
+        if (!hasRequiredMetadata(definition.owner))
+            errors.push(`${definition.key}: owner must not be blank or TBD`);
+        if (!hasRequiredMetadata(definition.downRamp.code))
+            errors.push(`${definition.key}: downRamp.code must not be blank or TBD`);
+        if (!hasRequiredMetadata(definition.downRamp.summary))
+            errors.push(`${definition.key}: downRamp.summary must not be blank or TBD`);
+        if (!hasRequiredMetadata(definition.key))
+            errors.push(`registry[${index}]: feature key must not be blank or TBD`);
+        else if (!/^[a-z][a-z0-9]*(?:[._][a-z][a-z0-9]*)*$/.test(definition.key))
+            errors.push(`${definition.key}: feature key must use canonical lowercase segments`);
+        if (hasRequiredMetadata(definition.downRamp.code) &&
+            !/^[a-z][a-z0-9]*(?:_[a-z][a-z0-9]*)*$/.test(definition.downRamp.code))
+            errors.push(`${definition.key}: downRamp.code must use canonical snake_case`);
+        if (definition.assignmentScopes.length === 0 || !definition.assignmentScopes.includes("global"))
+            errors.push(`${definition.key}: assignmentScopes must include global`);
+        if (definition.allowedActorPolicies.length === 0)
+            errors.push(`${definition.key}: allowedActorPolicies must not be empty`);
+        for (const [field, values] of [
+            ["assignmentScopes", definition.assignmentScopes],
+            ["allowedActorPolicies", definition.allowedActorPolicies],
+            ["requires", definition.requires],
+        ]) {
+            for (const duplicate of duplicateValues(values))
+                errors.push(`${definition.key}: ${field} contains duplicate ${duplicate}`);
+        }
+        if (definition.allowedActorPolicies.includes("global_policy") &&
+            (definition.assignmentScopes.length !== 1 || definition.assignmentScopes[0] !== "global"))
+            errors.push(`${definition.key}: global policy requires exactly global assignment scope`);
+        if (definition.stage !== "ga" && definition.surface && definition.defaultEnabled)
+            errors.push(`${definition.key}: non-GA features default off`);
+        if (definition.stage === "ga" && definition.surface && !definition.defaultEnabled)
+            errors.push(`${definition.key}: GA surface features default on`);
+        if (!definition.surface && definition.docs !== null)
+            errors.push(`${definition.key}: non-surface features must not have docs`);
+        if (definition.docs !== null &&
+            !hasCanonicalDocsSlug(definition.docs.channel, definition.docs.slug))
+            errors.push(`${definition.key}: docs slug must be a canonical ${definition.docs.channel} path`);
+        if (definition.docs !== null &&
+            definition.docs.feedbackUrl !== null &&
+            !isValidUrl(definition.docs.feedbackUrl))
+            errors.push(`${definition.key}: docs feedbackUrl must be a valid URL`);
+        if (definition.stage === "internal" && definition.docs?.channel === "public")
+            errors.push(`${definition.key}: internal features must not have public docs`);
+        if (definition.stage === "private_beta" && definition.docs?.channel !== "public")
+            errors.push(`${definition.key}: private beta requires public docs`);
+        if (definition.stage === "ga" && definition.surface && definition.docs?.channel !== "public")
+            errors.push(`${definition.key}: GA surface features require public docs`);
+        if (definition.stage !== "ga" && definition.surface && definition.reviewAfter === null)
+            errors.push(`${definition.key}: non-GA surface features require reviewAfter`);
+        if (definition.surface && definition.removeAfter === null)
+            errors.push(`${definition.key}: surface features require removeAfter`);
+        if (lifecycleAdoptedAtValid &&
+            reviewAfterValid &&
+            definition.reviewAfter !== null &&
+            definition.lifecycleAdoptedAt > definition.reviewAfter)
+            errors.push(`${definition.key}: lifecycleAdoptedAt must not follow reviewAfter`);
+        if (reviewAfterValid &&
+            removeAfterValid &&
+            definition.reviewAfter !== null &&
+            definition.removeAfter !== null &&
+            definition.reviewAfter > definition.removeAfter)
+            errors.push(`${definition.key}: reviewAfter must not follow removeAfter`);
+        if (lifecycleAdoptedAtValid &&
+            removeAfterValid &&
+            definition.removeAfter !== null &&
+            definition.lifecycleAdoptedAt > definition.removeAfter)
+            errors.push(`${definition.key}: lifecycleAdoptedAt must not follow removeAfter`);
+        if (definition.gaAt !== null && definition.stage !== "ga")
+            errors.push(`${definition.key}: only GA features may set gaAt`);
+        if (definition.stage === "ga" && definition.gaAt === null)
+            errors.push(`${definition.key}: GA features require gaAt`);
+        if (lifecycleAdoptedAtValid &&
+            gaAtValid &&
+            definition.gaAt !== null &&
+            definition.gaAt < definition.lifecycleAdoptedAt)
+            errors.push(`${definition.key}: gaAt must not precede lifecycleAdoptedAt`);
+        if (gaAtValid &&
+            removeAfterValid &&
+            definition.gaAt !== null &&
+            definition.removeAfter !== null &&
+            definition.gaAt > definition.removeAfter)
+            errors.push(`${definition.key}: gaAt must not follow removeAfter`);
+        if (definition.assignmentScopes.includes("user") &&
+            !definition.allowedActorPolicies.some((policy) => policy === "request_actor" || policy === "persisted_request_actor"))
+            errors.push(`${definition.key}: user scope requires an actor-aware policy`);
+        for (const dependency of definition.requires) {
+            const dependencyDefinition = byKey.get(dependency);
+            if (!dependencyDefinition) {
+                errors.push(`${definition.key}: unknown dependency ${dependency}`);
+                continue;
+            }
+            if (definition.allowedActorPolicies.some((policy) => !dependencyDefinition.allowedActorPolicies.includes(policy)))
+                errors.push(`${definition.key}: actor policies must be allowed by dependency ${dependency}`);
+            if (definition.assignmentScopes.some((scope) => !dependencyDefinition.assignmentScopes.includes(scope)))
+                errors.push(`${definition.key}: assignment scopes must be supported by dependency ${dependency}`);
+            if (FEATURE_STAGES.indexOf(dependencyDefinition.stage) <
+                FEATURE_STAGES.indexOf(definition.stage))
+                errors.push(`${definition.key}: dependency ${dependency} must be at least as mature as its dependent`);
+            if (definition.defaultEnabled && !dependencyDefinition.defaultEnabled)
+                errors.push(`${definition.key}: default-enabled feature requires default-enabled dependency ${dependency}`);
+            if (removeAfterValid &&
+                dependencyDefinition.removeAfter !== null &&
+                isStrictLifecycleDate(dependencyDefinition.removeAfter) &&
+                (definition.removeAfter === null ||
+                    dependencyDefinition.removeAfter < definition.removeAfter))
+                errors.push(`${definition.key}: dependency ${dependency} retires before its dependent`);
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (key) => {
+        if (visiting.has(key)) {
+            errors.push(`${key}: dependency cycle`);
+            return;
+        }
+        if (visited.has(key))
+            return;
+        visiting.add(key);
+        for (const dependency of byKey.get(key)?.requires ?? [])
+            visit(dependency);
+        visiting.delete(key);
+        visited.add(key);
+    };
+    for (const key of keys)
+        visit(key);
+    return errors;
+}

package/dist/contracts/feature-lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { FeatureRegistryEntry } from "./feature-lifecycle-core.js";
+import { launchEntries as compiledLaunchEntries } from "./generated-feature-launch-entries.js";
+export { FEATURE_ASSIGNMENT_SCOPES, FEATURE_EXECUTION_ACTOR_POLICIES, FEATURE_OWNER_IDS, FEATURE_STAGES, freezeFeatureRegistryEntry, validateFeatureLifecycleRegistry, } from "./feature-lifecycle-core.js";
+export type { FeatureAssignmentScope, FeatureExecutionActorPolicy, FeatureOwnerId, FeatureRegistryEntry, FeatureStage, } from "./feature-lifecycle-core.js";
+export type LifecycleFeatureKey = (typeof compiledLaunchEntries)[number]["key"];
+export declare const FEATURE_LIFECYCLE_REGISTRY: readonly FeatureRegistryEntry<LifecycleFeatureKey>[];
+export declare const FEATURE_LIFECYCLE_BY_KEY: ReadonlyMap<LifecycleFeatureKey, FeatureRegistryEntry<LifecycleFeatureKey>>;

package/dist/contracts/feature-lifecycle.js

@@ -0,0 +1,31 @@
+import { launchEntries as compiledLaunchEntries } from "./generated-feature-launch-entries.js";
+export { FEATURE_ASSIGNMENT_SCOPES, FEATURE_EXECUTION_ACTOR_POLICIES, FEATURE_OWNER_IDS, FEATURE_STAGES, freezeFeatureRegistryEntry, validateFeatureLifecycleRegistry, } from "./feature-lifecycle-core.js";
+export const FEATURE_LIFECYCLE_REGISTRY = compiledLaunchEntries;
+const featureLifecycleByKey = new Map(FEATURE_LIFECYCLE_REGISTRY.map((definition) => [definition.key, definition]));
+export const FEATURE_LIFECYCLE_BY_KEY = Object.freeze({
+    get size() {
+        return featureLifecycleByKey.size;
+    },
+    get(key) {
+        return featureLifecycleByKey.get(key);
+    },
+    has(key) {
+        return featureLifecycleByKey.has(key);
+    },
+    entries() {
+        return featureLifecycleByKey.entries();
+    },
+    keys() {
+        return featureLifecycleByKey.keys();
+    },
+    values() {
+        return featureLifecycleByKey.values();
+    },
+    forEach(callback, thisArg) {
+        for (const [key, value] of featureLifecycleByKey)
+            callback.call(thisArg, value, key, this);
+    },
+    [Symbol.iterator]() {
+        return featureLifecycleByKey[Symbol.iterator]();
+    },
+});

package/dist/contracts/features.d.ts

@@ -9,7 +9,7 @@ export declare const planCodeSchema: z.ZodEnum<{
 }>;
 export type PlanCode = z.infer<typeof planCodeSchema>;
 export declare const DEFAULT_PLAN_CODE: PlanCode;
-export declare const FEATURE_KEYS: readonly ["plans.paid.available", "anonymous.publishing", "beta.enrollment_gate", "domains.search", "domains.registration", "domains.dns_management", "domains.proxy_bindings", "annotations.preview_loader", "annotations.comments", "annotations.anonymous_reviewers", "annotations.cli", "annotations.notices", "annotations.spacefast_token", "annotations.published_comments", "sites.dedicated_runtime", "shelf", "tags", "zero"];
+export declare const FEATURE_KEYS: readonly ["plans.paid.available", "anonymous.publishing", "beta.enrollment_gate", "domains.search", "domains.registration", "domains.dns_management", "domains.wpcom_dns", "domains.domain_connect", "domains.proxy_bindings", "annotations.preview_loader", "annotations.comments", "annotations.anonymous_reviewers", "annotations.cli", "annotations.notices", "annotations.published_comments", "sites.dedicated_runtime", "shelf", "tags", "zero", "access.share_links", "access.invites", "access.firewall_card", "access.sso_connections", "access.byo_issuers", "access.views_panel", "pages.white_label"];
 export declare const featureKeySchema: z.ZodEnum<{
     zero: "zero";
     "plans.paid.available": "plans.paid.available";
@@ -18,17 +18,25 @@ export declare const featureKeySchema: z.ZodEnum<{
     "domains.search": "domains.search";
     "domains.registration": "domains.registration";
     "domains.dns_management": "domains.dns_management";
+    "domains.wpcom_dns": "domains.wpcom_dns";
+    "domains.domain_connect": "domains.domain_connect";
     "domains.proxy_bindings": "domains.proxy_bindings";
     "annotations.preview_loader": "annotations.preview_loader";
     "annotations.comments": "annotations.comments";
     "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
     "annotations.cli": "annotations.cli";
     "annotations.notices": "annotations.notices";
-    "annotations.spacefast_token": "annotations.spacefast_token";
     "annotations.published_comments": "annotations.published_comments";
     "sites.dedicated_runtime": "sites.dedicated_runtime";
     shelf: "shelf";
     tags: "tags";
+    "access.share_links": "access.share_links";
+    "access.invites": "access.invites";
+    "access.firewall_card": "access.firewall_card";
+    "access.sso_connections": "access.sso_connections";
+    "access.byo_issuers": "access.byo_issuers";
+    "access.views_panel": "access.views_panel";
+    "pages.white_label": "pages.white_label";
 }>;
 export type FeatureKey = z.infer<typeof featureKeySchema>;
 export declare const FEATURE_OVERRIDE_STATES: readonly ["enabled", "disabled", "kill_switch"];
@@ -56,6 +64,15 @@ export declare const planLimitsSchema: z.ZodObject<{
     buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
     buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
     analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    cloudRulesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    shareLinksPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    invitesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    inviteEmailsPerSpaceDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    inviteEmailsPerAccountDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    pendingAccessRequestsPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    serviceTokensPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    connectionsPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    teamDefaultRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
 }, z.core.$strip>;
 export type PlanLimits = z.infer<typeof planLimitsSchema>;
 export declare const teamEntitlementsSchema: z.ZodObject<{
@@ -82,9 +99,22 @@ export declare const teamEntitlementsSchema: z.ZodObject<{
         buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        cloudRulesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        shareLinksPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        invitesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        inviteEmailsPerSpaceDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        inviteEmailsPerAccountDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        pendingAccessRequestsPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        serviceTokensPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        connectionsPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        teamDefaultRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
     }, z.core.$strip>;
     headersBasicAuth: z.ZodBoolean;
     externalProxy: z.ZodBoolean;
+    dedicatedRuntime: z.ZodBoolean;
+    pagesWhiteLabel: z.ZodBoolean;
+    pagesCustomHtml: z.ZodBoolean;
+    pagesAdvancedTheming: z.ZodBoolean;
     runtimePhpWorkers: z.ZodNumber;
     analyticsHourlyGranularity: z.ZodBoolean;
     versionDiagnosticsIncluded: z.ZodBoolean;
@@ -100,6 +130,10 @@ export declare const teamEntitlementsResponseSchema: z.ZodObject<{
     }>;
     headersBasicAuth: z.ZodBoolean;
     externalProxy: z.ZodBoolean;
+    dedicatedRuntime: z.ZodBoolean;
+    pagesWhiteLabel: z.ZodBoolean;
+    pagesCustomHtml: z.ZodBoolean;
+    pagesAdvancedTheming: z.ZodBoolean;
     runtimePhpWorkers: z.ZodNumber;
     analyticsHourlyGranularity: z.ZodBoolean;
     versionDiagnosticsIncluded: z.ZodBoolean;
@@ -116,9 +150,17 @@ export declare const teamEntitlementsResponseSchema: z.ZodObject<{
         buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        cloudRulesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        shareLinksPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        invitesPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        inviteEmailsPerSpaceDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        inviteEmailsPerAccountDaily: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        pendingAccessRequestsPerSpace: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        serviceTokensPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        connectionsPerTeam: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        teamDefaultRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type TeamEntitlementsResponse = z.infer<typeof teamEntitlementsResponseSchema>;
 export type PlanDefinition = {
     code: PlanCode;
     name: string;
@@ -126,6 +168,10 @@ export type PlanDefinition = {
     limits: PlanLimits;
     headersBasicAuth: boolean;
     externalProxy: boolean;
+    dedicatedRuntime: boolean;
+    pagesWhiteLabel: boolean;
+    pagesCustomHtml: boolean;
+    pagesAdvancedTheming: boolean;
     runtimePhpWorkers: number;
     analyticsHourlyGranularity: boolean;
 };
@@ -155,17 +201,25 @@ export declare const FeatureStateSchema: z.ZodObject<{
         "domains.search": "domains.search";
         "domains.registration": "domains.registration";
         "domains.dns_management": "domains.dns_management";
+        "domains.wpcom_dns": "domains.wpcom_dns";
+        "domains.domain_connect": "domains.domain_connect";
         "domains.proxy_bindings": "domains.proxy_bindings";
         "annotations.preview_loader": "annotations.preview_loader";
         "annotations.comments": "annotations.comments";
         "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
         "annotations.cli": "annotations.cli";
         "annotations.notices": "annotations.notices";
-        "annotations.spacefast_token": "annotations.spacefast_token";
         "annotations.published_comments": "annotations.published_comments";
         "sites.dedicated_runtime": "sites.dedicated_runtime";
         shelf: "shelf";
         tags: "tags";
+        "access.share_links": "access.share_links";
+        "access.invites": "access.invites";
+        "access.firewall_card": "access.firewall_card";
+        "access.sso_connections": "access.sso_connections";
+        "access.byo_issuers": "access.byo_issuers";
+        "access.views_panel": "access.views_panel";
+        "pages.white_label": "pages.white_label";
     }>;
     enabled: z.ZodBoolean;
     source: z.ZodEnum<{
@@ -191,17 +245,25 @@ export declare const FeatureStateResponseSchema: z.ZodObject<{
         "domains.search": "domains.search";
         "domains.registration": "domains.registration";
         "domains.dns_management": "domains.dns_management";
+        "domains.wpcom_dns": "domains.wpcom_dns";
+        "domains.domain_connect": "domains.domain_connect";
         "domains.proxy_bindings": "domains.proxy_bindings";
         "annotations.preview_loader": "annotations.preview_loader";
         "annotations.comments": "annotations.comments";
         "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
         "annotations.cli": "annotations.cli";
         "annotations.notices": "annotations.notices";
-        "annotations.spacefast_token": "annotations.spacefast_token";
         "annotations.published_comments": "annotations.published_comments";
         "sites.dedicated_runtime": "sites.dedicated_runtime";
         shelf: "shelf";
         tags: "tags";
+        "access.share_links": "access.share_links";
+        "access.invites": "access.invites";
+        "access.firewall_card": "access.firewall_card";
+        "access.sso_connections": "access.sso_connections";
+        "access.byo_issuers": "access.byo_issuers";
+        "access.views_panel": "access.views_panel";
+        "pages.white_label": "pages.white_label";
     }>, z.ZodObject<{
         key: z.ZodEnum<{
             zero: "zero";
@@ -211,17 +273,25 @@ export declare const FeatureStateResponseSchema: z.ZodObject<{
             "domains.search": "domains.search";
             "domains.registration": "domains.registration";
             "domains.dns_management": "domains.dns_management";
+            "domains.wpcom_dns": "domains.wpcom_dns";
+            "domains.domain_connect": "domains.domain_connect";
             "domains.proxy_bindings": "domains.proxy_bindings";
             "annotations.preview_loader": "annotations.preview_loader";
             "annotations.comments": "annotations.comments";
             "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
             "annotations.cli": "annotations.cli";
             "annotations.notices": "annotations.notices";
-            "annotations.spacefast_token": "annotations.spacefast_token";
             "annotations.published_comments": "annotations.published_comments";
             "sites.dedicated_runtime": "sites.dedicated_runtime";
             shelf: "shelf";
             tags: "tags";
+            "access.share_links": "access.share_links";
+            "access.invites": "access.invites";
+            "access.firewall_card": "access.firewall_card";
+            "access.sso_connections": "access.sso_connections";
+            "access.byo_issuers": "access.byo_issuers";
+            "access.views_panel": "access.views_panel";
+            "pages.white_label": "pages.white_label";
         }>;
         enabled: z.ZodBoolean;
         source: z.ZodEnum<{