@vibes.diy/api-types 14.0.14 → 14.0.16

package/settings.js

@@ -3,46 +3,47 @@ import { dashAuthType, Role } from "./common.js";
 import { AIParams, ActiveEntry, EnablePublicAccess, EnableRequest, ActiveACL, KVString, SecretMeta, Style } from "./invite.js";
 import { anonWriteMode, dbAcl, dbPosture, postureIntent } from "./db-acls.js";
 import { cachedSuggestionRecord, cachedSuggestionBlessRecord, } from "./cached-suggestion.js";
-export const sharingGrantItem = type({
+import { lazyType } from "./lazy-type.js";
+export const sharingGrantItem = lazyType(() => type({
     grant: "'allow' | 'deny'",
     appSlug: "string",
     ownerHandle: "string",
     dbName: "string",
-});
-export const userSettingShareing = type({
+}));
+export const userSettingShareing = lazyType(() => type({
     type: "'sharing'",
     grants: sharingGrantItem.array(),
-});
+}));
 export function isUserSettingSharing(obj) {
     return !(userSettingShareing(obj) instanceof type.errors);
 }
-export const userSettingModelDefaults = type({
+export const userSettingModelDefaults = lazyType(() => type({
     type: "'modelDefaults'",
     "codegen?": AIParams.partial(),
     "runtime?": AIParams.partial(),
     "img?": AIParams.partial(),
     "chat?": AIParams.partial(),
     "app?": AIParams.partial(),
-});
+}));
 export function isUserSettingModelDefaults(obj) {
     return !(userSettingModelDefaults(obj) instanceof type.errors);
 }
-export const userSettingDefaultHandle = type({
+export const userSettingDefaultHandle = lazyType(() => type({
     type: "'defaultHandle'",
     ownerHandle: "string",
-});
+}));
 export function isUserSettingDefaultHandle(obj) {
     return !(userSettingDefaultHandle(obj) instanceof type.errors);
 }
-export const userSettingProfile = type({
+export const userSettingProfile = lazyType(() => type({
     type: "'profile'",
     "avatarCid?": "string",
     "displayName?": "string",
-});
+}));
 export function isUserSettingProfile(obj) {
     return !(userSettingProfile(obj) instanceof type.errors);
 }
-export const userSettingNotifications = type({
+export const userSettingNotifications = lazyType(() => type({
     type: "'notifications'",
     "buildComplete?": "boolean",
     "buildFailed?": "boolean",
@@ -62,55 +63,55 @@ export const userSettingNotifications = type({
     "appMessage?": "boolean",
     "connectionExpiring?": "boolean",
     "emailInstant?": "boolean",
-});
+}));
 export function isUserSettingNotifications(obj) {
     return !(userSettingNotifications(obj) instanceof type.errors);
 }
-export const userSettingEgressStatus = type({
+export const userSettingEgressStatus = lazyType(() => type({
     type: "'egressStatus'",
     status: "'blessed' | 'blocked'",
     updatedAt: "string",
     "setBy?": "string",
-});
+}));
 export function isUserSettingEgressStatus(obj) {
     return !(userSettingEgressStatus(obj) instanceof type.errors);
 }
-export const userSettingContactEmail = type({
+export const userSettingContactEmail = lazyType(() => type({
     type: "'contactEmail'",
     email: "string",
     updatedAt: "string",
-});
+}));
 export function isUserSettingContactEmail(obj) {
     return !(userSettingContactEmail(obj) instanceof type.errors);
 }
-export const userSettingOnboarding = type({
+export const userSettingOnboarding = lazyType(() => type({
     type: "'onboarding'",
     completedAt: "string",
-});
+}));
 export function isUserSettingOnboarding(obj) {
     return !(userSettingOnboarding(obj) instanceof type.errors);
 }
-const userSettingLegacyDefaultHandle = type({
+const userSettingLegacyDefaultHandle = lazyType(() => type({
     type: "'defaultUserSlug'",
     userSlug: "string",
-}).pipe(({ userSlug }) => ({ type: "defaultHandle", ownerHandle: userSlug }));
-export const userSettingGeoCountry = type({
+}).pipe(({ userSlug }) => ({ type: "defaultHandle", ownerHandle: userSlug })));
+export const userSettingGeoCountry = lazyType(() => type({
     type: "'geoCountry'",
     country: "string",
     updatedAt: "string",
-});
+}));
 export function isUserSettingGeoCountry(obj) {
     return !(userSettingGeoCountry(obj) instanceof type.errors);
 }
-export const userSettingRetentionDrip = type({
+export const userSettingRetentionDrip = lazyType(() => type({
     type: "'retentionDrip'",
     sent: { "[string]": "string" },
     updatedAt: "string",
-});
+}));
 export function isUserSettingRetentionDrip(obj) {
     return !(userSettingRetentionDrip(obj) instanceof type.errors);
 }
-export const userSettingItem = userSettingShareing
+export const userSettingItem = lazyType(() => userSettingShareing
     .or(userSettingModelDefaults)
     .or(userSettingDefaultHandle)
     .or(userSettingLegacyDefaultHandle)
@@ -120,202 +121,202 @@ export const userSettingItem = userSettingShareing
     .or(userSettingContactEmail)
     .or(userSettingGeoCountry)
     .or(userSettingRetentionDrip)
-    .or(userSettingOnboarding);
-export const reqEnsureUserSettings = type({
+    .or(userSettingOnboarding));
+export const reqEnsureUserSettings = lazyType(() => type({
     type: "'vibes.diy.req-ensure-user-settings'",
     auth: dashAuthType,
     settings: userSettingItem.array(),
-});
-export const resEnsureUserSettings = type({
+}));
+export const resEnsureUserSettings = lazyType(() => type({
     type: "'vibes.diy.res-ensure-user-settings'",
     userId: "string",
     settings: userSettingItem.array(),
     updated: "string",
     created: "string",
-});
+}));
 export function isResEnsureUserSettings(obj) {
     return !(resEnsureUserSettings(obj) instanceof type.errors);
 }
-export const reqSetEgressStatus = type({
+export const reqSetEgressStatus = lazyType(() => type({
     type: "'vibes.diy.req-set-egress-status'",
     auth: dashAuthType,
     ownerHandle: "string",
     status: "'default' | 'blessed' | 'blocked'",
-});
-export const resSetEgressStatus = type({
+}));
+export const resSetEgressStatus = lazyType(() => type({
     type: "'vibes.diy.res-set-egress-status'",
     ownerHandle: "string",
     status: "'default' | 'blessed' | 'blocked'",
     updated: "string",
-});
+}));
 export function isResSetEgressStatus(obj) {
     return !(resSetEgressStatus(obj) instanceof type.errors);
 }
-export const reqEnsureHandleAvatar = type({
+export const reqEnsureHandleAvatar = lazyType(() => type({
     type: "'vibes.diy.req-ensure-handle-avatar'",
     auth: dashAuthType,
     handle: "string",
     cid: "string",
     "mime?": "string",
-});
+}));
 export function isReqEnsureHandleAvatar(obj) {
     return !(reqEnsureHandleAvatar(obj) instanceof type.errors);
 }
-export const resEnsureHandleAvatar = type({
+export const resEnsureHandleAvatar = lazyType(() => type({
     type: "'vibes.diy.res-ensure-handle-avatar'",
     handle: "string",
     getURL: "string",
     mime: "string",
     updated: "string",
-});
+}));
 export function isResEnsureHandleAvatar(obj) {
     return !(resEnsureHandleAvatar(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsBase = type({
+export const reqEnsureAppSettingsBase = lazyType(() => type({
     type: "'vibes.diy.req-ensure-app-settings'",
     "auth?": dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
-});
+}));
 export function isReqEnsureAppSettingsBase(obj) {
     return !(reqEnsureAppSettingsBase(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsAcl = type({
+export const reqEnsureAppSettingsAcl = lazyType(() => type({
     aclEntry: type({
         entry: ActiveACL,
         op: "'delete' | 'upsert'",
     }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsAcl(obj) {
     return !(reqEnsureAppSettingsAcl(obj) instanceof type.errors);
 }
-export const reqPublicAccess = type({
+export const reqPublicAccess = lazyType(() => type({
     publicAccess: {
         enable: "boolean",
     },
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqPublicAccess(obj) {
     return !(reqPublicAccess(obj) instanceof type.errors);
 }
-export const reqRequest = type({
+export const reqRequest = lazyType(() => type({
     request: {
         enable: "boolean",
         "autoAcceptRole?": Role,
     },
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqRequest(obj) {
     return !(reqRequest(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsTitle = type({
+export const reqEnsureAppSettingsTitle = lazyType(() => type({
     title: "string",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsTitle(obj) {
     return !(reqEnsureAppSettingsTitle(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsSkills = type({
+export const reqEnsureAppSettingsSkills = lazyType(() => type({
     skills: type("string").array(),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsSkills(obj) {
     return !(reqEnsureAppSettingsSkills(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsTheme = type({
+export const reqEnsureAppSettingsTheme = lazyType(() => type({
     theme: "string",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsTheme(obj) {
     return !(reqEnsureAppSettingsTheme(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsColorTheme = type({
+export const reqEnsureAppSettingsColorTheme = lazyType(() => type({
     colorTheme: "string | null",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsColorTheme(obj) {
     return !(reqEnsureAppSettingsColorTheme(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsStyle = type({
+export const reqEnsureAppSettingsStyle = lazyType(() => type({
     style: Style.or("null"),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsStyle(obj) {
     return !(reqEnsureAppSettingsStyle(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsDraftStyle = type({
+export const reqEnsureAppSettingsDraftStyle = lazyType(() => type({
     draftStyle: Style.or("null"),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsDraftStyle(obj) {
     return !(reqEnsureAppSettingsDraftStyle(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsStylePublish = type({
+export const reqEnsureAppSettingsStylePublish = lazyType(() => type({
     stylePublish: "true",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsStylePublish(obj) {
     return !(reqEnsureAppSettingsStylePublish(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsIconDescription = type({
+export const reqEnsureAppSettingsIconDescription = lazyType(() => type({
     iconDescription: "string",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsIconDescription(obj) {
     return !(reqEnsureAppSettingsIconDescription(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsIconRegen = type({
+export const reqEnsureAppSettingsIconRegen = lazyType(() => type({
     iconRegen: "true",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsIconRegen(obj) {
     return !(reqEnsureAppSettingsIconRegen(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsRuntime = type({
+export const reqEnsureAppSettingsRuntime = lazyType(() => type({
     runtime: AIParams.partial().or("null"),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsRuntime(obj) {
     return !(reqEnsureAppSettingsRuntime(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsCodegen = type({
+export const reqEnsureAppSettingsCodegen = lazyType(() => type({
     codegen: AIParams.partial().or("null"),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsCodegen(obj) {
     return !(reqEnsureAppSettingsCodegen(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsImg = type({
+export const reqEnsureAppSettingsImg = lazyType(() => type({
     img: AIParams.partial().or("null"),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsImg(obj) {
     return !(reqEnsureAppSettingsImg(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsEnv = type({
+export const reqEnsureAppSettingsEnv = lazyType(() => type({
     env: KVString.array(),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsEnv(obj) {
     return !(reqEnsureAppSettingsEnv(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsSecretSet = type({
+export const reqEnsureAppSettingsSecretSet = lazyType(() => type({
     secretSet: type({ key: "string", value: "string" }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsSecretSet(obj) {
     return !(reqEnsureAppSettingsSecretSet(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsSecretRemove = type({
+export const reqEnsureAppSettingsSecretRemove = lazyType(() => type({
     secretRemove: type({ key: "string" }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsSecretRemove(obj) {
     return !(reqEnsureAppSettingsSecretRemove(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsDbAcl = type({
+export const reqEnsureAppSettingsDbAcl = lazyType(() => type({
     dbAcl: type({
         dbName: "string",
         acl: dbAcl,
     }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsDbAcl(obj) {
     return !(reqEnsureAppSettingsDbAcl(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsCachedSuggestion = type({
+export const reqEnsureAppSettingsCachedSuggestion = lazyType(() => type({
     cachedSuggestion: type({
         key: "string",
         fsId: "string",
         sourceFsId: "string",
     }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsCachedSuggestion(obj) {
     return !(reqEnsureAppSettingsCachedSuggestion(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsCachedSuggestionBless = type({
+export const reqEnsureAppSettingsCachedSuggestionBless = lazyType(() => type({
     cachedSuggestionBless: type({
         key: "string",
         "fsId?": "string",
@@ -324,52 +325,52 @@ export const reqEnsureAppSettingsCachedSuggestionBless = type({
         "targetAppSlug?": "string",
         op: "'bless' | 'revoke'",
     }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsCachedSuggestionBless(obj) {
     return !(reqEnsureAppSettingsCachedSuggestionBless(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsRecommendedAdd = type({
+export const reqEnsureAppSettingsRecommendedAdd = lazyType(() => type({
     recommendedAdd: type({ ownerHandle: "string", appSlug: "string" }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsRecommendedAdd(obj) {
     return !(reqEnsureAppSettingsRecommendedAdd(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsRecommendedRemove = type({
+export const reqEnsureAppSettingsRecommendedRemove = lazyType(() => type({
     recommendedRemove: type({ id: "string" }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsRecommendedRemove(obj) {
     return !(reqEnsureAppSettingsRecommendedRemove(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsRecommendedMask = type({
+export const reqEnsureAppSettingsRecommendedMask = lazyType(() => type({
     recommendedMask: type({ ownerHandle: "string", appSlug: "string", op: "'mask' | 'unmask'" }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsRecommendedMask(obj) {
     return !(reqEnsureAppSettingsRecommendedMask(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsDbAclRemove = type({
+export const reqEnsureAppSettingsDbAclRemove = lazyType(() => type({
     dbAclRemove: type({
         dbName: "string",
     }),
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsDbAclRemove(obj) {
     return !(reqEnsureAppSettingsDbAclRemove(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsPrivacySensitive = type({
+export const reqEnsureAppSettingsPrivacySensitive = lazyType(() => type({
     privacySensitive: "boolean",
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsPrivacySensitive(obj) {
     return !(reqEnsureAppSettingsPrivacySensitive(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsAnonWrite = type({
+export const reqEnsureAppSettingsAnonWrite = lazyType(() => type({
     anonWrite: anonWriteMode,
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsAnonWrite(obj) {
     return !(reqEnsureAppSettingsAnonWrite(obj) instanceof type.errors);
 }
-export const reqEnsureAppSettingsPosture = type({
+export const reqEnsureAppSettingsPosture = lazyType(() => type({
     posture: postureIntent,
     "anonWrite?": anonWriteMode,
-}).and(reqEnsureAppSettingsBase);
+}).and(reqEnsureAppSettingsBase));
 export function isReqEnsureAppSettingsPosture(obj) {
     return !(reqEnsureAppSettingsPosture(obj) instanceof type.errors);
 }
@@ -401,7 +402,7 @@ export function isReqEnsureAppSettings(obj) {
         isReqEnsureAppSettingsPosture(obj) ||
         isReqEnsureAppSettingsBase(obj));
 }
-export const AppSettings = type({
+export const AppSettings = lazyType(() => type({
     entries: ActiveEntry.array(),
     entry: type({
         settings: {
@@ -428,21 +429,21 @@ export const AppSettings = type({
         "cachedSuggestions?": type({ "[string]": cachedSuggestionRecord }),
         "cachedSuggestionBlesses?": type({ "[string]": cachedSuggestionBlessRecord }),
     }),
-});
-export const dbEnvelopeRow = type({
+}));
+export const dbEnvelopeRow = lazyType(() => type({
     dbName: "string",
     provenance: "'platform-default' | 'your-pin'",
     "stored?": dbAcl,
     effective: dbAcl,
     absorbed: "boolean",
-});
-export const appEnvelopeReadout = type({
+}));
+export const appEnvelopeReadout = lazyType(() => type({
     posture: dbPosture,
     anonWrite: anonWriteMode,
     wildcard: dbAcl,
     dbs: dbEnvelopeRow.array(),
-});
-export const resEnsureAppSettings = type({
+}));
+export const resEnsureAppSettings = lazyType(() => type({
     type: "'vibes.diy.res-ensure-app-settings'",
     userId: "string",
     appSlug: "string",
@@ -454,11 +455,11 @@ export const resEnsureAppSettings = type({
     "envelope?": appEnvelopeReadout,
     updated: "string",
     created: "string",
-});
+}));
 export function isResEnsureAppSettings(obj) {
     return !(resEnsureAppSettings(obj) instanceof type.errors);
 }
-export const reqListApplicationChats = type({
+export const reqListApplicationChats = lazyType(() => type({
     type: "'vibes.diy.req-list-application-chats'",
     auth: dashAuthType,
     "appSlug?": "string",
@@ -466,62 +467,62 @@ export const reqListApplicationChats = type({
     "limit?": "number",
     "cursor?": "string",
     "asHandle?": "string",
-});
-export const resListApplicationChatsItem = type({
+}));
+export const resListApplicationChatsItem = lazyType(() => type({
     chatId: "string",
     appSlug: "string",
     ownerHandle: "string",
     created: "string",
     "userHandle?": "string",
-});
-export const resListApplicationChats = type({
+}));
+export const resListApplicationChats = lazyType(() => type({
     type: "'vibes.diy.res-list-application-chats'",
     items: resListApplicationChatsItem.array(),
     "nextCursor?": "string",
-});
+}));
 export function isResListApplicationChats(obj) {
     return !(resListApplicationChats(obj) instanceof type.errors);
 }
-export const reqListCodegenChats = type({
+export const reqListCodegenChats = lazyType(() => type({
     type: "'vibes.diy.req-list-codegen-chats'",
     auth: dashAuthType,
     "appSlug?": "string",
     "ownerHandle?": "string",
     "limit?": "number",
     "cursor?": "string",
-});
-export const resListCodegenChatsItem = type({
+}));
+export const resListCodegenChatsItem = lazyType(() => type({
     chatId: "string",
     appSlug: "string",
     ownerHandle: "string",
     created: "string",
-});
-export const resListCodegenChats = type({
+}));
+export const resListCodegenChats = lazyType(() => type({
     type: "'vibes.diy.res-list-codegen-chats'",
     items: resListCodegenChatsItem.array(),
     "nextCursor?": "string",
-});
+}));
 export function isResListCodegenChats(obj) {
     return !(resListCodegenChats(obj) instanceof type.errors);
 }
-export const evtAppSetting = type({
+export const evtAppSetting = lazyType(() => type({
     type: "'vibes.diy.evt-app-setting'",
     ownerHandle: "string",
     appSlug: "string",
     settings: ActiveEntry.array(),
-});
+}));
 export function isEvtAppSetting(obj) {
     return !(evtAppSetting(obj) instanceof type.errors);
 }
-export const evtBackendArm = type({
+export const evtBackendArm = lazyType(() => type({
     type: "'vibes.diy.evt-backend-arm'",
     ownerHandle: "string",
     appSlug: "string",
-});
+}));
 export function isEvtBackendArm(obj) {
     return !(evtBackendArm(obj) instanceof type.errors);
 }
-export const evtBackendOnChange = type({
+export const evtBackendOnChange = lazyType(() => type({
     type: "'vibes.diy.evt-backend-onChange'",
     ownerHandle: "string",
     appSlug: "string",
@@ -533,36 +534,36 @@ export const evtBackendOnChange = type({
     "oldDoc?": "unknown | null",
     depth: "number",
     "writerUserId?": "string | null",
-});
+}));
 export function isEvtBackendOnChange(obj) {
     return !(evtBackendOnChange(obj) instanceof type.errors);
 }
-export const reqRetentionPreview = type({
+export const reqRetentionPreview = lazyType(() => type({
     type: "'vibes.diy.req-retention-preview'",
     auth: dashAuthType,
     step: "string",
     "userId?": "string",
-});
-export const resRetentionPreview = type({
+}));
+export const resRetentionPreview = lazyType(() => type({
     type: "'vibes.diy.res-retention-preview'",
     userId: "string",
     step: "string",
     enqueued: "boolean",
-});
+}));
 export function isResRetentionPreview(obj) {
     return !(resRetentionPreview(obj) instanceof type.errors);
 }
-export const reqRetentionResetClaim = type({
+export const reqRetentionResetClaim = lazyType(() => type({
     type: "'vibes.diy.req-retention-reset-claim'",
     auth: dashAuthType,
     userId: "string",
     "step?": "string",
-});
-export const resRetentionResetClaim = type({
+}));
+export const resRetentionResetClaim = lazyType(() => type({
     type: "'vibes.diy.res-retention-reset-claim'",
     userId: "string",
     cleared: "string[]",
-});
+}));
 export function isResRetentionResetClaim(obj) {
     return !(resRetentionResetClaim(obj) instanceof type.errors);
 }