@atproto/pds 0.4.94 → 0.4.95

package/src/lexicon/types/app/bsky/embed/record.ts

@@ -2,148 +2,141 @@
  * 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 * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
-import * as AppBskyFeedDefs from '../feed/defs'
-import * as AppBskyGraphDefs from '../graph/defs'
-import * as AppBskyLabelerDefs from '../labeler/defs'
-import * as AppBskyActorDefs from '../actor/defs'
-import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
-import * as AppBskyEmbedImages from './images'
-import * as AppBskyEmbedVideo from './video'
-import * as AppBskyEmbedExternal from './external'
-import * as AppBskyEmbedRecordWithMedia from './recordWithMedia'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+import type * as AppBskyFeedDefs from '../feed/defs.js'
+import type * as AppBskyGraphDefs from '../graph/defs.js'
+import type * as AppBskyLabelerDefs from '../labeler/defs.js'
+import type * as AppBskyActorDefs from '../actor/defs.js'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs.js'
+import type * as AppBskyEmbedImages from './images.js'
+import type * as AppBskyEmbedVideo from './video.js'
+import type * as AppBskyEmbedExternal from './external.js'
+import type * as AppBskyEmbedRecordWithMedia from './recordWithMedia.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.embed.record'
 
 export interface Main {
+  $type?: 'app.bsky.embed.record'
   record: ComAtprotoRepoStrongRef.Main
-  [k: string]: unknown
 }
 
-export function isMain(v: unknown): v is Main {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.embed.record#main' ||
-      v.$type === 'app.bsky.embed.record')
-  )
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateMain(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#main', v)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
 }
 
 export interface View {
+  $type?: 'app.bsky.embed.record#view'
   record:
-    | ViewRecord
-    | ViewNotFound
-    | ViewBlocked
-    | ViewDetached
-    | AppBskyFeedDefs.GeneratorView
-    | AppBskyGraphDefs.ListView
-    | AppBskyLabelerDefs.LabelerView
-    | AppBskyGraphDefs.StarterPackViewBasic
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+    | $Typed<ViewRecord>
+    | $Typed<ViewNotFound>
+    | $Typed<ViewBlocked>
+    | $Typed<ViewDetached>
+    | $Typed<AppBskyFeedDefs.GeneratorView>
+    | $Typed<AppBskyGraphDefs.ListView>
+    | $Typed<AppBskyLabelerDefs.LabelerView>
+    | $Typed<AppBskyGraphDefs.StarterPackViewBasic>
+    | { $type: string }
 }
 
-export function isView(v: unknown): v is View {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.embed.record#view'
-  )
+const hashView = 'view'
+
+export function isView<V>(v: V) {
+  return is$typed(v, id, hashView)
 }
 
-export function validateView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#view', v)
+export function validateView<V>(v: V) {
+  return validate<View & V>(v, id, hashView)
 }
 
 export interface ViewRecord {
+  $type?: 'app.bsky.embed.record#viewRecord'
   uri: string
   cid: string
   author: AppBskyActorDefs.ProfileViewBasic
   /** The record data itself. */
-  value: {}
+  value: { [_ in string]: unknown }
   labels?: ComAtprotoLabelDefs.Label[]
   replyCount?: number
   repostCount?: number
   likeCount?: number
   quoteCount?: number
   embeds?: (
-    | AppBskyEmbedImages.View
-    | AppBskyEmbedVideo.View
-    | AppBskyEmbedExternal.View
-    | View
-    | AppBskyEmbedRecordWithMedia.View
-    | { $type: string; [k: string]: unknown }
+    | $Typed<AppBskyEmbedImages.View>
+    | $Typed<AppBskyEmbedVideo.View>
+    | $Typed<AppBskyEmbedExternal.View>
+    | $Typed<View>
+    | $Typed<AppBskyEmbedRecordWithMedia.View>
+    | { $type: string }
   )[]
   indexedAt: string
-  [k: string]: unknown
 }
 
-export function isViewRecord(v: unknown): v is ViewRecord {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.record#viewRecord'
-  )
+const hashViewRecord = 'viewRecord'
+
+export function isViewRecord<V>(v: V) {
+  return is$typed(v, id, hashViewRecord)
 }
 
-export function validateViewRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#viewRecord', v)
+export function validateViewRecord<V>(v: V) {
+  return validate<ViewRecord & V>(v, id, hashViewRecord)
 }
 
 export interface ViewNotFound {
+  $type?: 'app.bsky.embed.record#viewNotFound'
   uri: string
   notFound: true
-  [k: string]: unknown
 }
 
-export function isViewNotFound(v: unknown): v is ViewNotFound {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.record#viewNotFound'
-  )
+const hashViewNotFound = 'viewNotFound'
+
+export function isViewNotFound<V>(v: V) {
+  return is$typed(v, id, hashViewNotFound)
 }
 
-export function validateViewNotFound(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#viewNotFound', v)
+export function validateViewNotFound<V>(v: V) {
+  return validate<ViewNotFound & V>(v, id, hashViewNotFound)
 }
 
 export interface ViewBlocked {
+  $type?: 'app.bsky.embed.record#viewBlocked'
   uri: string
   blocked: true
   author: AppBskyFeedDefs.BlockedAuthor
-  [k: string]: unknown
 }
 
-export function isViewBlocked(v: unknown): v is ViewBlocked {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.record#viewBlocked'
-  )
+const hashViewBlocked = 'viewBlocked'
+
+export function isViewBlocked<V>(v: V) {
+  return is$typed(v, id, hashViewBlocked)
 }
 
-export function validateViewBlocked(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#viewBlocked', v)
+export function validateViewBlocked<V>(v: V) {
+  return validate<ViewBlocked & V>(v, id, hashViewBlocked)
 }
 
 export interface ViewDetached {
+  $type?: 'app.bsky.embed.record#viewDetached'
   uri: string
   detached: true
-  [k: string]: unknown
 }
 
-export function isViewDetached(v: unknown): v is ViewDetached {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.record#viewDetached'
-  )
+const hashViewDetached = 'viewDetached'
+
+export function isViewDetached<V>(v: V) {
+  return is$typed(v, id, hashViewDetached)
 }
 
-export function validateViewDetached(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.record#viewDetached', v)
+export function validateViewDetached<V>(v: V) {
+  return validate<ViewDetached & V>(v, id, hashViewDetached)
 }

package/src/lexicon/types/app/bsky/embed/recordWithMedia.ts

@@ -2,55 +2,54 @@
  * 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 * as AppBskyEmbedRecord from './record'
-import * as AppBskyEmbedImages from './images'
-import * as AppBskyEmbedVideo from './video'
-import * as AppBskyEmbedExternal from './external'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyEmbedRecord from './record.js'
+import type * as AppBskyEmbedImages from './images.js'
+import type * as AppBskyEmbedVideo from './video.js'
+import type * as AppBskyEmbedExternal from './external.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.embed.recordWithMedia'
 
 export interface Main {
+  $type?: 'app.bsky.embed.recordWithMedia'
   record: AppBskyEmbedRecord.Main
   media:
-    | AppBskyEmbedImages.Main
-    | AppBskyEmbedVideo.Main
-    | AppBskyEmbedExternal.Main
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+    | $Typed<AppBskyEmbedImages.Main>
+    | $Typed<AppBskyEmbedVideo.Main>
+    | $Typed<AppBskyEmbedExternal.Main>
+    | { $type: string }
 }
 
-export function isMain(v: unknown): v is Main {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.embed.recordWithMedia#main' ||
-      v.$type === 'app.bsky.embed.recordWithMedia')
-  )
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateMain(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.recordWithMedia#main', v)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
 }
 
 export interface View {
+  $type?: 'app.bsky.embed.recordWithMedia#view'
   record: AppBskyEmbedRecord.View
   media:
-    | AppBskyEmbedImages.View
-    | AppBskyEmbedVideo.View
-    | AppBskyEmbedExternal.View
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+    | $Typed<AppBskyEmbedImages.View>
+    | $Typed<AppBskyEmbedVideo.View>
+    | $Typed<AppBskyEmbedExternal.View>
+    | { $type: string }
 }
 
-export function isView(v: unknown): v is View {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.recordWithMedia#view'
-  )
+const hashView = 'view'
+
+export function isView<V>(v: V) {
+  return is$typed(v, id, hashView)
 }
 
-export function validateView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.recordWithMedia#view', v)
+export function validateView<V>(v: V) {
+  return validate<View & V>(v, id, hashView)
 }

package/src/lexicon/types/app/bsky/embed/video.ts

@@ -2,66 +2,65 @@
  * 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 * as AppBskyEmbedDefs from './defs'
+import { validate as _validate } from '../../../../lexicons'
+import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyEmbedDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.embed.video'
 
 export interface Main {
+  $type?: 'app.bsky.embed.video'
   video: BlobRef
   captions?: Caption[]
   /** Alt text description of the video, for accessibility. */
   alt?: string
   aspectRatio?: AppBskyEmbedDefs.AspectRatio
-  [k: string]: unknown
 }
 
-export function isMain(v: unknown): v is Main {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.embed.video#main' ||
-      v.$type === 'app.bsky.embed.video')
-  )
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateMain(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.video#main', v)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
 }
 
 export interface Caption {
+  $type?: 'app.bsky.embed.video#caption'
   lang: string
   file: BlobRef
-  [k: string]: unknown
 }
 
-export function isCaption(v: unknown): v is Caption {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.embed.video#caption'
-  )
+const hashCaption = 'caption'
+
+export function isCaption<V>(v: V) {
+  return is$typed(v, id, hashCaption)
 }
 
-export function validateCaption(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.video#caption', v)
+export function validateCaption<V>(v: V) {
+  return validate<Caption & V>(v, id, hashCaption)
 }
 
 export interface View {
+  $type?: 'app.bsky.embed.video#view'
   cid: string
   playlist: string
   thumbnail?: string
   alt?: string
   aspectRatio?: AppBskyEmbedDefs.AspectRatio
-  [k: string]: unknown
 }
 
-export function isView(v: unknown): v is View {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.embed.video#view'
-  )
+const hashView = 'view'
+
+export function isView<V>(v: V) {
+  return is$typed(v, id, hashView)
 }
 
-export function validateView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.embed.video#view', v)
+export function validateView<V>(v: V) {
+  return validate<View & V>(v, id, hashView)
 }