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

package/src/client/types/tools/ozone/moderation/defs.ts

@@ -3,15 +3,21 @@
  */
 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 ComAtprotoAdminDefs from '../../../com/atproto/admin/defs'
-import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
-import * as ChatBskyConvoDefs from '../../../chat/bsky/convo/defs'
-import * as ComAtprotoModerationDefs from '../../../com/atproto/moderation/defs'
-import * as ComAtprotoServerDefs from '../../../com/atproto/server/defs'
-import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoAdminDefs from '../../../com/atproto/admin/defs'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
+import type * as ChatBskyConvoDefs from '../../../chat/bsky/convo/defs'
+import type * as ComAtprotoModerationDefs from '../../../com/atproto/moderation/defs'
+import type * as ComAtprotoServerDefs from '../../../com/atproto/server/defs'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'tools.ozone.moderation.defs'
 
 export interface ModEventView {
@@ -49,19 +55,18 @@ export interface ModEventView {
   subjectHandle?: string
 }
 
+const hashModEventView = 'modEventView'
+
 export function isModEventView<V>(v: V) {
-  return is$typed(v, id, 'modEventView')
+  return is$typed(v, id, hashModEventView)
 }
 
-export function validateModEventView(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventView`,
-    v,
-  ) as ValidationResult<ModEventView>
+export function validateModEventView<V>(v: V) {
+  return validate<ModEventView & V>(v, id, hashModEventView)
 }
 
-export function isValidModEventView<V>(v: V): v is V & $Typed<ModEventView> {
-  return isModEventView(v) && validateModEventView(v).success
+export function isValidModEventView<V>(v: V) {
+  return isValid<ModEventView>(v, id, hashModEventView)
 }
 
 export interface ModEventViewDetail {
@@ -98,21 +103,18 @@ export interface ModEventViewDetail {
   createdAt: string
 }
 
+const hashModEventViewDetail = 'modEventViewDetail'
+
 export function isModEventViewDetail<V>(v: V) {
-  return is$typed(v, id, 'modEventViewDetail')
+  return is$typed(v, id, hashModEventViewDetail)
 }
 
-export function validateModEventViewDetail(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventViewDetail`,
-    v,
-  ) as ValidationResult<ModEventViewDetail>
+export function validateModEventViewDetail<V>(v: V) {
+  return validate<ModEventViewDetail & V>(v, id, hashModEventViewDetail)
 }
 
-export function isValidModEventViewDetail<V>(
-  v: V,
-): v is V & $Typed<ModEventViewDetail> {
-  return isModEventViewDetail(v) && validateModEventViewDetail(v).success
+export function isValidModEventViewDetail<V>(v: V) {
+  return isValid<ModEventViewDetail>(v, id, hashModEventViewDetail)
 }
 
 export interface SubjectStatusView {
@@ -146,21 +148,18 @@ export interface SubjectStatusView {
   tags?: string[]
 }
 
+const hashSubjectStatusView = 'subjectStatusView'
+
 export function isSubjectStatusView<V>(v: V) {
-  return is$typed(v, id, 'subjectStatusView')
+  return is$typed(v, id, hashSubjectStatusView)
 }
 
-export function validateSubjectStatusView(v: unknown) {
-  return lexicons.validate(
-    `${id}#subjectStatusView`,
-    v,
-  ) as ValidationResult<SubjectStatusView>
+export function validateSubjectStatusView<V>(v: V) {
+  return validate<SubjectStatusView & V>(v, id, hashSubjectStatusView)
 }
 
-export function isValidSubjectStatusView<V>(
-  v: V,
-): v is V & $Typed<SubjectStatusView> {
-  return isSubjectStatusView(v) && validateSubjectStatusView(v).success
+export function isValidSubjectStatusView<V>(v: V) {
+  return isValid<SubjectStatusView>(v, id, hashSubjectStatusView)
 }
 
 export type SubjectReviewState =
@@ -189,21 +188,18 @@ export interface ModEventTakedown {
   acknowledgeAccountSubjects?: boolean
 }
 
+const hashModEventTakedown = 'modEventTakedown'
+
 export function isModEventTakedown<V>(v: V) {
-  return is$typed(v, id, 'modEventTakedown')
+  return is$typed(v, id, hashModEventTakedown)
 }
 
-export function validateModEventTakedown(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventTakedown`,
-    v,
-  ) as ValidationResult<ModEventTakedown>
+export function validateModEventTakedown<V>(v: V) {
+  return validate<ModEventTakedown & V>(v, id, hashModEventTakedown)
 }
 
-export function isValidModEventTakedown<V>(
-  v: V,
-): v is V & $Typed<ModEventTakedown> {
-  return isModEventTakedown(v) && validateModEventTakedown(v).success
+export function isValidModEventTakedown<V>(v: V) {
+  return isValid<ModEventTakedown>(v, id, hashModEventTakedown)
 }
 
 /** Revert take down action on a subject */
@@ -213,23 +209,22 @@ export interface ModEventReverseTakedown {
   comment?: string
 }
 
+const hashModEventReverseTakedown = 'modEventReverseTakedown'
+
 export function isModEventReverseTakedown<V>(v: V) {
-  return is$typed(v, id, 'modEventReverseTakedown')
+  return is$typed(v, id, hashModEventReverseTakedown)
 }
 
-export function validateModEventReverseTakedown(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventReverseTakedown`,
+export function validateModEventReverseTakedown<V>(v: V) {
+  return validate<ModEventReverseTakedown & V>(
     v,
-  ) as ValidationResult<ModEventReverseTakedown>
+    id,
+    hashModEventReverseTakedown,
+  )
 }
 
-export function isValidModEventReverseTakedown<V>(
-  v: V,
-): v is V & $Typed<ModEventReverseTakedown> {
-  return (
-    isModEventReverseTakedown(v) && validateModEventReverseTakedown(v).success
-  )
+export function isValidModEventReverseTakedown<V>(v: V) {
+  return isValid<ModEventReverseTakedown>(v, id, hashModEventReverseTakedown)
 }
 
 /** Resolve appeal on a subject */
@@ -239,21 +234,18 @@ export interface ModEventResolveAppeal {
   comment?: string
 }
 
+const hashModEventResolveAppeal = 'modEventResolveAppeal'
+
 export function isModEventResolveAppeal<V>(v: V) {
-  return is$typed(v, id, 'modEventResolveAppeal')
+  return is$typed(v, id, hashModEventResolveAppeal)
 }
 
-export function validateModEventResolveAppeal(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventResolveAppeal`,
-    v,
-  ) as ValidationResult<ModEventResolveAppeal>
+export function validateModEventResolveAppeal<V>(v: V) {
+  return validate<ModEventResolveAppeal & V>(v, id, hashModEventResolveAppeal)
 }
 
-export function isValidModEventResolveAppeal<V>(
-  v: V,
-): v is V & $Typed<ModEventResolveAppeal> {
-  return isModEventResolveAppeal(v) && validateModEventResolveAppeal(v).success
+export function isValidModEventResolveAppeal<V>(v: V) {
+  return isValid<ModEventResolveAppeal>(v, id, hashModEventResolveAppeal)
 }
 
 /** Add a comment to a subject */
@@ -264,21 +256,18 @@ export interface ModEventComment {
   sticky?: boolean
 }
 
+const hashModEventComment = 'modEventComment'
+
 export function isModEventComment<V>(v: V) {
-  return is$typed(v, id, 'modEventComment')
+  return is$typed(v, id, hashModEventComment)
 }
 
-export function validateModEventComment(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventComment`,
-    v,
-  ) as ValidationResult<ModEventComment>
+export function validateModEventComment<V>(v: V) {
+  return validate<ModEventComment & V>(v, id, hashModEventComment)
 }
 
-export function isValidModEventComment<V>(
-  v: V,
-): v is V & $Typed<ModEventComment> {
-  return isModEventComment(v) && validateModEventComment(v).success
+export function isValidModEventComment<V>(v: V) {
+  return isValid<ModEventComment>(v, id, hashModEventComment)
 }
 
 /** Report a subject */
@@ -290,21 +279,18 @@ export interface ModEventReport {
   reportType: ComAtprotoModerationDefs.ReasonType
 }
 
+const hashModEventReport = 'modEventReport'
+
 export function isModEventReport<V>(v: V) {
-  return is$typed(v, id, 'modEventReport')
+  return is$typed(v, id, hashModEventReport)
 }
 
-export function validateModEventReport(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventReport`,
-    v,
-  ) as ValidationResult<ModEventReport>
+export function validateModEventReport<V>(v: V) {
+  return validate<ModEventReport & V>(v, id, hashModEventReport)
 }
 
-export function isValidModEventReport<V>(
-  v: V,
-): v is V & $Typed<ModEventReport> {
-  return isModEventReport(v) && validateModEventReport(v).success
+export function isValidModEventReport<V>(v: V) {
+  return isValid<ModEventReport>(v, id, hashModEventReport)
 }
 
 /** Apply/Negate labels on a subject */
@@ -315,19 +301,18 @@ export interface ModEventLabel {
   negateLabelVals: string[]
 }
 
+const hashModEventLabel = 'modEventLabel'
+
 export function isModEventLabel<V>(v: V) {
-  return is$typed(v, id, 'modEventLabel')
+  return is$typed(v, id, hashModEventLabel)
 }
 
-export function validateModEventLabel(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventLabel`,
-    v,
-  ) as ValidationResult<ModEventLabel>
+export function validateModEventLabel<V>(v: V) {
+  return validate<ModEventLabel & V>(v, id, hashModEventLabel)
 }
 
-export function isValidModEventLabel<V>(v: V): v is V & $Typed<ModEventLabel> {
-  return isModEventLabel(v) && validateModEventLabel(v).success
+export function isValidModEventLabel<V>(v: V) {
+  return isValid<ModEventLabel>(v, id, hashModEventLabel)
 }
 
 export interface ModEventAcknowledge {
@@ -337,21 +322,18 @@ export interface ModEventAcknowledge {
   acknowledgeAccountSubjects?: boolean
 }
 
+const hashModEventAcknowledge = 'modEventAcknowledge'
+
 export function isModEventAcknowledge<V>(v: V) {
-  return is$typed(v, id, 'modEventAcknowledge')
+  return is$typed(v, id, hashModEventAcknowledge)
 }
 
-export function validateModEventAcknowledge(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventAcknowledge`,
-    v,
-  ) as ValidationResult<ModEventAcknowledge>
+export function validateModEventAcknowledge<V>(v: V) {
+  return validate<ModEventAcknowledge & V>(v, id, hashModEventAcknowledge)
 }
 
-export function isValidModEventAcknowledge<V>(
-  v: V,
-): v is V & $Typed<ModEventAcknowledge> {
-  return isModEventAcknowledge(v) && validateModEventAcknowledge(v).success
+export function isValidModEventAcknowledge<V>(v: V) {
+  return isValid<ModEventAcknowledge>(v, id, hashModEventAcknowledge)
 }
 
 export interface ModEventEscalate {
@@ -359,21 +341,18 @@ export interface ModEventEscalate {
   comment?: string
 }
 
+const hashModEventEscalate = 'modEventEscalate'
+
 export function isModEventEscalate<V>(v: V) {
-  return is$typed(v, id, 'modEventEscalate')
+  return is$typed(v, id, hashModEventEscalate)
 }
 
-export function validateModEventEscalate(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventEscalate`,
-    v,
-  ) as ValidationResult<ModEventEscalate>
+export function validateModEventEscalate<V>(v: V) {
+  return validate<ModEventEscalate & V>(v, id, hashModEventEscalate)
 }
 
-export function isValidModEventEscalate<V>(
-  v: V,
-): v is V & $Typed<ModEventEscalate> {
-  return isModEventEscalate(v) && validateModEventEscalate(v).success
+export function isValidModEventEscalate<V>(v: V) {
+  return isValid<ModEventEscalate>(v, id, hashModEventEscalate)
 }
 
 /** Mute incoming reports on a subject */
@@ -384,19 +363,18 @@ export interface ModEventMute {
   durationInHours: number
 }
 
+const hashModEventMute = 'modEventMute'
+
 export function isModEventMute<V>(v: V) {
-  return is$typed(v, id, 'modEventMute')
+  return is$typed(v, id, hashModEventMute)
 }
 
-export function validateModEventMute(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventMute`,
-    v,
-  ) as ValidationResult<ModEventMute>
+export function validateModEventMute<V>(v: V) {
+  return validate<ModEventMute & V>(v, id, hashModEventMute)
 }
 
-export function isValidModEventMute<V>(v: V): v is V & $Typed<ModEventMute> {
-  return isModEventMute(v) && validateModEventMute(v).success
+export function isValidModEventMute<V>(v: V) {
+  return isValid<ModEventMute>(v, id, hashModEventMute)
 }
 
 /** Unmute action on a subject */
@@ -406,21 +384,18 @@ export interface ModEventUnmute {
   comment?: string
 }
 
+const hashModEventUnmute = 'modEventUnmute'
+
 export function isModEventUnmute<V>(v: V) {
-  return is$typed(v, id, 'modEventUnmute')
+  return is$typed(v, id, hashModEventUnmute)
 }
 
-export function validateModEventUnmute(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventUnmute`,
-    v,
-  ) as ValidationResult<ModEventUnmute>
+export function validateModEventUnmute<V>(v: V) {
+  return validate<ModEventUnmute & V>(v, id, hashModEventUnmute)
 }
 
-export function isValidModEventUnmute<V>(
-  v: V,
-): v is V & $Typed<ModEventUnmute> {
-  return isModEventUnmute(v) && validateModEventUnmute(v).success
+export function isValidModEventUnmute<V>(v: V) {
+  return isValid<ModEventUnmute>(v, id, hashModEventUnmute)
 }
 
 /** Mute incoming reports from an account */
@@ -431,21 +406,18 @@ export interface ModEventMuteReporter {
   durationInHours?: number
 }
 
+const hashModEventMuteReporter = 'modEventMuteReporter'
+
 export function isModEventMuteReporter<V>(v: V) {
-  return is$typed(v, id, 'modEventMuteReporter')
+  return is$typed(v, id, hashModEventMuteReporter)
 }
 
-export function validateModEventMuteReporter(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventMuteReporter`,
-    v,
-  ) as ValidationResult<ModEventMuteReporter>
+export function validateModEventMuteReporter<V>(v: V) {
+  return validate<ModEventMuteReporter & V>(v, id, hashModEventMuteReporter)
 }
 
-export function isValidModEventMuteReporter<V>(
-  v: V,
-): v is V & $Typed<ModEventMuteReporter> {
-  return isModEventMuteReporter(v) && validateModEventMuteReporter(v).success
+export function isValidModEventMuteReporter<V>(v: V) {
+  return isValid<ModEventMuteReporter>(v, id, hashModEventMuteReporter)
 }
 
 /** Unmute incoming reports from an account */
@@ -455,23 +427,18 @@ export interface ModEventUnmuteReporter {
   comment?: string
 }
 
+const hashModEventUnmuteReporter = 'modEventUnmuteReporter'
+
 export function isModEventUnmuteReporter<V>(v: V) {
-  return is$typed(v, id, 'modEventUnmuteReporter')
+  return is$typed(v, id, hashModEventUnmuteReporter)
 }
 
-export function validateModEventUnmuteReporter(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventUnmuteReporter`,
-    v,
-  ) as ValidationResult<ModEventUnmuteReporter>
+export function validateModEventUnmuteReporter<V>(v: V) {
+  return validate<ModEventUnmuteReporter & V>(v, id, hashModEventUnmuteReporter)
 }
 
-export function isValidModEventUnmuteReporter<V>(
-  v: V,
-): v is V & $Typed<ModEventUnmuteReporter> {
-  return (
-    isModEventUnmuteReporter(v) && validateModEventUnmuteReporter(v).success
-  )
+export function isValidModEventUnmuteReporter<V>(v: V) {
+  return isValid<ModEventUnmuteReporter>(v, id, hashModEventUnmuteReporter)
 }
 
 /** Keep a log of outgoing email to a user */
@@ -485,19 +452,18 @@ export interface ModEventEmail {
   comment?: string
 }
 
+const hashModEventEmail = 'modEventEmail'
+
 export function isModEventEmail<V>(v: V) {
-  return is$typed(v, id, 'modEventEmail')
+  return is$typed(v, id, hashModEventEmail)
 }
 
-export function validateModEventEmail(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventEmail`,
-    v,
-  ) as ValidationResult<ModEventEmail>
+export function validateModEventEmail<V>(v: V) {
+  return validate<ModEventEmail & V>(v, id, hashModEventEmail)
 }
 
-export function isValidModEventEmail<V>(v: V): v is V & $Typed<ModEventEmail> {
-  return isModEventEmail(v) && validateModEventEmail(v).success
+export function isValidModEventEmail<V>(v: V) {
+  return isValid<ModEventEmail>(v, id, hashModEventEmail)
 }
 
 /** Divert a record's blobs to a 3rd party service for further scanning/tagging */
@@ -506,21 +472,18 @@ export interface ModEventDivert {
   comment?: string
 }
 
+const hashModEventDivert = 'modEventDivert'
+
 export function isModEventDivert<V>(v: V) {
-  return is$typed(v, id, 'modEventDivert')
+  return is$typed(v, id, hashModEventDivert)
 }
 
-export function validateModEventDivert(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventDivert`,
-    v,
-  ) as ValidationResult<ModEventDivert>
+export function validateModEventDivert<V>(v: V) {
+  return validate<ModEventDivert & V>(v, id, hashModEventDivert)
 }
 
-export function isValidModEventDivert<V>(
-  v: V,
-): v is V & $Typed<ModEventDivert> {
-  return isModEventDivert(v) && validateModEventDivert(v).success
+export function isValidModEventDivert<V>(v: V) {
+  return isValid<ModEventDivert>(v, id, hashModEventDivert)
 }
 
 /** Add/Remove a tag on a subject */
@@ -534,19 +497,18 @@ export interface ModEventTag {
   comment?: string
 }
 
+const hashModEventTag = 'modEventTag'
+
 export function isModEventTag<V>(v: V) {
-  return is$typed(v, id, 'modEventTag')
+  return is$typed(v, id, hashModEventTag)
 }
 
-export function validateModEventTag(v: unknown) {
-  return lexicons.validate(
-    `${id}#modEventTag`,
-    v,
-  ) as ValidationResult<ModEventTag>
+export function validateModEventTag<V>(v: V) {
+  return validate<ModEventTag & V>(v, id, hashModEventTag)
 }
 
-export function isValidModEventTag<V>(v: V): v is V & $Typed<ModEventTag> {
-  return isModEventTag(v) && validateModEventTag(v).success
+export function isValidModEventTag<V>(v: V) {
+  return isValid<ModEventTag>(v, id, hashModEventTag)
 }
 
 /** Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
@@ -566,19 +528,18 @@ export interface AccountEvent {
   timestamp: string
 }
 
+const hashAccountEvent = 'accountEvent'
+
 export function isAccountEvent<V>(v: V) {
-  return is$typed(v, id, 'accountEvent')
+  return is$typed(v, id, hashAccountEvent)
 }
 
-export function validateAccountEvent(v: unknown) {
-  return lexicons.validate(
-    `${id}#accountEvent`,
-    v,
-  ) as ValidationResult<AccountEvent>
+export function validateAccountEvent<V>(v: V) {
+  return validate<AccountEvent & V>(v, id, hashAccountEvent)
 }
 
-export function isValidAccountEvent<V>(v: V): v is V & $Typed<AccountEvent> {
-  return isAccountEvent(v) && validateAccountEvent(v).success
+export function isValidAccountEvent<V>(v: V) {
+  return isValid<AccountEvent>(v, id, hashAccountEvent)
 }
 
 /** Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
@@ -591,19 +552,18 @@ export interface IdentityEvent {
   timestamp: string
 }
 
+const hashIdentityEvent = 'identityEvent'
+
 export function isIdentityEvent<V>(v: V) {
-  return is$typed(v, id, 'identityEvent')
+  return is$typed(v, id, hashIdentityEvent)
 }
 
-export function validateIdentityEvent(v: unknown) {
-  return lexicons.validate(
-    `${id}#identityEvent`,
-    v,
-  ) as ValidationResult<IdentityEvent>
+export function validateIdentityEvent<V>(v: V) {
+  return validate<IdentityEvent & V>(v, id, hashIdentityEvent)
 }
 
-export function isValidIdentityEvent<V>(v: V): v is V & $Typed<IdentityEvent> {
-  return isIdentityEvent(v) && validateIdentityEvent(v).success
+export function isValidIdentityEvent<V>(v: V) {
+  return isValid<IdentityEvent>(v, id, hashIdentityEvent)
 }
 
 /** Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
@@ -615,19 +575,18 @@ export interface RecordEvent {
   timestamp: string
 }
 
+const hashRecordEvent = 'recordEvent'
+
 export function isRecordEvent<V>(v: V) {
-  return is$typed(v, id, 'recordEvent')
+  return is$typed(v, id, hashRecordEvent)
 }
 
-export function validateRecordEvent(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordEvent`,
-    v,
-  ) as ValidationResult<RecordEvent>
+export function validateRecordEvent<V>(v: V) {
+  return validate<RecordEvent & V>(v, id, hashRecordEvent)
 }
 
-export function isValidRecordEvent<V>(v: V): v is V & $Typed<RecordEvent> {
-  return isRecordEvent(v) && validateRecordEvent(v).success
+export function isValidRecordEvent<V>(v: V) {
+  return isValid<RecordEvent>(v, id, hashRecordEvent)
 }
 
 export interface RepoView {
@@ -645,16 +604,18 @@ export interface RepoView {
   threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[]
 }
 
+const hashRepoView = 'repoView'
+
 export function isRepoView<V>(v: V) {
-  return is$typed(v, id, 'repoView')
+  return is$typed(v, id, hashRepoView)
 }
 
-export function validateRepoView(v: unknown) {
-  return lexicons.validate(`${id}#repoView`, v) as ValidationResult<RepoView>
+export function validateRepoView<V>(v: V) {
+  return validate<RepoView & V>(v, id, hashRepoView)
 }
 
-export function isValidRepoView<V>(v: V): v is V & $Typed<RepoView> {
-  return isRepoView(v) && validateRepoView(v).success
+export function isValidRepoView<V>(v: V) {
+  return isValid<RepoView>(v, id, hashRepoView)
 }
 
 export interface RepoViewDetail {
@@ -675,21 +636,18 @@ export interface RepoViewDetail {
   threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[]
 }
 
+const hashRepoViewDetail = 'repoViewDetail'
+
 export function isRepoViewDetail<V>(v: V) {
-  return is$typed(v, id, 'repoViewDetail')
+  return is$typed(v, id, hashRepoViewDetail)
 }
 
-export function validateRepoViewDetail(v: unknown) {
-  return lexicons.validate(
-    `${id}#repoViewDetail`,
-    v,
-  ) as ValidationResult<RepoViewDetail>
+export function validateRepoViewDetail<V>(v: V) {
+  return validate<RepoViewDetail & V>(v, id, hashRepoViewDetail)
 }
 
-export function isValidRepoViewDetail<V>(
-  v: V,
-): v is V & $Typed<RepoViewDetail> {
-  return isRepoViewDetail(v) && validateRepoViewDetail(v).success
+export function isValidRepoViewDetail<V>(v: V) {
+  return isValid<RepoViewDetail>(v, id, hashRepoViewDetail)
 }
 
 export interface RepoViewNotFound {
@@ -697,21 +655,18 @@ export interface RepoViewNotFound {
   did: string
 }
 
+const hashRepoViewNotFound = 'repoViewNotFound'
+
 export function isRepoViewNotFound<V>(v: V) {
-  return is$typed(v, id, 'repoViewNotFound')
+  return is$typed(v, id, hashRepoViewNotFound)
 }
 
-export function validateRepoViewNotFound(v: unknown) {
-  return lexicons.validate(
-    `${id}#repoViewNotFound`,
-    v,
-  ) as ValidationResult<RepoViewNotFound>
+export function validateRepoViewNotFound<V>(v: V) {
+  return validate<RepoViewNotFound & V>(v, id, hashRepoViewNotFound)
 }
 
-export function isValidRepoViewNotFound<V>(
-  v: V,
-): v is V & $Typed<RepoViewNotFound> {
-  return isRepoViewNotFound(v) && validateRepoViewNotFound(v).success
+export function isValidRepoViewNotFound<V>(v: V) {
+  return isValid<RepoViewNotFound>(v, id, hashRepoViewNotFound)
 }
 
 export interface RecordView {
@@ -725,19 +680,18 @@ export interface RecordView {
   repo: RepoView
 }
 
+const hashRecordView = 'recordView'
+
 export function isRecordView<V>(v: V) {
-  return is$typed(v, id, 'recordView')
+  return is$typed(v, id, hashRecordView)
 }
 
-export function validateRecordView(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordView`,
-    v,
-  ) as ValidationResult<RecordView>
+export function validateRecordView<V>(v: V) {
+  return validate<RecordView & V>(v, id, hashRecordView)
 }
 
-export function isValidRecordView<V>(v: V): v is V & $Typed<RecordView> {
-  return isRecordView(v) && validateRecordView(v).success
+export function isValidRecordView<V>(v: V) {
+  return isValid<RecordView>(v, id, hashRecordView)
 }
 
 export interface RecordViewDetail {
@@ -752,21 +706,18 @@ export interface RecordViewDetail {
   repo: RepoView
 }
 
+const hashRecordViewDetail = 'recordViewDetail'
+
 export function isRecordViewDetail<V>(v: V) {
-  return is$typed(v, id, 'recordViewDetail')
+  return is$typed(v, id, hashRecordViewDetail)
 }
 
-export function validateRecordViewDetail(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordViewDetail`,
-    v,
-  ) as ValidationResult<RecordViewDetail>
+export function validateRecordViewDetail<V>(v: V) {
+  return validate<RecordViewDetail & V>(v, id, hashRecordViewDetail)
 }
 
-export function isValidRecordViewDetail<V>(
-  v: V,
-): v is V & $Typed<RecordViewDetail> {
-  return isRecordViewDetail(v) && validateRecordViewDetail(v).success
+export function isValidRecordViewDetail<V>(v: V) {
+  return isValid<RecordViewDetail>(v, id, hashRecordViewDetail)
 }
 
 export interface RecordViewNotFound {
@@ -774,21 +725,18 @@ export interface RecordViewNotFound {
   uri: string
 }
 
+const hashRecordViewNotFound = 'recordViewNotFound'
+
 export function isRecordViewNotFound<V>(v: V) {
-  return is$typed(v, id, 'recordViewNotFound')
+  return is$typed(v, id, hashRecordViewNotFound)
 }
 
-export function validateRecordViewNotFound(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordViewNotFound`,
-    v,
-  ) as ValidationResult<RecordViewNotFound>
+export function validateRecordViewNotFound<V>(v: V) {
+  return validate<RecordViewNotFound & V>(v, id, hashRecordViewNotFound)
 }
 
-export function isValidRecordViewNotFound<V>(
-  v: V,
-): v is V & $Typed<RecordViewNotFound> {
-  return isRecordViewNotFound(v) && validateRecordViewNotFound(v).success
+export function isValidRecordViewNotFound<V>(v: V) {
+  return isValid<RecordViewNotFound>(v, id, hashRecordViewNotFound)
 }
 
 export interface Moderation {
@@ -796,19 +744,18 @@ export interface Moderation {
   subjectStatus?: SubjectStatusView
 }
 
+const hashModeration = 'moderation'
+
 export function isModeration<V>(v: V) {
-  return is$typed(v, id, 'moderation')
+  return is$typed(v, id, hashModeration)
 }
 
-export function validateModeration(v: unknown) {
-  return lexicons.validate(
-    `${id}#moderation`,
-    v,
-  ) as ValidationResult<Moderation>
+export function validateModeration<V>(v: V) {
+  return validate<Moderation & V>(v, id, hashModeration)
 }
 
-export function isValidModeration<V>(v: V): v is V & $Typed<Moderation> {
-  return isModeration(v) && validateModeration(v).success
+export function isValidModeration<V>(v: V) {
+  return isValid<Moderation>(v, id, hashModeration)
 }
 
 export interface ModerationDetail {
@@ -816,21 +763,18 @@ export interface ModerationDetail {
   subjectStatus?: SubjectStatusView
 }
 
+const hashModerationDetail = 'moderationDetail'
+
 export function isModerationDetail<V>(v: V) {
-  return is$typed(v, id, 'moderationDetail')
+  return is$typed(v, id, hashModerationDetail)
 }
 
-export function validateModerationDetail(v: unknown) {
-  return lexicons.validate(
-    `${id}#moderationDetail`,
-    v,
-  ) as ValidationResult<ModerationDetail>
+export function validateModerationDetail<V>(v: V) {
+  return validate<ModerationDetail & V>(v, id, hashModerationDetail)
 }
 
-export function isValidModerationDetail<V>(
-  v: V,
-): v is V & $Typed<ModerationDetail> {
-  return isModerationDetail(v) && validateModerationDetail(v).success
+export function isValidModerationDetail<V>(v: V) {
+  return isValid<ModerationDetail>(v, id, hashModerationDetail)
 }
 
 export interface BlobView {
@@ -843,16 +787,18 @@ export interface BlobView {
   moderation?: Moderation
 }
 
+const hashBlobView = 'blobView'
+
 export function isBlobView<V>(v: V) {
-  return is$typed(v, id, 'blobView')
+  return is$typed(v, id, hashBlobView)
 }
 
-export function validateBlobView(v: unknown) {
-  return lexicons.validate(`${id}#blobView`, v) as ValidationResult<BlobView>
+export function validateBlobView<V>(v: V) {
+  return validate<BlobView & V>(v, id, hashBlobView)
 }
 
-export function isValidBlobView<V>(v: V): v is V & $Typed<BlobView> {
-  return isBlobView(v) && validateBlobView(v).success
+export function isValidBlobView<V>(v: V) {
+  return isValid<BlobView>(v, id, hashBlobView)
 }
 
 export interface ImageDetails {
@@ -861,19 +807,18 @@ export interface ImageDetails {
   height: number
 }
 
+const hashImageDetails = 'imageDetails'
+
 export function isImageDetails<V>(v: V) {
-  return is$typed(v, id, 'imageDetails')
+  return is$typed(v, id, hashImageDetails)
 }
 
-export function validateImageDetails(v: unknown) {
-  return lexicons.validate(
-    `${id}#imageDetails`,
-    v,
-  ) as ValidationResult<ImageDetails>
+export function validateImageDetails<V>(v: V) {
+  return validate<ImageDetails & V>(v, id, hashImageDetails)
 }
 
-export function isValidImageDetails<V>(v: V): v is V & $Typed<ImageDetails> {
-  return isImageDetails(v) && validateImageDetails(v).success
+export function isValidImageDetails<V>(v: V) {
+  return isValid<ImageDetails>(v, id, hashImageDetails)
 }
 
 export interface VideoDetails {
@@ -883,19 +828,18 @@ export interface VideoDetails {
   length: number
 }
 
+const hashVideoDetails = 'videoDetails'
+
 export function isVideoDetails<V>(v: V) {
-  return is$typed(v, id, 'videoDetails')
+  return is$typed(v, id, hashVideoDetails)
 }
 
-export function validateVideoDetails(v: unknown) {
-  return lexicons.validate(
-    `${id}#videoDetails`,
-    v,
-  ) as ValidationResult<VideoDetails>
+export function validateVideoDetails<V>(v: V) {
+  return validate<VideoDetails & V>(v, id, hashVideoDetails)
 }
 
-export function isValidVideoDetails<V>(v: V): v is V & $Typed<VideoDetails> {
-  return isVideoDetails(v) && validateVideoDetails(v).success
+export function isValidVideoDetails<V>(v: V) {
+  return isValid<VideoDetails>(v, id, hashVideoDetails)
 }
 
 export interface AccountHosting {
@@ -914,21 +858,18 @@ export interface AccountHosting {
   reactivatedAt?: string
 }
 
+const hashAccountHosting = 'accountHosting'
+
 export function isAccountHosting<V>(v: V) {
-  return is$typed(v, id, 'accountHosting')
+  return is$typed(v, id, hashAccountHosting)
 }
 
-export function validateAccountHosting(v: unknown) {
-  return lexicons.validate(
-    `${id}#accountHosting`,
-    v,
-  ) as ValidationResult<AccountHosting>
+export function validateAccountHosting<V>(v: V) {
+  return validate<AccountHosting & V>(v, id, hashAccountHosting)
 }
 
-export function isValidAccountHosting<V>(
-  v: V,
-): v is V & $Typed<AccountHosting> {
-  return isAccountHosting(v) && validateAccountHosting(v).success
+export function isValidAccountHosting<V>(v: V) {
+  return isValid<AccountHosting>(v, id, hashAccountHosting)
 }
 
 export interface RecordHosting {
@@ -939,17 +880,16 @@ export interface RecordHosting {
   deletedAt?: string
 }
 
+const hashRecordHosting = 'recordHosting'
+
 export function isRecordHosting<V>(v: V) {
-  return is$typed(v, id, 'recordHosting')
+  return is$typed(v, id, hashRecordHosting)
 }
 
-export function validateRecordHosting(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordHosting`,
-    v,
-  ) as ValidationResult<RecordHosting>
+export function validateRecordHosting<V>(v: V) {
+  return validate<RecordHosting & V>(v, id, hashRecordHosting)
 }
 
-export function isValidRecordHosting<V>(v: V): v is V & $Typed<RecordHosting> {
-  return isRecordHosting(v) && validateRecordHosting(v).success
+export function isValidRecordHosting<V>(v: V) {
+  return isValid<RecordHosting>(v, id, hashRecordHosting)
 }