@atproto/api 0.13.20 → 0.14.0-next.0

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

@@ -2,9 +2,9 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 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'
@@ -12,109 +12,117 @@ import * as ComAtprotoModerationDefs from '../../../com/atproto/moderation/defs'
 import * as ComAtprotoServerDefs from '../../../com/atproto/server/defs'
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 
+const id = 'tools.ozone.moderation.defs'
+
 export interface ModEventView {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventView'>
   id: number
   event:
-    | ModEventTakedown
-    | ModEventReverseTakedown
-    | ModEventComment
-    | ModEventReport
-    | ModEventLabel
-    | ModEventAcknowledge
-    | ModEventEscalate
-    | ModEventMute
-    | ModEventUnmute
-    | ModEventMuteReporter
-    | ModEventUnmuteReporter
-    | ModEventEmail
-    | ModEventResolveAppeal
-    | ModEventDivert
-    | ModEventTag
-    | AccountEvent
-    | IdentityEvent
-    | RecordEvent
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ModEventTakedown>
+    | $Typed<ModEventReverseTakedown>
+    | $Typed<ModEventComment>
+    | $Typed<ModEventReport>
+    | $Typed<ModEventLabel>
+    | $Typed<ModEventAcknowledge>
+    | $Typed<ModEventEscalate>
+    | $Typed<ModEventMute>
+    | $Typed<ModEventUnmute>
+    | $Typed<ModEventMuteReporter>
+    | $Typed<ModEventUnmuteReporter>
+    | $Typed<ModEventEmail>
+    | $Typed<ModEventResolveAppeal>
+    | $Typed<ModEventDivert>
+    | $Typed<ModEventTag>
+    | $Typed<AccountEvent>
+    | $Typed<IdentityEvent>
+    | $Typed<RecordEvent>
+    | { $type: string }
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | ChatBskyConvoDefs.MessageRef
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | $Typed<ChatBskyConvoDefs.MessageRef>
+    | { $type: string }
   subjectBlobCids: string[]
   createdBy: string
   createdAt: string
   creatorHandle?: string
   subjectHandle?: string
-  [k: string]: unknown
 }
 
-export function isModEventView(v: unknown): v is ModEventView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventView'
-  )
+export function isModEventView<V>(v: V) {
+  return is$typed(v, id, 'modEventView')
 }
 
-export function validateModEventView(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventView', v)
+export function validateModEventView(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventView`,
+    v,
+  ) as ValidationResult<ModEventView>
+}
+
+export function isValidModEventView<V>(v: V): v is V & $Typed<ModEventView> {
+  return isModEventView(v) && validateModEventView(v).success
 }
 
 export interface ModEventViewDetail {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventViewDetail'>
   id: number
   event:
-    | ModEventTakedown
-    | ModEventReverseTakedown
-    | ModEventComment
-    | ModEventReport
-    | ModEventLabel
-    | ModEventAcknowledge
-    | ModEventEscalate
-    | ModEventMute
-    | ModEventUnmute
-    | ModEventMuteReporter
-    | ModEventUnmuteReporter
-    | ModEventEmail
-    | ModEventResolveAppeal
-    | ModEventDivert
-    | ModEventTag
-    | AccountEvent
-    | IdentityEvent
-    | RecordEvent
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ModEventTakedown>
+    | $Typed<ModEventReverseTakedown>
+    | $Typed<ModEventComment>
+    | $Typed<ModEventReport>
+    | $Typed<ModEventLabel>
+    | $Typed<ModEventAcknowledge>
+    | $Typed<ModEventEscalate>
+    | $Typed<ModEventMute>
+    | $Typed<ModEventUnmute>
+    | $Typed<ModEventMuteReporter>
+    | $Typed<ModEventUnmuteReporter>
+    | $Typed<ModEventEmail>
+    | $Typed<ModEventResolveAppeal>
+    | $Typed<ModEventDivert>
+    | $Typed<ModEventTag>
+    | $Typed<AccountEvent>
+    | $Typed<IdentityEvent>
+    | $Typed<RecordEvent>
+    | { $type: string }
   subject:
-    | RepoView
-    | RepoViewNotFound
-    | RecordView
-    | RecordViewNotFound
-    | { $type: string; [k: string]: unknown }
+    | $Typed<RepoView>
+    | $Typed<RepoViewNotFound>
+    | $Typed<RecordView>
+    | $Typed<RecordViewNotFound>
+    | { $type: string }
   subjectBlobs: BlobView[]
   createdBy: string
   createdAt: string
-  [k: string]: unknown
 }
 
-export function isModEventViewDetail(v: unknown): v is ModEventViewDetail {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventViewDetail'
-  )
+export function isModEventViewDetail<V>(v: V) {
+  return is$typed(v, id, 'modEventViewDetail')
 }
 
-export function validateModEventViewDetail(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventViewDetail', v)
+export function validateModEventViewDetail(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventViewDetail`,
+    v,
+  ) as ValidationResult<ModEventViewDetail>
+}
+
+export function isValidModEventViewDetail<V>(
+  v: V,
+): v is V & $Typed<ModEventViewDetail> {
+  return isModEventViewDetail(v) && validateModEventViewDetail(v).success
 }
 
 export interface SubjectStatusView {
+  $type?: $Type<'tools.ozone.moderation.defs', 'subjectStatusView'>
   id: number
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | { $type: string; [k: string]: unknown }
-  hosting?:
-    | AccountHosting
-    | RecordHosting
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
+  hosting?: $Typed<AccountHosting> | $Typed<RecordHosting> | { $type: string }
   subjectBlobCids?: string[]
   subjectRepoHandle?: string
   /** Timestamp referencing when the last update was made to the moderation status of the subject */
@@ -136,19 +144,23 @@ export interface SubjectStatusView {
   appealed?: boolean
   suspendUntil?: string
   tags?: string[]
-  [k: string]: unknown
 }
 
-export function isSubjectStatusView(v: unknown): v is SubjectStatusView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#subjectStatusView'
-  )
+export function isSubjectStatusView<V>(v: V) {
+  return is$typed(v, id, 'subjectStatusView')
+}
+
+export function validateSubjectStatusView(v: unknown) {
+  return lexicons.validate(
+    `${id}#subjectStatusView`,
+    v,
+  ) as ValidationResult<SubjectStatusView>
 }
 
-export function validateSubjectStatusView(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#subjectStatusView', v)
+export function isValidSubjectStatusView<V>(
+  v: V,
+): v is V & $Typed<SubjectStatusView> {
+  return isSubjectStatusView(v) && validateSubjectStatusView(v).success
 }
 
 export type SubjectReviewState =
@@ -159,333 +171,387 @@ export type SubjectReviewState =
   | (string & {})
 
 /** Moderator review status of a subject: Open. Indicates that the subject needs to be reviewed by a moderator */
-export const REVIEWOPEN = 'tools.ozone.moderation.defs#reviewOpen'
+export const REVIEWOPEN = `${id}#reviewOpen`
 /** Moderator review status of a subject: Escalated. Indicates that the subject was escalated for review by a moderator */
-export const REVIEWESCALATED = 'tools.ozone.moderation.defs#reviewEscalated'
+export const REVIEWESCALATED = `${id}#reviewEscalated`
 /** Moderator review status of a subject: Closed. Indicates that the subject was already reviewed and resolved by a moderator */
-export const REVIEWCLOSED = 'tools.ozone.moderation.defs#reviewClosed'
+export const REVIEWCLOSED = `${id}#reviewClosed`
 /** Moderator review status of a subject: Unnecessary. Indicates that the subject does not need a review at the moment but there is probably some moderation related metadata available for it */
-export const REVIEWNONE = 'tools.ozone.moderation.defs#reviewNone'
+export const REVIEWNONE = `${id}#reviewNone`
 
 /** Take down a subject permanently or temporarily */
 export interface ModEventTakedown {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventTakedown'>
   comment?: string
   /** Indicates how long the takedown should be in effect before automatically expiring. */
   durationInHours?: number
   /** If true, all other reports on content authored by this account will be resolved (acknowledged). */
   acknowledgeAccountSubjects?: boolean
-  [k: string]: unknown
 }
 
-export function isModEventTakedown(v: unknown): v is ModEventTakedown {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventTakedown'
-  )
+export function isModEventTakedown<V>(v: V) {
+  return is$typed(v, id, 'modEventTakedown')
+}
+
+export function validateModEventTakedown(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventTakedown`,
+    v,
+  ) as ValidationResult<ModEventTakedown>
 }
 
-export function validateModEventTakedown(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventTakedown', v)
+export function isValidModEventTakedown<V>(
+  v: V,
+): v is V & $Typed<ModEventTakedown> {
+  return isModEventTakedown(v) && validateModEventTakedown(v).success
 }
 
 /** Revert take down action on a subject */
 export interface ModEventReverseTakedown {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventReverseTakedown'>
   /** Describe reasoning behind the reversal. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventReverseTakedown(
-  v: unknown,
-): v is ModEventReverseTakedown {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventReverseTakedown'
-  )
+export function isModEventReverseTakedown<V>(v: V) {
+  return is$typed(v, id, 'modEventReverseTakedown')
 }
 
-export function validateModEventReverseTakedown(v: unknown): ValidationResult {
+export function validateModEventReverseTakedown(v: unknown) {
   return lexicons.validate(
-    'tools.ozone.moderation.defs#modEventReverseTakedown',
+    `${id}#modEventReverseTakedown`,
     v,
+  ) as ValidationResult<ModEventReverseTakedown>
+}
+
+export function isValidModEventReverseTakedown<V>(
+  v: V,
+): v is V & $Typed<ModEventReverseTakedown> {
+  return (
+    isModEventReverseTakedown(v) && validateModEventReverseTakedown(v).success
   )
 }
 
 /** Resolve appeal on a subject */
 export interface ModEventResolveAppeal {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventResolveAppeal'>
   /** Describe resolution. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventResolveAppeal(
-  v: unknown,
-): v is ModEventResolveAppeal {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventResolveAppeal'
-  )
+export function isModEventResolveAppeal<V>(v: V) {
+  return is$typed(v, id, 'modEventResolveAppeal')
 }
 
-export function validateModEventResolveAppeal(v: unknown): ValidationResult {
+export function validateModEventResolveAppeal(v: unknown) {
   return lexicons.validate(
-    'tools.ozone.moderation.defs#modEventResolveAppeal',
+    `${id}#modEventResolveAppeal`,
     v,
-  )
+  ) as ValidationResult<ModEventResolveAppeal>
+}
+
+export function isValidModEventResolveAppeal<V>(
+  v: V,
+): v is V & $Typed<ModEventResolveAppeal> {
+  return isModEventResolveAppeal(v) && validateModEventResolveAppeal(v).success
 }
 
 /** Add a comment to a subject */
 export interface ModEventComment {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventComment'>
   comment: string
   /** Make the comment persistent on the subject */
   sticky?: boolean
-  [k: string]: unknown
 }
 
-export function isModEventComment(v: unknown): v is ModEventComment {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventComment'
-  )
+export function isModEventComment<V>(v: V) {
+  return is$typed(v, id, 'modEventComment')
+}
+
+export function validateModEventComment(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventComment`,
+    v,
+  ) as ValidationResult<ModEventComment>
 }
 
-export function validateModEventComment(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventComment', v)
+export function isValidModEventComment<V>(
+  v: V,
+): v is V & $Typed<ModEventComment> {
+  return isModEventComment(v) && validateModEventComment(v).success
 }
 
 /** Report a subject */
 export interface ModEventReport {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventReport'>
   comment?: string
   /** Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject. */
   isReporterMuted?: boolean
   reportType: ComAtprotoModerationDefs.ReasonType
-  [k: string]: unknown
 }
 
-export function isModEventReport(v: unknown): v is ModEventReport {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventReport'
-  )
+export function isModEventReport<V>(v: V) {
+  return is$typed(v, id, 'modEventReport')
+}
+
+export function validateModEventReport(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventReport`,
+    v,
+  ) as ValidationResult<ModEventReport>
 }
 
-export function validateModEventReport(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventReport', v)
+export function isValidModEventReport<V>(
+  v: V,
+): v is V & $Typed<ModEventReport> {
+  return isModEventReport(v) && validateModEventReport(v).success
 }
 
 /** Apply/Negate labels on a subject */
 export interface ModEventLabel {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventLabel'>
   comment?: string
   createLabelVals: string[]
   negateLabelVals: string[]
-  [k: string]: unknown
 }
 
-export function isModEventLabel(v: unknown): v is ModEventLabel {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventLabel'
-  )
+export function isModEventLabel<V>(v: V) {
+  return is$typed(v, id, 'modEventLabel')
 }
 
-export function validateModEventLabel(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventLabel', v)
+export function validateModEventLabel(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventLabel`,
+    v,
+  ) as ValidationResult<ModEventLabel>
+}
+
+export function isValidModEventLabel<V>(v: V): v is V & $Typed<ModEventLabel> {
+  return isModEventLabel(v) && validateModEventLabel(v).success
 }
 
 export interface ModEventAcknowledge {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventAcknowledge'>
   comment?: string
   /** If true, all other reports on content authored by this account will be resolved (acknowledged). */
   acknowledgeAccountSubjects?: boolean
-  [k: string]: unknown
 }
 
-export function isModEventAcknowledge(v: unknown): v is ModEventAcknowledge {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventAcknowledge'
-  )
+export function isModEventAcknowledge<V>(v: V) {
+  return is$typed(v, id, 'modEventAcknowledge')
 }
 
-export function validateModEventAcknowledge(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventAcknowledge', v)
+export function validateModEventAcknowledge(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventAcknowledge`,
+    v,
+  ) as ValidationResult<ModEventAcknowledge>
+}
+
+export function isValidModEventAcknowledge<V>(
+  v: V,
+): v is V & $Typed<ModEventAcknowledge> {
+  return isModEventAcknowledge(v) && validateModEventAcknowledge(v).success
 }
 
 export interface ModEventEscalate {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventEscalate'>
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventEscalate(v: unknown): v is ModEventEscalate {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventEscalate'
-  )
+export function isModEventEscalate<V>(v: V) {
+  return is$typed(v, id, 'modEventEscalate')
 }
 
-export function validateModEventEscalate(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventEscalate', v)
+export function validateModEventEscalate(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventEscalate`,
+    v,
+  ) as ValidationResult<ModEventEscalate>
+}
+
+export function isValidModEventEscalate<V>(
+  v: V,
+): v is V & $Typed<ModEventEscalate> {
+  return isModEventEscalate(v) && validateModEventEscalate(v).success
 }
 
 /** Mute incoming reports on a subject */
 export interface ModEventMute {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventMute'>
   comment?: string
   /** Indicates how long the subject should remain muted. */
   durationInHours: number
-  [k: string]: unknown
 }
 
-export function isModEventMute(v: unknown): v is ModEventMute {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventMute'
-  )
+export function isModEventMute<V>(v: V) {
+  return is$typed(v, id, 'modEventMute')
 }
 
-export function validateModEventMute(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventMute', v)
+export function validateModEventMute(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventMute`,
+    v,
+  ) as ValidationResult<ModEventMute>
+}
+
+export function isValidModEventMute<V>(v: V): v is V & $Typed<ModEventMute> {
+  return isModEventMute(v) && validateModEventMute(v).success
 }
 
 /** Unmute action on a subject */
 export interface ModEventUnmute {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventUnmute'>
   /** Describe reasoning behind the reversal. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventUnmute(v: unknown): v is ModEventUnmute {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventUnmute'
-  )
+export function isModEventUnmute<V>(v: V) {
+  return is$typed(v, id, 'modEventUnmute')
 }
 
-export function validateModEventUnmute(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventUnmute', v)
+export function validateModEventUnmute(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventUnmute`,
+    v,
+  ) as ValidationResult<ModEventUnmute>
+}
+
+export function isValidModEventUnmute<V>(
+  v: V,
+): v is V & $Typed<ModEventUnmute> {
+  return isModEventUnmute(v) && validateModEventUnmute(v).success
 }
 
 /** Mute incoming reports from an account */
 export interface ModEventMuteReporter {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventMuteReporter'>
   comment?: string
   /** Indicates how long the account should remain muted. Falsy value here means a permanent mute. */
   durationInHours?: number
-  [k: string]: unknown
 }
 
-export function isModEventMuteReporter(v: unknown): v is ModEventMuteReporter {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventMuteReporter'
-  )
+export function isModEventMuteReporter<V>(v: V) {
+  return is$typed(v, id, 'modEventMuteReporter')
 }
 
-export function validateModEventMuteReporter(v: unknown): ValidationResult {
+export function validateModEventMuteReporter(v: unknown) {
   return lexicons.validate(
-    'tools.ozone.moderation.defs#modEventMuteReporter',
+    `${id}#modEventMuteReporter`,
     v,
-  )
+  ) as ValidationResult<ModEventMuteReporter>
+}
+
+export function isValidModEventMuteReporter<V>(
+  v: V,
+): v is V & $Typed<ModEventMuteReporter> {
+  return isModEventMuteReporter(v) && validateModEventMuteReporter(v).success
 }
 
 /** Unmute incoming reports from an account */
 export interface ModEventUnmuteReporter {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventUnmuteReporter'>
   /** Describe reasoning behind the reversal. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventUnmuteReporter(
-  v: unknown,
-): v is ModEventUnmuteReporter {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventUnmuteReporter'
-  )
+export function isModEventUnmuteReporter<V>(v: V) {
+  return is$typed(v, id, 'modEventUnmuteReporter')
 }
 
-export function validateModEventUnmuteReporter(v: unknown): ValidationResult {
+export function validateModEventUnmuteReporter(v: unknown) {
   return lexicons.validate(
-    'tools.ozone.moderation.defs#modEventUnmuteReporter',
+    `${id}#modEventUnmuteReporter`,
     v,
+  ) as ValidationResult<ModEventUnmuteReporter>
+}
+
+export function isValidModEventUnmuteReporter<V>(
+  v: V,
+): v is V & $Typed<ModEventUnmuteReporter> {
+  return (
+    isModEventUnmuteReporter(v) && validateModEventUnmuteReporter(v).success
   )
 }
 
 /** Keep a log of outgoing email to a user */
 export interface ModEventEmail {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventEmail'>
   /** The subject line of the email sent to the user. */
   subjectLine: string
   /** The content of the email sent to the user. */
   content?: string
   /** Additional comment about the outgoing comm. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventEmail(v: unknown): v is ModEventEmail {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventEmail'
-  )
+export function isModEventEmail<V>(v: V) {
+  return is$typed(v, id, 'modEventEmail')
+}
+
+export function validateModEventEmail(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventEmail`,
+    v,
+  ) as ValidationResult<ModEventEmail>
 }
 
-export function validateModEventEmail(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventEmail', v)
+export function isValidModEventEmail<V>(v: V): v is V & $Typed<ModEventEmail> {
+  return isModEventEmail(v) && validateModEventEmail(v).success
 }
 
 /** Divert a record's blobs to a 3rd party service for further scanning/tagging */
 export interface ModEventDivert {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventDivert'>
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventDivert(v: unknown): v is ModEventDivert {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventDivert'
-  )
+export function isModEventDivert<V>(v: V) {
+  return is$typed(v, id, 'modEventDivert')
 }
 
-export function validateModEventDivert(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventDivert', v)
+export function validateModEventDivert(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventDivert`,
+    v,
+  ) as ValidationResult<ModEventDivert>
+}
+
+export function isValidModEventDivert<V>(
+  v: V,
+): v is V & $Typed<ModEventDivert> {
+  return isModEventDivert(v) && validateModEventDivert(v).success
 }
 
 /** Add/Remove a tag on a subject */
 export interface ModEventTag {
+  $type?: $Type<'tools.ozone.moderation.defs', 'modEventTag'>
   /** Tags to be added to the subject. If already exists, won't be duplicated. */
   add: string[]
   /** Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated. */
   remove: string[]
   /** Additional comment about added/removed tags. */
   comment?: string
-  [k: string]: unknown
 }
 
-export function isModEventTag(v: unknown): v is ModEventTag {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#modEventTag'
-  )
+export function isModEventTag<V>(v: V) {
+  return is$typed(v, id, 'modEventTag')
+}
+
+export function validateModEventTag(v: unknown) {
+  return lexicons.validate(
+    `${id}#modEventTag`,
+    v,
+  ) as ValidationResult<ModEventTag>
 }
 
-export function validateModEventTag(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#modEventTag', v)
+export function isValidModEventTag<V>(v: V): v is V & $Typed<ModEventTag> {
+  return isModEventTag(v) && validateModEventTag(v).success
 }
 
 /** Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
 export interface AccountEvent {
+  $type?: $Type<'tools.ozone.moderation.defs', 'accountEvent'>
   comment?: string
   /** Indicates that the account has a repository which can be fetched from the host that emitted this event. */
   active: boolean
@@ -498,69 +564,78 @@ export interface AccountEvent {
     | 'tombstoned'
     | (string & {})
   timestamp: string
-  [k: string]: unknown
 }
 
-export function isAccountEvent(v: unknown): v is AccountEvent {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#accountEvent'
-  )
+export function isAccountEvent<V>(v: V) {
+  return is$typed(v, id, 'accountEvent')
+}
+
+export function validateAccountEvent(v: unknown) {
+  return lexicons.validate(
+    `${id}#accountEvent`,
+    v,
+  ) as ValidationResult<AccountEvent>
 }
 
-export function validateAccountEvent(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#accountEvent', v)
+export function isValidAccountEvent<V>(v: V): v is V & $Typed<AccountEvent> {
+  return isAccountEvent(v) && validateAccountEvent(v).success
 }
 
 /** Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
 export interface IdentityEvent {
+  $type?: $Type<'tools.ozone.moderation.defs', 'identityEvent'>
   comment?: string
   handle?: string
   pdsHost?: string
   tombstone?: boolean
   timestamp: string
-  [k: string]: unknown
 }
 
-export function isIdentityEvent(v: unknown): v is IdentityEvent {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#identityEvent'
-  )
+export function isIdentityEvent<V>(v: V) {
+  return is$typed(v, id, 'identityEvent')
+}
+
+export function validateIdentityEvent(v: unknown) {
+  return lexicons.validate(
+    `${id}#identityEvent`,
+    v,
+  ) as ValidationResult<IdentityEvent>
 }
 
-export function validateIdentityEvent(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#identityEvent', v)
+export function isValidIdentityEvent<V>(v: V): v is V & $Typed<IdentityEvent> {
+  return isIdentityEvent(v) && validateIdentityEvent(v).success
 }
 
 /** Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
 export interface RecordEvent {
+  $type?: $Type<'tools.ozone.moderation.defs', 'recordEvent'>
   comment?: string
   op: 'create' | 'update' | 'delete' | (string & {})
   cid?: string
   timestamp: string
-  [k: string]: unknown
 }
 
-export function isRecordEvent(v: unknown): v is RecordEvent {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#recordEvent'
-  )
+export function isRecordEvent<V>(v: V) {
+  return is$typed(v, id, 'recordEvent')
+}
+
+export function validateRecordEvent(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordEvent`,
+    v,
+  ) as ValidationResult<RecordEvent>
 }
 
-export function validateRecordEvent(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#recordEvent', v)
+export function isValidRecordEvent<V>(v: V): v is V & $Typed<RecordEvent> {
+  return isRecordEvent(v) && validateRecordEvent(v).success
 }
 
 export interface RepoView {
+  $type?: $Type<'tools.ozone.moderation.defs', 'repoView'>
   did: string
   handle: string
   email?: string
-  relatedRecords: {}[]
+  relatedRecords: { [_ in string]: unknown }[]
   indexedAt: string
   moderation: Moderation
   invitedBy?: ComAtprotoServerDefs.InviteCode
@@ -568,26 +643,26 @@ export interface RepoView {
   inviteNote?: string
   deactivatedAt?: string
   threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[]
-  [k: string]: unknown
 }
 
-export function isRepoView(v: unknown): v is RepoView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#repoView'
-  )
+export function isRepoView<V>(v: V) {
+  return is$typed(v, id, 'repoView')
+}
+
+export function validateRepoView(v: unknown) {
+  return lexicons.validate(`${id}#repoView`, v) as ValidationResult<RepoView>
 }
 
-export function validateRepoView(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#repoView', v)
+export function isValidRepoView<V>(v: V): v is V & $Typed<RepoView> {
+  return isRepoView(v) && validateRepoView(v).success
 }
 
 export interface RepoViewDetail {
+  $type?: $Type<'tools.ozone.moderation.defs', 'repoViewDetail'>
   did: string
   handle: string
   email?: string
-  relatedRecords: {}[]
+  relatedRecords: { [_ in string]: unknown }[]
   indexedAt: string
   moderation: ModerationDetail
   labels?: ComAtprotoLabelDefs.Label[]
@@ -598,199 +673,233 @@ export interface RepoViewDetail {
   emailConfirmedAt?: string
   deactivatedAt?: string
   threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[]
-  [k: string]: unknown
 }
 
-export function isRepoViewDetail(v: unknown): v is RepoViewDetail {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#repoViewDetail'
-  )
+export function isRepoViewDetail<V>(v: V) {
+  return is$typed(v, id, 'repoViewDetail')
 }
 
-export function validateRepoViewDetail(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#repoViewDetail', v)
+export function validateRepoViewDetail(v: unknown) {
+  return lexicons.validate(
+    `${id}#repoViewDetail`,
+    v,
+  ) as ValidationResult<RepoViewDetail>
+}
+
+export function isValidRepoViewDetail<V>(
+  v: V,
+): v is V & $Typed<RepoViewDetail> {
+  return isRepoViewDetail(v) && validateRepoViewDetail(v).success
 }
 
 export interface RepoViewNotFound {
+  $type?: $Type<'tools.ozone.moderation.defs', 'repoViewNotFound'>
   did: string
-  [k: string]: unknown
 }
 
-export function isRepoViewNotFound(v: unknown): v is RepoViewNotFound {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#repoViewNotFound'
-  )
+export function isRepoViewNotFound<V>(v: V) {
+  return is$typed(v, id, 'repoViewNotFound')
 }
 
-export function validateRepoViewNotFound(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#repoViewNotFound', v)
+export function validateRepoViewNotFound(v: unknown) {
+  return lexicons.validate(
+    `${id}#repoViewNotFound`,
+    v,
+  ) as ValidationResult<RepoViewNotFound>
+}
+
+export function isValidRepoViewNotFound<V>(
+  v: V,
+): v is V & $Typed<RepoViewNotFound> {
+  return isRepoViewNotFound(v) && validateRepoViewNotFound(v).success
 }
 
 export interface RecordView {
+  $type?: $Type<'tools.ozone.moderation.defs', 'recordView'>
   uri: string
   cid: string
-  value: {}
+  value: { [_ in string]: unknown }
   blobCids: string[]
   indexedAt: string
   moderation: Moderation
   repo: RepoView
-  [k: string]: unknown
 }
 
-export function isRecordView(v: unknown): v is RecordView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#recordView'
-  )
+export function isRecordView<V>(v: V) {
+  return is$typed(v, id, 'recordView')
+}
+
+export function validateRecordView(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordView`,
+    v,
+  ) as ValidationResult<RecordView>
 }
 
-export function validateRecordView(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#recordView', v)
+export function isValidRecordView<V>(v: V): v is V & $Typed<RecordView> {
+  return isRecordView(v) && validateRecordView(v).success
 }
 
 export interface RecordViewDetail {
+  $type?: $Type<'tools.ozone.moderation.defs', 'recordViewDetail'>
   uri: string
   cid: string
-  value: {}
+  value: { [_ in string]: unknown }
   blobs: BlobView[]
   labels?: ComAtprotoLabelDefs.Label[]
   indexedAt: string
   moderation: ModerationDetail
   repo: RepoView
-  [k: string]: unknown
 }
 
-export function isRecordViewDetail(v: unknown): v is RecordViewDetail {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#recordViewDetail'
-  )
+export function isRecordViewDetail<V>(v: V) {
+  return is$typed(v, id, 'recordViewDetail')
 }
 
-export function validateRecordViewDetail(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#recordViewDetail', v)
+export function validateRecordViewDetail(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordViewDetail`,
+    v,
+  ) as ValidationResult<RecordViewDetail>
+}
+
+export function isValidRecordViewDetail<V>(
+  v: V,
+): v is V & $Typed<RecordViewDetail> {
+  return isRecordViewDetail(v) && validateRecordViewDetail(v).success
 }
 
 export interface RecordViewNotFound {
+  $type?: $Type<'tools.ozone.moderation.defs', 'recordViewNotFound'>
   uri: string
-  [k: string]: unknown
 }
 
-export function isRecordViewNotFound(v: unknown): v is RecordViewNotFound {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#recordViewNotFound'
-  )
+export function isRecordViewNotFound<V>(v: V) {
+  return is$typed(v, id, 'recordViewNotFound')
 }
 
-export function validateRecordViewNotFound(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#recordViewNotFound', v)
+export function validateRecordViewNotFound(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordViewNotFound`,
+    v,
+  ) as ValidationResult<RecordViewNotFound>
+}
+
+export function isValidRecordViewNotFound<V>(
+  v: V,
+): v is V & $Typed<RecordViewNotFound> {
+  return isRecordViewNotFound(v) && validateRecordViewNotFound(v).success
 }
 
 export interface Moderation {
+  $type?: $Type<'tools.ozone.moderation.defs', 'moderation'>
   subjectStatus?: SubjectStatusView
-  [k: string]: unknown
 }
 
-export function isModeration(v: unknown): v is Moderation {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#moderation'
-  )
+export function isModeration<V>(v: V) {
+  return is$typed(v, id, 'moderation')
 }
 
-export function validateModeration(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#moderation', v)
+export function validateModeration(v: unknown) {
+  return lexicons.validate(
+    `${id}#moderation`,
+    v,
+  ) as ValidationResult<Moderation>
+}
+
+export function isValidModeration<V>(v: V): v is V & $Typed<Moderation> {
+  return isModeration(v) && validateModeration(v).success
 }
 
 export interface ModerationDetail {
+  $type?: $Type<'tools.ozone.moderation.defs', 'moderationDetail'>
   subjectStatus?: SubjectStatusView
-  [k: string]: unknown
 }
 
-export function isModerationDetail(v: unknown): v is ModerationDetail {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#moderationDetail'
-  )
+export function isModerationDetail<V>(v: V) {
+  return is$typed(v, id, 'moderationDetail')
+}
+
+export function validateModerationDetail(v: unknown) {
+  return lexicons.validate(
+    `${id}#moderationDetail`,
+    v,
+  ) as ValidationResult<ModerationDetail>
 }
 
-export function validateModerationDetail(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#moderationDetail', v)
+export function isValidModerationDetail<V>(
+  v: V,
+): v is V & $Typed<ModerationDetail> {
+  return isModerationDetail(v) && validateModerationDetail(v).success
 }
 
 export interface BlobView {
+  $type?: $Type<'tools.ozone.moderation.defs', 'blobView'>
   cid: string
   mimeType: string
   size: number
   createdAt: string
-  details?:
-    | ImageDetails
-    | VideoDetails
-    | { $type: string; [k: string]: unknown }
+  details?: $Typed<ImageDetails> | $Typed<VideoDetails> | { $type: string }
   moderation?: Moderation
-  [k: string]: unknown
 }
 
-export function isBlobView(v: unknown): v is BlobView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#blobView'
-  )
+export function isBlobView<V>(v: V) {
+  return is$typed(v, id, 'blobView')
+}
+
+export function validateBlobView(v: unknown) {
+  return lexicons.validate(`${id}#blobView`, v) as ValidationResult<BlobView>
 }
 
-export function validateBlobView(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#blobView', v)
+export function isValidBlobView<V>(v: V): v is V & $Typed<BlobView> {
+  return isBlobView(v) && validateBlobView(v).success
 }
 
 export interface ImageDetails {
+  $type?: $Type<'tools.ozone.moderation.defs', 'imageDetails'>
   width: number
   height: number
-  [k: string]: unknown
 }
 
-export function isImageDetails(v: unknown): v is ImageDetails {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#imageDetails'
-  )
+export function isImageDetails<V>(v: V) {
+  return is$typed(v, id, 'imageDetails')
+}
+
+export function validateImageDetails(v: unknown) {
+  return lexicons.validate(
+    `${id}#imageDetails`,
+    v,
+  ) as ValidationResult<ImageDetails>
 }
 
-export function validateImageDetails(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#imageDetails', v)
+export function isValidImageDetails<V>(v: V): v is V & $Typed<ImageDetails> {
+  return isImageDetails(v) && validateImageDetails(v).success
 }
 
 export interface VideoDetails {
+  $type?: $Type<'tools.ozone.moderation.defs', 'videoDetails'>
   width: number
   height: number
   length: number
-  [k: string]: unknown
 }
 
-export function isVideoDetails(v: unknown): v is VideoDetails {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#videoDetails'
-  )
+export function isVideoDetails<V>(v: V) {
+  return is$typed(v, id, 'videoDetails')
+}
+
+export function validateVideoDetails(v: unknown) {
+  return lexicons.validate(
+    `${id}#videoDetails`,
+    v,
+  ) as ValidationResult<VideoDetails>
 }
 
-export function validateVideoDetails(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#videoDetails', v)
+export function isValidVideoDetails<V>(v: V): v is V & $Typed<VideoDetails> {
+  return isVideoDetails(v) && validateVideoDetails(v).success
 }
 
 export interface AccountHosting {
+  $type?: $Type<'tools.ozone.moderation.defs', 'accountHosting'>
   status:
     | 'takendown'
     | 'suspended'
@@ -803,37 +912,44 @@ export interface AccountHosting {
   deletedAt?: string
   deactivatedAt?: string
   reactivatedAt?: string
-  [k: string]: unknown
 }
 
-export function isAccountHosting(v: unknown): v is AccountHosting {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#accountHosting'
-  )
+export function isAccountHosting<V>(v: V) {
+  return is$typed(v, id, 'accountHosting')
+}
+
+export function validateAccountHosting(v: unknown) {
+  return lexicons.validate(
+    `${id}#accountHosting`,
+    v,
+  ) as ValidationResult<AccountHosting>
 }
 
-export function validateAccountHosting(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#accountHosting', v)
+export function isValidAccountHosting<V>(
+  v: V,
+): v is V & $Typed<AccountHosting> {
+  return isAccountHosting(v) && validateAccountHosting(v).success
 }
 
 export interface RecordHosting {
+  $type?: $Type<'tools.ozone.moderation.defs', 'recordHosting'>
   status: 'deleted' | 'unknown' | (string & {})
   updatedAt?: string
   createdAt?: string
   deletedAt?: string
-  [k: string]: unknown
 }
 
-export function isRecordHosting(v: unknown): v is RecordHosting {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'tools.ozone.moderation.defs#recordHosting'
-  )
+export function isRecordHosting<V>(v: V) {
+  return is$typed(v, id, 'recordHosting')
+}
+
+export function validateRecordHosting(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordHosting`,
+    v,
+  ) as ValidationResult<RecordHosting>
 }
 
-export function validateRecordHosting(v: unknown): ValidationResult {
-  return lexicons.validate('tools.ozone.moderation.defs#recordHosting', v)
+export function isValidRecordHosting<V>(v: V): v is V & $Typed<RecordHosting> {
+  return isRecordHosting(v) && validateRecordHosting(v).success
 }