@atproto/bsky 0.0.116 → 0.0.118

package/src/lexicon/types/com/atproto/label/defs.ts

@@ -2,12 +2,17 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.label.defs'
 
 /** Metadata tag on an atproto resource (eg, repo or record). */
 export interface Label {
+  $type?: 'com.atproto.label.defs#label'
   /** The AT Protocol version of the label object. */
   ver?: number
   /** DID of the actor who created this label. */
@@ -26,60 +31,54 @@ export interface Label {
   exp?: string
   /** Signature of dag-cbor encoded label. */
   sig?: Uint8Array
-  [k: string]: unknown
 }
 
-export function isLabel(v: unknown): v is Label {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.defs#label'
-  )
+const hashLabel = 'label'
+
+export function isLabel<V>(v: V) {
+  return is$typed(v, id, hashLabel)
 }
 
-export function validateLabel(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.defs#label', v)
+export function validateLabel<V>(v: V) {
+  return validate<Label & V>(v, id, hashLabel)
 }
 
 /** Metadata tags on an atproto record, published by the author within the record. */
 export interface SelfLabels {
+  $type?: 'com.atproto.label.defs#selfLabels'
   values: SelfLabel[]
-  [k: string]: unknown
 }
 
-export function isSelfLabels(v: unknown): v is SelfLabels {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.defs#selfLabels'
-  )
+const hashSelfLabels = 'selfLabels'
+
+export function isSelfLabels<V>(v: V) {
+  return is$typed(v, id, hashSelfLabels)
 }
 
-export function validateSelfLabels(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.defs#selfLabels', v)
+export function validateSelfLabels<V>(v: V) {
+  return validate<SelfLabels & V>(v, id, hashSelfLabels)
 }
 
 /** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
 export interface SelfLabel {
+  $type?: 'com.atproto.label.defs#selfLabel'
   /** The short string name of the value or type of this label. */
   val: string
-  [k: string]: unknown
 }
 
-export function isSelfLabel(v: unknown): v is SelfLabel {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.defs#selfLabel'
-  )
+const hashSelfLabel = 'selfLabel'
+
+export function isSelfLabel<V>(v: V) {
+  return is$typed(v, id, hashSelfLabel)
 }
 
-export function validateSelfLabel(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.defs#selfLabel', v)
+export function validateSelfLabel<V>(v: V) {
+  return validate<SelfLabel & V>(v, id, hashSelfLabel)
 }
 
 /** Declares a label value and its expected interpretations and behaviors. */
 export interface LabelValueDefinition {
+  $type?: 'com.atproto.label.defs#labelValueDefinition'
   /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
   identifier: string
   /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
@@ -91,48 +90,40 @@ export interface LabelValueDefinition {
   /** Does the user need to have adult content enabled in order to configure this label? */
   adultOnly?: boolean
   locales: LabelValueDefinitionStrings[]
-  [k: string]: unknown
 }
 
-export function isLabelValueDefinition(v: unknown): v is LabelValueDefinition {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.defs#labelValueDefinition'
-  )
+const hashLabelValueDefinition = 'labelValueDefinition'
+
+export function isLabelValueDefinition<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinition)
 }
 
-export function validateLabelValueDefinition(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.defs#labelValueDefinition', v)
+export function validateLabelValueDefinition<V>(v: V) {
+  return validate<LabelValueDefinition & V>(v, id, hashLabelValueDefinition)
 }
 
 /** Strings which describe the label in the UI, localized into a specific language. */
 export interface LabelValueDefinitionStrings {
+  $type?: 'com.atproto.label.defs#labelValueDefinitionStrings'
   /** The code of the language these strings are written in. */
   lang: string
   /** A short human-readable name for the label. */
   name: string
   /** A longer description of what the label means and why it might be applied. */
   description: string
-  [k: string]: unknown
 }
 
-export function isLabelValueDefinitionStrings(
-  v: unknown,
-): v is LabelValueDefinitionStrings {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.defs#labelValueDefinitionStrings'
-  )
+const hashLabelValueDefinitionStrings = 'labelValueDefinitionStrings'
+
+export function isLabelValueDefinitionStrings<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinitionStrings)
 }
 
-export function validateLabelValueDefinitionStrings(
-  v: unknown,
-): ValidationResult {
-  return lexicons.validate(
-    'com.atproto.label.defs#labelValueDefinitionStrings',
+export function validateLabelValueDefinitionStrings<V>(v: V) {
+  return validate<LabelValueDefinitionStrings & V>(
     v,
+    id,
+    hashLabelValueDefinitionStrings,
   )
 }
 

package/src/lexicon/types/com/atproto/label/queryLabels.ts

@@ -3,11 +3,15 @@
  */
 import express from 'express'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
-import * as ComAtprotoLabelDefs from './defs'
+import type * as ComAtprotoLabelDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.label.queryLabels'
 
 export interface QueryParams {
   /** List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI. */
@@ -23,7 +27,6 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   labels: ComAtprotoLabelDefs.Label[]
-  [k: string]: unknown
 }
 
 export type HandlerInput = undefined

package/src/lexicon/types/com/atproto/label/subscribeLabels.ts

@@ -2,22 +2,23 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 import { HandlerAuth, ErrorFrame } from '@atproto/xrpc-server'
-import { IncomingMessage } from 'http'
-import * as ComAtprotoLabelDefs from './defs'
+import { IncomingMessage } from 'node:http'
+import type * as ComAtprotoLabelDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.label.subscribeLabels'
 
 export interface QueryParams {
   /** The last known event seq number to backfill from. */
   cursor?: number
 }
 
-export type OutputSchema =
-  | Labels
-  | Info
-  | { $type: string; [k: string]: unknown }
+export type OutputSchema = $Typed<Labels> | $Typed<Info> | { $type: string }
 export type HandlerError = ErrorFrame<'FutureCursor'>
 export type HandlerOutput = HandlerError | OutputSchema
 export type HandlerReqCtx<HA extends HandlerAuth = never> = {
@@ -31,37 +32,33 @@ export type Handler<HA extends HandlerAuth = never> = (
 ) => AsyncIterable<HandlerOutput>
 
 export interface Labels {
+  $type?: 'com.atproto.label.subscribeLabels#labels'
   seq: number
   labels: ComAtprotoLabelDefs.Label[]
-  [k: string]: unknown
 }
 
-export function isLabels(v: unknown): v is Labels {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.subscribeLabels#labels'
-  )
+const hashLabels = 'labels'
+
+export function isLabels<V>(v: V) {
+  return is$typed(v, id, hashLabels)
 }
 
-export function validateLabels(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.subscribeLabels#labels', v)
+export function validateLabels<V>(v: V) {
+  return validate<Labels & V>(v, id, hashLabels)
 }
 
 export interface Info {
+  $type?: 'com.atproto.label.subscribeLabels#info'
   name: 'OutdatedCursor' | (string & {})
   message?: string
-  [k: string]: unknown
 }
 
-export function isInfo(v: unknown): v is Info {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.subscribeLabels#info'
-  )
+const hashInfo = 'info'
+
+export function isInfo<V>(v: V) {
+  return is$typed(v, id, hashInfo)
 }
 
-export function validateInfo(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.subscribeLabels#info', v)
+export function validateInfo<V>(v: V) {
+  return validate<Info & V>(v, id, hashInfo)
 }

package/src/lexicon/types/com/atproto/lexicon/schema.ts

@@ -2,25 +2,27 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.lexicon.schema'
 
 export interface Record {
+  $type: 'com.atproto.lexicon.schema'
   /** Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system. */
   lexicon: number
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'com.atproto.lexicon.schema#main' ||
-      v.$type === 'com.atproto.lexicon.schema')
-  )
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.lexicon.schema#main', v)
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
 }

package/src/lexicon/types/com/atproto/moderation/createReport.ts

@@ -3,13 +3,17 @@
  */
 import express from 'express'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
-import * as ComAtprotoModerationDefs from './defs'
-import * as ComAtprotoAdminDefs from '../admin/defs'
-import * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+import type * as ComAtprotoModerationDefs from './defs.js'
+import type * as ComAtprotoAdminDefs from '../admin/defs.js'
+import type * as ComAtprotoRepoStrongRef from '../repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.moderation.createReport'
 
 export interface QueryParams {}
 
@@ -18,10 +22,9 @@ export interface InputSchema {
   /** Additional context about the content and violation. */
   reason?: string
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
 }
 
 export interface OutputSchema {
@@ -29,12 +32,11 @@ export interface OutputSchema {
   reasonType: ComAtprotoModerationDefs.ReasonType
   reason?: string
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
   reportedBy: string
   createdAt: string
-  [k: string]: unknown
 }
 
 export interface HandlerInput {

package/src/lexicon/types/com/atproto/moderation/defs.ts

@@ -2,9 +2,13 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.moderation.defs'
 
 export type ReasonType =
   | 'com.atproto.moderation.defs#reasonSpam'
@@ -17,16 +21,16 @@ export type ReasonType =
   | (string & {})
 
 /** Spam: frequent unwanted promotion, replies, mentions */
-export const REASONSPAM = 'com.atproto.moderation.defs#reasonSpam'
+export const REASONSPAM = `${id}#reasonSpam`
 /** Direct violation of server rules, laws, terms of service */
-export const REASONVIOLATION = 'com.atproto.moderation.defs#reasonViolation'
+export const REASONVIOLATION = `${id}#reasonViolation`
 /** Misleading identity, affiliation, or content */
-export const REASONMISLEADING = 'com.atproto.moderation.defs#reasonMisleading'
+export const REASONMISLEADING = `${id}#reasonMisleading`
 /** Unwanted or mislabeled sexual content */
-export const REASONSEXUAL = 'com.atproto.moderation.defs#reasonSexual'
+export const REASONSEXUAL = `${id}#reasonSexual`
 /** Rude, harassing, explicit, or otherwise unwelcoming behavior */
-export const REASONRUDE = 'com.atproto.moderation.defs#reasonRude'
+export const REASONRUDE = `${id}#reasonRude`
 /** Other: reports not falling under another report category */
-export const REASONOTHER = 'com.atproto.moderation.defs#reasonOther'
+export const REASONOTHER = `${id}#reasonOther`
 /** Appeal: appeal a previously taken moderation action */
-export const REASONAPPEAL = 'com.atproto.moderation.defs#reasonAppeal'
+export const REASONAPPEAL = `${id}#reasonAppeal`

package/src/lexicon/types/com/atproto/repo/applyWrites.ts

@@ -3,11 +3,15 @@
  */
 import express from 'express'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
-import * as ComAtprotoRepoDefs from './defs'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.applyWrites'
 
 export interface QueryParams {}
 
@@ -16,16 +20,18 @@ export interface InputSchema {
   repo: string
   /** Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons. */
   validate?: boolean
-  writes: (Create | Update | Delete)[]
+  writes: ($Typed<Create> | $Typed<Update> | $Typed<Delete>)[]
   /** If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
   commit?: ComAtprotoRepoDefs.CommitMeta
-  results?: (CreateResult | UpdateResult | DeleteResult)[]
-  [k: string]: unknown
+  results?: (
+    | $Typed<CreateResult>
+    | $Typed<UpdateResult>
+    | $Typed<DeleteResult>
+  )[]
 }
 
 export interface HandlerInput {
@@ -60,113 +66,101 @@ export type Handler<HA extends HandlerAuth = never> = (
 
 /** Operation which creates a new record. */
 export interface Create {
+  $type?: 'com.atproto.repo.applyWrites#create'
   collection: string
   rkey?: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
 }
 
-export function isCreate(v: unknown): v is Create {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#create'
-  )
+const hashCreate = 'create'
+
+export function isCreate<V>(v: V) {
+  return is$typed(v, id, hashCreate)
 }
 
-export function validateCreate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#create', v)
+export function validateCreate<V>(v: V) {
+  return validate<Create & V>(v, id, hashCreate)
 }
 
 /** Operation which updates an existing record. */
 export interface Update {
+  $type?: 'com.atproto.repo.applyWrites#update'
   collection: string
   rkey: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
 }
 
-export function isUpdate(v: unknown): v is Update {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#update'
-  )
+const hashUpdate = 'update'
+
+export function isUpdate<V>(v: V) {
+  return is$typed(v, id, hashUpdate)
 }
 
-export function validateUpdate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#update', v)
+export function validateUpdate<V>(v: V) {
+  return validate<Update & V>(v, id, hashUpdate)
 }
 
 /** Operation which deletes an existing record. */
 export interface Delete {
+  $type?: 'com.atproto.repo.applyWrites#delete'
   collection: string
   rkey: string
-  [k: string]: unknown
 }
 
-export function isDelete(v: unknown): v is Delete {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#delete'
-  )
+const hashDelete = 'delete'
+
+export function isDelete<V>(v: V) {
+  return is$typed(v, id, hashDelete)
 }
 
-export function validateDelete(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#delete', v)
+export function validateDelete<V>(v: V) {
+  return validate<Delete & V>(v, id, hashDelete)
 }
 
 export interface CreateResult {
+  $type?: 'com.atproto.repo.applyWrites#createResult'
   uri: string
   cid: string
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
-export function isCreateResult(v: unknown): v is CreateResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#createResult'
-  )
+const hashCreateResult = 'createResult'
+
+export function isCreateResult<V>(v: V) {
+  return is$typed(v, id, hashCreateResult)
 }
 
-export function validateCreateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#createResult', v)
+export function validateCreateResult<V>(v: V) {
+  return validate<CreateResult & V>(v, id, hashCreateResult)
 }
 
 export interface UpdateResult {
+  $type?: 'com.atproto.repo.applyWrites#updateResult'
   uri: string
   cid: string
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
-export function isUpdateResult(v: unknown): v is UpdateResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#updateResult'
-  )
+const hashUpdateResult = 'updateResult'
+
+export function isUpdateResult<V>(v: V) {
+  return is$typed(v, id, hashUpdateResult)
 }
 
-export function validateUpdateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#updateResult', v)
+export function validateUpdateResult<V>(v: V) {
+  return validate<UpdateResult & V>(v, id, hashUpdateResult)
 }
 
 export interface DeleteResult {
-  [k: string]: unknown
+  $type?: 'com.atproto.repo.applyWrites#deleteResult'
 }
 
-export function isDeleteResult(v: unknown): v is DeleteResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#deleteResult'
-  )
+const hashDeleteResult = 'deleteResult'
+
+export function isDeleteResult<V>(v: V) {
+  return is$typed(v, id, hashDeleteResult)
 }
 
-export function validateDeleteResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#deleteResult', v)
+export function validateDeleteResult<V>(v: V) {
+  return validate<DeleteResult & V>(v, id, hashDeleteResult)
 }

package/src/lexicon/types/com/atproto/repo/createRecord.ts

@@ -3,11 +3,15 @@
  */
 import express from 'express'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
-import * as ComAtprotoRepoDefs from './defs'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.createRecord'
 
 export interface QueryParams {}
 
@@ -21,10 +25,9 @@ export interface InputSchema {
   /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
   validate?: boolean
   /** The record itself. Must contain a $type field. */
-  record: {}
+  record: { [_ in string]: unknown }
   /** Compare and swap with the previous commit by CID. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
@@ -32,7 +35,6 @@ export interface OutputSchema {
   cid: string
   commit?: ComAtprotoRepoDefs.CommitMeta
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
 export interface HandlerInput {