@atproto/api 0.14.0-next.0 → 0.14.0-next.2

package/src/client/types/app/bsky/actor/defs.ts

@@ -3,12 +3,18 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
-import * as AppBskyGraphDefs from '../graph/defs'
-import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+import type * as AppBskyGraphDefs from '../graph/defs'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'app.bsky.actor.defs'
 
 export interface ProfileViewBasic {
@@ -23,21 +29,18 @@ export interface ProfileViewBasic {
   createdAt?: string
 }
 
+const hashProfileViewBasic = 'profileViewBasic'
+
 export function isProfileViewBasic<V>(v: V) {
-  return is$typed(v, id, 'profileViewBasic')
+  return is$typed(v, id, hashProfileViewBasic)
 }
 
-export function validateProfileViewBasic(v: unknown) {
-  return lexicons.validate(
-    `${id}#profileViewBasic`,
-    v,
-  ) as ValidationResult<ProfileViewBasic>
+export function validateProfileViewBasic<V>(v: V) {
+  return validate<ProfileViewBasic & V>(v, id, hashProfileViewBasic)
 }
 
-export function isValidProfileViewBasic<V>(
-  v: V,
-): v is V & $Typed<ProfileViewBasic> {
-  return isProfileViewBasic(v) && validateProfileViewBasic(v).success
+export function isValidProfileViewBasic<V>(v: V) {
+  return isValid<ProfileViewBasic & V>(v, id, hashProfileViewBasic)
 }
 
 export interface ProfileView {
@@ -54,19 +57,18 @@ export interface ProfileView {
   labels?: ComAtprotoLabelDefs.Label[]
 }
 
+const hashProfileView = 'profileView'
+
 export function isProfileView<V>(v: V) {
-  return is$typed(v, id, 'profileView')
+  return is$typed(v, id, hashProfileView)
 }
 
-export function validateProfileView(v: unknown) {
-  return lexicons.validate(
-    `${id}#profileView`,
-    v,
-  ) as ValidationResult<ProfileView>
+export function validateProfileView<V>(v: V) {
+  return validate<ProfileView & V>(v, id, hashProfileView)
 }
 
-export function isValidProfileView<V>(v: V): v is V & $Typed<ProfileView> {
-  return isProfileView(v) && validateProfileView(v).success
+export function isValidProfileView<V>(v: V) {
+  return isValid<ProfileView & V>(v, id, hashProfileView)
 }
 
 export interface ProfileViewDetailed {
@@ -89,21 +91,18 @@ export interface ProfileViewDetailed {
   pinnedPost?: ComAtprotoRepoStrongRef.Main
 }
 
+const hashProfileViewDetailed = 'profileViewDetailed'
+
 export function isProfileViewDetailed<V>(v: V) {
-  return is$typed(v, id, 'profileViewDetailed')
+  return is$typed(v, id, hashProfileViewDetailed)
 }
 
-export function validateProfileViewDetailed(v: unknown) {
-  return lexicons.validate(
-    `${id}#profileViewDetailed`,
-    v,
-  ) as ValidationResult<ProfileViewDetailed>
+export function validateProfileViewDetailed<V>(v: V) {
+  return validate<ProfileViewDetailed & V>(v, id, hashProfileViewDetailed)
 }
 
-export function isValidProfileViewDetailed<V>(
-  v: V,
-): v is V & $Typed<ProfileViewDetailed> {
-  return isProfileViewDetailed(v) && validateProfileViewDetailed(v).success
+export function isValidProfileViewDetailed<V>(v: V) {
+  return isValid<ProfileViewDetailed & V>(v, id, hashProfileViewDetailed)
 }
 
 export interface ProfileAssociated {
@@ -115,21 +114,18 @@ export interface ProfileAssociated {
   chat?: ProfileAssociatedChat
 }
 
+const hashProfileAssociated = 'profileAssociated'
+
 export function isProfileAssociated<V>(v: V) {
-  return is$typed(v, id, 'profileAssociated')
+  return is$typed(v, id, hashProfileAssociated)
 }
 
-export function validateProfileAssociated(v: unknown) {
-  return lexicons.validate(
-    `${id}#profileAssociated`,
-    v,
-  ) as ValidationResult<ProfileAssociated>
+export function validateProfileAssociated<V>(v: V) {
+  return validate<ProfileAssociated & V>(v, id, hashProfileAssociated)
 }
 
-export function isValidProfileAssociated<V>(
-  v: V,
-): v is V & $Typed<ProfileAssociated> {
-  return isProfileAssociated(v) && validateProfileAssociated(v).success
+export function isValidProfileAssociated<V>(v: V) {
+  return isValid<ProfileAssociated & V>(v, id, hashProfileAssociated)
 }
 
 export interface ProfileAssociatedChat {
@@ -137,21 +133,18 @@ export interface ProfileAssociatedChat {
   allowIncoming: 'all' | 'none' | 'following' | (string & {})
 }
 
+const hashProfileAssociatedChat = 'profileAssociatedChat'
+
 export function isProfileAssociatedChat<V>(v: V) {
-  return is$typed(v, id, 'profileAssociatedChat')
+  return is$typed(v, id, hashProfileAssociatedChat)
 }
 
-export function validateProfileAssociatedChat(v: unknown) {
-  return lexicons.validate(
-    `${id}#profileAssociatedChat`,
-    v,
-  ) as ValidationResult<ProfileAssociatedChat>
+export function validateProfileAssociatedChat<V>(v: V) {
+  return validate<ProfileAssociatedChat & V>(v, id, hashProfileAssociatedChat)
 }
 
-export function isValidProfileAssociatedChat<V>(
-  v: V,
-): v is V & $Typed<ProfileAssociatedChat> {
-  return isProfileAssociatedChat(v) && validateProfileAssociatedChat(v).success
+export function isValidProfileAssociatedChat<V>(v: V) {
+  return isValid<ProfileAssociatedChat & V>(v, id, hashProfileAssociatedChat)
 }
 
 /** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. */
@@ -167,19 +160,18 @@ export interface ViewerState {
   knownFollowers?: KnownFollowers
 }
 
+const hashViewerState = 'viewerState'
+
 export function isViewerState<V>(v: V) {
-  return is$typed(v, id, 'viewerState')
+  return is$typed(v, id, hashViewerState)
 }
 
-export function validateViewerState(v: unknown) {
-  return lexicons.validate(
-    `${id}#viewerState`,
-    v,
-  ) as ValidationResult<ViewerState>
+export function validateViewerState<V>(v: V) {
+  return validate<ViewerState & V>(v, id, hashViewerState)
 }
 
-export function isValidViewerState<V>(v: V): v is V & $Typed<ViewerState> {
-  return isViewerState(v) && validateViewerState(v).success
+export function isValidViewerState<V>(v: V) {
+  return isValid<ViewerState & V>(v, id, hashViewerState)
 }
 
 /** The subject's followers whom you also follow */
@@ -189,21 +181,18 @@ export interface KnownFollowers {
   followers: ProfileViewBasic[]
 }
 
+const hashKnownFollowers = 'knownFollowers'
+
 export function isKnownFollowers<V>(v: V) {
-  return is$typed(v, id, 'knownFollowers')
+  return is$typed(v, id, hashKnownFollowers)
 }
 
-export function validateKnownFollowers(v: unknown) {
-  return lexicons.validate(
-    `${id}#knownFollowers`,
-    v,
-  ) as ValidationResult<KnownFollowers>
+export function validateKnownFollowers<V>(v: V) {
+  return validate<KnownFollowers & V>(v, id, hashKnownFollowers)
 }
 
-export function isValidKnownFollowers<V>(
-  v: V,
-): v is V & $Typed<KnownFollowers> {
-  return isKnownFollowers(v) && validateKnownFollowers(v).success
+export function isValidKnownFollowers<V>(v: V) {
+  return isValid<KnownFollowers & V>(v, id, hashKnownFollowers)
 }
 
 export type Preferences = (
@@ -227,21 +216,18 @@ export interface AdultContentPref {
   enabled: boolean
 }
 
+const hashAdultContentPref = 'adultContentPref'
+
 export function isAdultContentPref<V>(v: V) {
-  return is$typed(v, id, 'adultContentPref')
+  return is$typed(v, id, hashAdultContentPref)
 }
 
-export function validateAdultContentPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#adultContentPref`,
-    v,
-  ) as ValidationResult<AdultContentPref>
+export function validateAdultContentPref<V>(v: V) {
+  return validate<AdultContentPref & V>(v, id, hashAdultContentPref)
 }
 
-export function isValidAdultContentPref<V>(
-  v: V,
-): v is V & $Typed<AdultContentPref> {
-  return isAdultContentPref(v) && validateAdultContentPref(v).success
+export function isValidAdultContentPref<V>(v: V) {
+  return isValid<AdultContentPref & V>(v, id, hashAdultContentPref)
 }
 
 export interface ContentLabelPref {
@@ -252,21 +238,18 @@ export interface ContentLabelPref {
   visibility: 'ignore' | 'show' | 'warn' | 'hide' | (string & {})
 }
 
+const hashContentLabelPref = 'contentLabelPref'
+
 export function isContentLabelPref<V>(v: V) {
-  return is$typed(v, id, 'contentLabelPref')
+  return is$typed(v, id, hashContentLabelPref)
 }
 
-export function validateContentLabelPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#contentLabelPref`,
-    v,
-  ) as ValidationResult<ContentLabelPref>
+export function validateContentLabelPref<V>(v: V) {
+  return validate<ContentLabelPref & V>(v, id, hashContentLabelPref)
 }
 
-export function isValidContentLabelPref<V>(
-  v: V,
-): v is V & $Typed<ContentLabelPref> {
-  return isContentLabelPref(v) && validateContentLabelPref(v).success
+export function isValidContentLabelPref<V>(v: V) {
+  return isValid<ContentLabelPref & V>(v, id, hashContentLabelPref)
 }
 
 export interface SavedFeed {
@@ -277,16 +260,18 @@ export interface SavedFeed {
   pinned: boolean
 }
 
+const hashSavedFeed = 'savedFeed'
+
 export function isSavedFeed<V>(v: V) {
-  return is$typed(v, id, 'savedFeed')
+  return is$typed(v, id, hashSavedFeed)
 }
 
-export function validateSavedFeed(v: unknown) {
-  return lexicons.validate(`${id}#savedFeed`, v) as ValidationResult<SavedFeed>
+export function validateSavedFeed<V>(v: V) {
+  return validate<SavedFeed & V>(v, id, hashSavedFeed)
 }
 
-export function isValidSavedFeed<V>(v: V): v is V & $Typed<SavedFeed> {
-  return isSavedFeed(v) && validateSavedFeed(v).success
+export function isValidSavedFeed<V>(v: V) {
+  return isValid<SavedFeed & V>(v, id, hashSavedFeed)
 }
 
 export interface SavedFeedsPrefV2 {
@@ -294,21 +279,18 @@ export interface SavedFeedsPrefV2 {
   items: SavedFeed[]
 }
 
+const hashSavedFeedsPrefV2 = 'savedFeedsPrefV2'
+
 export function isSavedFeedsPrefV2<V>(v: V) {
-  return is$typed(v, id, 'savedFeedsPrefV2')
+  return is$typed(v, id, hashSavedFeedsPrefV2)
 }
 
-export function validateSavedFeedsPrefV2(v: unknown) {
-  return lexicons.validate(
-    `${id}#savedFeedsPrefV2`,
-    v,
-  ) as ValidationResult<SavedFeedsPrefV2>
+export function validateSavedFeedsPrefV2<V>(v: V) {
+  return validate<SavedFeedsPrefV2 & V>(v, id, hashSavedFeedsPrefV2)
 }
 
-export function isValidSavedFeedsPrefV2<V>(
-  v: V,
-): v is V & $Typed<SavedFeedsPrefV2> {
-  return isSavedFeedsPrefV2(v) && validateSavedFeedsPrefV2(v).success
+export function isValidSavedFeedsPrefV2<V>(v: V) {
+  return isValid<SavedFeedsPrefV2 & V>(v, id, hashSavedFeedsPrefV2)
 }
 
 export interface SavedFeedsPref {
@@ -318,21 +300,18 @@ export interface SavedFeedsPref {
   timelineIndex?: number
 }
 
+const hashSavedFeedsPref = 'savedFeedsPref'
+
 export function isSavedFeedsPref<V>(v: V) {
-  return is$typed(v, id, 'savedFeedsPref')
+  return is$typed(v, id, hashSavedFeedsPref)
 }
 
-export function validateSavedFeedsPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#savedFeedsPref`,
-    v,
-  ) as ValidationResult<SavedFeedsPref>
+export function validateSavedFeedsPref<V>(v: V) {
+  return validate<SavedFeedsPref & V>(v, id, hashSavedFeedsPref)
 }
 
-export function isValidSavedFeedsPref<V>(
-  v: V,
-): v is V & $Typed<SavedFeedsPref> {
-  return isSavedFeedsPref(v) && validateSavedFeedsPref(v).success
+export function isValidSavedFeedsPref<V>(v: V) {
+  return isValid<SavedFeedsPref & V>(v, id, hashSavedFeedsPref)
 }
 
 export interface PersonalDetailsPref {
@@ -341,21 +320,18 @@ export interface PersonalDetailsPref {
   birthDate?: string
 }
 
+const hashPersonalDetailsPref = 'personalDetailsPref'
+
 export function isPersonalDetailsPref<V>(v: V) {
-  return is$typed(v, id, 'personalDetailsPref')
+  return is$typed(v, id, hashPersonalDetailsPref)
 }
 
-export function validatePersonalDetailsPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#personalDetailsPref`,
-    v,
-  ) as ValidationResult<PersonalDetailsPref>
+export function validatePersonalDetailsPref<V>(v: V) {
+  return validate<PersonalDetailsPref & V>(v, id, hashPersonalDetailsPref)
 }
 
-export function isValidPersonalDetailsPref<V>(
-  v: V,
-): v is V & $Typed<PersonalDetailsPref> {
-  return isPersonalDetailsPref(v) && validatePersonalDetailsPref(v).success
+export function isValidPersonalDetailsPref<V>(v: V) {
+  return isValid<PersonalDetailsPref & V>(v, id, hashPersonalDetailsPref)
 }
 
 export interface FeedViewPref {
@@ -374,19 +350,18 @@ export interface FeedViewPref {
   hideQuotePosts?: boolean
 }
 
+const hashFeedViewPref = 'feedViewPref'
+
 export function isFeedViewPref<V>(v: V) {
-  return is$typed(v, id, 'feedViewPref')
+  return is$typed(v, id, hashFeedViewPref)
 }
 
-export function validateFeedViewPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#feedViewPref`,
-    v,
-  ) as ValidationResult<FeedViewPref>
+export function validateFeedViewPref<V>(v: V) {
+  return validate<FeedViewPref & V>(v, id, hashFeedViewPref)
 }
 
-export function isValidFeedViewPref<V>(v: V): v is V & $Typed<FeedViewPref> {
-  return isFeedViewPref(v) && validateFeedViewPref(v).success
+export function isValidFeedViewPref<V>(v: V) {
+  return isValid<FeedViewPref & V>(v, id, hashFeedViewPref)
 }
 
 export interface ThreadViewPref {
@@ -403,21 +378,18 @@ export interface ThreadViewPref {
   prioritizeFollowedUsers?: boolean
 }
 
+const hashThreadViewPref = 'threadViewPref'
+
 export function isThreadViewPref<V>(v: V) {
-  return is$typed(v, id, 'threadViewPref')
+  return is$typed(v, id, hashThreadViewPref)
 }
 
-export function validateThreadViewPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#threadViewPref`,
-    v,
-  ) as ValidationResult<ThreadViewPref>
+export function validateThreadViewPref<V>(v: V) {
+  return validate<ThreadViewPref & V>(v, id, hashThreadViewPref)
 }
 
-export function isValidThreadViewPref<V>(
-  v: V,
-): v is V & $Typed<ThreadViewPref> {
-  return isThreadViewPref(v) && validateThreadViewPref(v).success
+export function isValidThreadViewPref<V>(v: V) {
+  return isValid<ThreadViewPref & V>(v, id, hashThreadViewPref)
 }
 
 export interface InterestsPref {
@@ -426,19 +398,18 @@ export interface InterestsPref {
   tags: string[]
 }
 
+const hashInterestsPref = 'interestsPref'
+
 export function isInterestsPref<V>(v: V) {
-  return is$typed(v, id, 'interestsPref')
+  return is$typed(v, id, hashInterestsPref)
 }
 
-export function validateInterestsPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#interestsPref`,
-    v,
-  ) as ValidationResult<InterestsPref>
+export function validateInterestsPref<V>(v: V) {
+  return validate<InterestsPref & V>(v, id, hashInterestsPref)
 }
 
-export function isValidInterestsPref<V>(v: V): v is V & $Typed<InterestsPref> {
-  return isInterestsPref(v) && validateInterestsPref(v).success
+export function isValidInterestsPref<V>(v: V) {
+  return isValid<InterestsPref & V>(v, id, hashInterestsPref)
 }
 
 export type MutedWordTarget = 'content' | 'tag' | (string & {})
@@ -457,16 +428,18 @@ export interface MutedWord {
   expiresAt?: string
 }
 
+const hashMutedWord = 'mutedWord'
+
 export function isMutedWord<V>(v: V) {
-  return is$typed(v, id, 'mutedWord')
+  return is$typed(v, id, hashMutedWord)
 }
 
-export function validateMutedWord(v: unknown) {
-  return lexicons.validate(`${id}#mutedWord`, v) as ValidationResult<MutedWord>
+export function validateMutedWord<V>(v: V) {
+  return validate<MutedWord & V>(v, id, hashMutedWord)
 }
 
-export function isValidMutedWord<V>(v: V): v is V & $Typed<MutedWord> {
-  return isMutedWord(v) && validateMutedWord(v).success
+export function isValidMutedWord<V>(v: V) {
+  return isValid<MutedWord & V>(v, id, hashMutedWord)
 }
 
 export interface MutedWordsPref {
@@ -475,21 +448,18 @@ export interface MutedWordsPref {
   items: MutedWord[]
 }
 
+const hashMutedWordsPref = 'mutedWordsPref'
+
 export function isMutedWordsPref<V>(v: V) {
-  return is$typed(v, id, 'mutedWordsPref')
+  return is$typed(v, id, hashMutedWordsPref)
 }
 
-export function validateMutedWordsPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#mutedWordsPref`,
-    v,
-  ) as ValidationResult<MutedWordsPref>
+export function validateMutedWordsPref<V>(v: V) {
+  return validate<MutedWordsPref & V>(v, id, hashMutedWordsPref)
 }
 
-export function isValidMutedWordsPref<V>(
-  v: V,
-): v is V & $Typed<MutedWordsPref> {
-  return isMutedWordsPref(v) && validateMutedWordsPref(v).success
+export function isValidMutedWordsPref<V>(v: V) {
+  return isValid<MutedWordsPref & V>(v, id, hashMutedWordsPref)
 }
 
 export interface HiddenPostsPref {
@@ -498,21 +468,18 @@ export interface HiddenPostsPref {
   items: string[]
 }
 
+const hashHiddenPostsPref = 'hiddenPostsPref'
+
 export function isHiddenPostsPref<V>(v: V) {
-  return is$typed(v, id, 'hiddenPostsPref')
+  return is$typed(v, id, hashHiddenPostsPref)
 }
 
-export function validateHiddenPostsPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#hiddenPostsPref`,
-    v,
-  ) as ValidationResult<HiddenPostsPref>
+export function validateHiddenPostsPref<V>(v: V) {
+  return validate<HiddenPostsPref & V>(v, id, hashHiddenPostsPref)
 }
 
-export function isValidHiddenPostsPref<V>(
-  v: V,
-): v is V & $Typed<HiddenPostsPref> {
-  return isHiddenPostsPref(v) && validateHiddenPostsPref(v).success
+export function isValidHiddenPostsPref<V>(v: V) {
+  return isValid<HiddenPostsPref & V>(v, id, hashHiddenPostsPref)
 }
 
 export interface LabelersPref {
@@ -520,19 +487,18 @@ export interface LabelersPref {
   labelers: LabelerPrefItem[]
 }
 
+const hashLabelersPref = 'labelersPref'
+
 export function isLabelersPref<V>(v: V) {
-  return is$typed(v, id, 'labelersPref')
+  return is$typed(v, id, hashLabelersPref)
 }
 
-export function validateLabelersPref(v: unknown) {
-  return lexicons.validate(
-    `${id}#labelersPref`,
-    v,
-  ) as ValidationResult<LabelersPref>
+export function validateLabelersPref<V>(v: V) {
+  return validate<LabelersPref & V>(v, id, hashLabelersPref)
 }
 
-export function isValidLabelersPref<V>(v: V): v is V & $Typed<LabelersPref> {
-  return isLabelersPref(v) && validateLabelersPref(v).success
+export function isValidLabelersPref<V>(v: V) {
+  return isValid<LabelersPref & V>(v, id, hashLabelersPref)
 }
 
 export interface LabelerPrefItem {
@@ -540,21 +506,18 @@ export interface LabelerPrefItem {
   did: string
 }
 
+const hashLabelerPrefItem = 'labelerPrefItem'
+
 export function isLabelerPrefItem<V>(v: V) {
-  return is$typed(v, id, 'labelerPrefItem')
+  return is$typed(v, id, hashLabelerPrefItem)
 }
 
-export function validateLabelerPrefItem(v: unknown) {
-  return lexicons.validate(
-    `${id}#labelerPrefItem`,
-    v,
-  ) as ValidationResult<LabelerPrefItem>
+export function validateLabelerPrefItem<V>(v: V) {
+  return validate<LabelerPrefItem & V>(v, id, hashLabelerPrefItem)
 }
 
-export function isValidLabelerPrefItem<V>(
-  v: V,
-): v is V & $Typed<LabelerPrefItem> {
-  return isLabelerPrefItem(v) && validateLabelerPrefItem(v).success
+export function isValidLabelerPrefItem<V>(v: V) {
+  return isValid<LabelerPrefItem & V>(v, id, hashLabelerPrefItem)
 }
 
 /** A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this. */
@@ -567,21 +530,18 @@ export interface BskyAppStatePref {
   nuxs?: Nux[]
 }
 
+const hashBskyAppStatePref = 'bskyAppStatePref'
+
 export function isBskyAppStatePref<V>(v: V) {
-  return is$typed(v, id, 'bskyAppStatePref')
+  return is$typed(v, id, hashBskyAppStatePref)
 }
 
-export function validateBskyAppStatePref(v: unknown) {
-  return lexicons.validate(
-    `${id}#bskyAppStatePref`,
-    v,
-  ) as ValidationResult<BskyAppStatePref>
+export function validateBskyAppStatePref<V>(v: V) {
+  return validate<BskyAppStatePref & V>(v, id, hashBskyAppStatePref)
 }
 
-export function isValidBskyAppStatePref<V>(
-  v: V,
-): v is V & $Typed<BskyAppStatePref> {
-  return isBskyAppStatePref(v) && validateBskyAppStatePref(v).success
+export function isValidBskyAppStatePref<V>(v: V) {
+  return isValid<BskyAppStatePref & V>(v, id, hashBskyAppStatePref)
 }
 
 /** If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress. */
@@ -590,21 +550,18 @@ export interface BskyAppProgressGuide {
   guide: string
 }
 
+const hashBskyAppProgressGuide = 'bskyAppProgressGuide'
+
 export function isBskyAppProgressGuide<V>(v: V) {
-  return is$typed(v, id, 'bskyAppProgressGuide')
+  return is$typed(v, id, hashBskyAppProgressGuide)
 }
 
-export function validateBskyAppProgressGuide(v: unknown) {
-  return lexicons.validate(
-    `${id}#bskyAppProgressGuide`,
-    v,
-  ) as ValidationResult<BskyAppProgressGuide>
+export function validateBskyAppProgressGuide<V>(v: V) {
+  return validate<BskyAppProgressGuide & V>(v, id, hashBskyAppProgressGuide)
 }
 
-export function isValidBskyAppProgressGuide<V>(
-  v: V,
-): v is V & $Typed<BskyAppProgressGuide> {
-  return isBskyAppProgressGuide(v) && validateBskyAppProgressGuide(v).success
+export function isValidBskyAppProgressGuide<V>(v: V) {
+  return isValid<BskyAppProgressGuide & V>(v, id, hashBskyAppProgressGuide)
 }
 
 /** A new user experiences (NUX) storage object */
@@ -618,14 +575,16 @@ export interface Nux {
   expiresAt?: string
 }
 
+const hashNux = 'nux'
+
 export function isNux<V>(v: V) {
-  return is$typed(v, id, 'nux')
+  return is$typed(v, id, hashNux)
 }
 
-export function validateNux(v: unknown) {
-  return lexicons.validate(`${id}#nux`, v) as ValidationResult<Nux>
+export function validateNux<V>(v: V) {
+  return validate<Nux & V>(v, id, hashNux)
 }
 
-export function isValidNux<V>(v: V): v is V & $Typed<Nux> {
-  return isNux(v) && validateNux(v).success
+export function isValidNux<V>(v: V) {
+  return isValid<Nux & V>(v, id, hashNux)
 }