@atproto/api 0.13.20 → 0.14.0-next.0

package/src/client/types/app/bsky/feed/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 AppBskyActorDefs from '../actor/defs'
 import * as AppBskyEmbedImages from '../embed/images'
 import * as AppBskyEmbedVideo from '../embed/video'
@@ -15,18 +15,21 @@ import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 import * as AppBskyRichtextFacet from '../richtext/facet'
 import * as AppBskyGraphDefs from '../graph/defs'
 
+const id = 'app.bsky.feed.defs'
+
 export interface PostView {
+  $type?: $Type<'app.bsky.feed.defs', 'postView'>
   uri: string
   cid: string
   author: AppBskyActorDefs.ProfileViewBasic
-  record: {}
+  record: { [_ in string]: unknown }
   embed?:
-    | AppBskyEmbedImages.View
-    | AppBskyEmbedVideo.View
-    | AppBskyEmbedExternal.View
-    | AppBskyEmbedRecord.View
-    | AppBskyEmbedRecordWithMedia.View
-    | { $type: string; [k: string]: unknown }
+    | $Typed<AppBskyEmbedImages.View>
+    | $Typed<AppBskyEmbedVideo.View>
+    | $Typed<AppBskyEmbedExternal.View>
+    | $Typed<AppBskyEmbedRecord.View>
+    | $Typed<AppBskyEmbedRecordWithMedia.View>
+    | { $type: string }
   replyCount?: number
   repostCount?: number
   likeCount?: number
@@ -35,206 +38,233 @@ export interface PostView {
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
   threadgate?: ThreadgateView
-  [k: string]: unknown
 }
 
-export function isPostView(v: unknown): v is PostView {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.defs#postView'
-  )
+export function isPostView<V>(v: V) {
+  return is$typed(v, id, 'postView')
+}
+
+export function validatePostView(v: unknown) {
+  return lexicons.validate(`${id}#postView`, v) as ValidationResult<PostView>
 }
 
-export function validatePostView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#postView', v)
+export function isValidPostView<V>(v: V): v is V & $Typed<PostView> {
+  return isPostView(v) && validatePostView(v).success
 }
 
 /** Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests. */
 export interface ViewerState {
+  $type?: $Type<'app.bsky.feed.defs', 'viewerState'>
   repost?: string
   like?: string
   threadMuted?: boolean
   replyDisabled?: boolean
   embeddingDisabled?: boolean
   pinned?: boolean
-  [k: string]: unknown
 }
 
-export function isViewerState(v: unknown): v is ViewerState {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#viewerState'
-  )
+export function isViewerState<V>(v: V) {
+  return is$typed(v, id, 'viewerState')
 }
 
-export function validateViewerState(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#viewerState', v)
+export function validateViewerState(v: unknown) {
+  return lexicons.validate(
+    `${id}#viewerState`,
+    v,
+  ) as ValidationResult<ViewerState>
+}
+
+export function isValidViewerState<V>(v: V): v is V & $Typed<ViewerState> {
+  return isViewerState(v) && validateViewerState(v).success
 }
 
 export interface FeedViewPost {
+  $type?: $Type<'app.bsky.feed.defs', 'feedViewPost'>
   post: PostView
   reply?: ReplyRef
-  reason?: ReasonRepost | ReasonPin | { $type: string; [k: string]: unknown }
+  reason?: $Typed<ReasonRepost> | $Typed<ReasonPin> | { $type: string }
   /** Context provided by feed generator that may be passed back alongside interactions. */
   feedContext?: string
-  [k: string]: unknown
 }
 
-export function isFeedViewPost(v: unknown): v is FeedViewPost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#feedViewPost'
-  )
+export function isFeedViewPost<V>(v: V) {
+  return is$typed(v, id, 'feedViewPost')
 }
 
-export function validateFeedViewPost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#feedViewPost', v)
+export function validateFeedViewPost(v: unknown) {
+  return lexicons.validate(
+    `${id}#feedViewPost`,
+    v,
+  ) as ValidationResult<FeedViewPost>
+}
+
+export function isValidFeedViewPost<V>(v: V): v is V & $Typed<FeedViewPost> {
+  return isFeedViewPost(v) && validateFeedViewPost(v).success
 }
 
 export interface ReplyRef {
+  $type?: $Type<'app.bsky.feed.defs', 'replyRef'>
   root:
-    | PostView
-    | NotFoundPost
-    | BlockedPost
-    | { $type: string; [k: string]: unknown }
+    | $Typed<PostView>
+    | $Typed<NotFoundPost>
+    | $Typed<BlockedPost>
+    | { $type: string }
   parent:
-    | PostView
-    | NotFoundPost
-    | BlockedPost
-    | { $type: string; [k: string]: unknown }
+    | $Typed<PostView>
+    | $Typed<NotFoundPost>
+    | $Typed<BlockedPost>
+    | { $type: string }
   grandparentAuthor?: AppBskyActorDefs.ProfileViewBasic
-  [k: string]: unknown
 }
 
-export function isReplyRef(v: unknown): v is ReplyRef {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.defs#replyRef'
-  )
+export function isReplyRef<V>(v: V) {
+  return is$typed(v, id, 'replyRef')
 }
 
-export function validateReplyRef(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#replyRef', v)
+export function validateReplyRef(v: unknown) {
+  return lexicons.validate(`${id}#replyRef`, v) as ValidationResult<ReplyRef>
+}
+
+export function isValidReplyRef<V>(v: V): v is V & $Typed<ReplyRef> {
+  return isReplyRef(v) && validateReplyRef(v).success
 }
 
 export interface ReasonRepost {
+  $type?: $Type<'app.bsky.feed.defs', 'reasonRepost'>
   by: AppBskyActorDefs.ProfileViewBasic
   indexedAt: string
-  [k: string]: unknown
 }
 
-export function isReasonRepost(v: unknown): v is ReasonRepost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#reasonRepost'
-  )
+export function isReasonRepost<V>(v: V) {
+  return is$typed(v, id, 'reasonRepost')
+}
+
+export function validateReasonRepost(v: unknown) {
+  return lexicons.validate(
+    `${id}#reasonRepost`,
+    v,
+  ) as ValidationResult<ReasonRepost>
 }
 
-export function validateReasonRepost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#reasonRepost', v)
+export function isValidReasonRepost<V>(v: V): v is V & $Typed<ReasonRepost> {
+  return isReasonRepost(v) && validateReasonRepost(v).success
 }
 
 export interface ReasonPin {
-  [k: string]: unknown
+  $type?: $Type<'app.bsky.feed.defs', 'reasonPin'>
+}
+
+export function isReasonPin<V>(v: V) {
+  return is$typed(v, id, 'reasonPin')
 }
 
-export function isReasonPin(v: unknown): v is ReasonPin {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#reasonPin'
-  )
+export function validateReasonPin(v: unknown) {
+  return lexicons.validate(`${id}#reasonPin`, v) as ValidationResult<ReasonPin>
 }
 
-export function validateReasonPin(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#reasonPin', v)
+export function isValidReasonPin<V>(v: V): v is V & $Typed<ReasonPin> {
+  return isReasonPin(v) && validateReasonPin(v).success
 }
 
 export interface ThreadViewPost {
+  $type?: $Type<'app.bsky.feed.defs', 'threadViewPost'>
   post: PostView
   parent?:
-    | ThreadViewPost
-    | NotFoundPost
-    | BlockedPost
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ThreadViewPost>
+    | $Typed<NotFoundPost>
+    | $Typed<BlockedPost>
+    | { $type: string }
   replies?: (
-    | ThreadViewPost
-    | NotFoundPost
-    | BlockedPost
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ThreadViewPost>
+    | $Typed<NotFoundPost>
+    | $Typed<BlockedPost>
+    | { $type: string }
   )[]
-  [k: string]: unknown
 }
 
-export function isThreadViewPost(v: unknown): v is ThreadViewPost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#threadViewPost'
-  )
+export function isThreadViewPost<V>(v: V) {
+  return is$typed(v, id, 'threadViewPost')
 }
 
-export function validateThreadViewPost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#threadViewPost', v)
+export function validateThreadViewPost(v: unknown) {
+  return lexicons.validate(
+    `${id}#threadViewPost`,
+    v,
+  ) as ValidationResult<ThreadViewPost>
+}
+
+export function isValidThreadViewPost<V>(
+  v: V,
+): v is V & $Typed<ThreadViewPost> {
+  return isThreadViewPost(v) && validateThreadViewPost(v).success
 }
 
 export interface NotFoundPost {
+  $type?: $Type<'app.bsky.feed.defs', 'notFoundPost'>
   uri: string
   notFound: true
-  [k: string]: unknown
 }
 
-export function isNotFoundPost(v: unknown): v is NotFoundPost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#notFoundPost'
-  )
+export function isNotFoundPost<V>(v: V) {
+  return is$typed(v, id, 'notFoundPost')
+}
+
+export function validateNotFoundPost(v: unknown) {
+  return lexicons.validate(
+    `${id}#notFoundPost`,
+    v,
+  ) as ValidationResult<NotFoundPost>
 }
 
-export function validateNotFoundPost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#notFoundPost', v)
+export function isValidNotFoundPost<V>(v: V): v is V & $Typed<NotFoundPost> {
+  return isNotFoundPost(v) && validateNotFoundPost(v).success
 }
 
 export interface BlockedPost {
+  $type?: $Type<'app.bsky.feed.defs', 'blockedPost'>
   uri: string
   blocked: true
   author: BlockedAuthor
-  [k: string]: unknown
 }
 
-export function isBlockedPost(v: unknown): v is BlockedPost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#blockedPost'
-  )
+export function isBlockedPost<V>(v: V) {
+  return is$typed(v, id, 'blockedPost')
 }
 
-export function validateBlockedPost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#blockedPost', v)
+export function validateBlockedPost(v: unknown) {
+  return lexicons.validate(
+    `${id}#blockedPost`,
+    v,
+  ) as ValidationResult<BlockedPost>
+}
+
+export function isValidBlockedPost<V>(v: V): v is V & $Typed<BlockedPost> {
+  return isBlockedPost(v) && validateBlockedPost(v).success
 }
 
 export interface BlockedAuthor {
+  $type?: $Type<'app.bsky.feed.defs', 'blockedAuthor'>
   did: string
   viewer?: AppBskyActorDefs.ViewerState
-  [k: string]: unknown
 }
 
-export function isBlockedAuthor(v: unknown): v is BlockedAuthor {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#blockedAuthor'
-  )
+export function isBlockedAuthor<V>(v: V) {
+  return is$typed(v, id, 'blockedAuthor')
 }
 
-export function validateBlockedAuthor(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#blockedAuthor', v)
+export function validateBlockedAuthor(v: unknown) {
+  return lexicons.validate(
+    `${id}#blockedAuthor`,
+    v,
+  ) as ValidationResult<BlockedAuthor>
+}
+
+export function isValidBlockedAuthor<V>(v: V): v is V & $Typed<BlockedAuthor> {
+  return isBlockedAuthor(v) && validateBlockedAuthor(v).success
 }
 
 export interface GeneratorView {
+  $type?: $Type<'app.bsky.feed.defs', 'generatorView'>
   uri: string
   cid: string
   did: string
@@ -248,115 +278,143 @@ export interface GeneratorView {
   labels?: ComAtprotoLabelDefs.Label[]
   viewer?: GeneratorViewerState
   indexedAt: string
-  [k: string]: unknown
 }
 
-export function isGeneratorView(v: unknown): v is GeneratorView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#generatorView'
-  )
+export function isGeneratorView<V>(v: V) {
+  return is$typed(v, id, 'generatorView')
 }
 
-export function validateGeneratorView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#generatorView', v)
+export function validateGeneratorView(v: unknown) {
+  return lexicons.validate(
+    `${id}#generatorView`,
+    v,
+  ) as ValidationResult<GeneratorView>
+}
+
+export function isValidGeneratorView<V>(v: V): v is V & $Typed<GeneratorView> {
+  return isGeneratorView(v) && validateGeneratorView(v).success
 }
 
 export interface GeneratorViewerState {
+  $type?: $Type<'app.bsky.feed.defs', 'generatorViewerState'>
   like?: string
-  [k: string]: unknown
 }
 
-export function isGeneratorViewerState(v: unknown): v is GeneratorViewerState {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#generatorViewerState'
-  )
+export function isGeneratorViewerState<V>(v: V) {
+  return is$typed(v, id, 'generatorViewerState')
+}
+
+export function validateGeneratorViewerState(v: unknown) {
+  return lexicons.validate(
+    `${id}#generatorViewerState`,
+    v,
+  ) as ValidationResult<GeneratorViewerState>
 }
 
-export function validateGeneratorViewerState(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#generatorViewerState', v)
+export function isValidGeneratorViewerState<V>(
+  v: V,
+): v is V & $Typed<GeneratorViewerState> {
+  return isGeneratorViewerState(v) && validateGeneratorViewerState(v).success
 }
 
 export interface SkeletonFeedPost {
+  $type?: $Type<'app.bsky.feed.defs', 'skeletonFeedPost'>
   post: string
   reason?:
-    | SkeletonReasonRepost
-    | SkeletonReasonPin
-    | { $type: string; [k: string]: unknown }
+    | $Typed<SkeletonReasonRepost>
+    | $Typed<SkeletonReasonPin>
+    | { $type: string }
   /** Context that will be passed through to client and may be passed to feed generator back alongside interactions. */
   feedContext?: string
-  [k: string]: unknown
 }
 
-export function isSkeletonFeedPost(v: unknown): v is SkeletonFeedPost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#skeletonFeedPost'
-  )
+export function isSkeletonFeedPost<V>(v: V) {
+  return is$typed(v, id, 'skeletonFeedPost')
+}
+
+export function validateSkeletonFeedPost(v: unknown) {
+  return lexicons.validate(
+    `${id}#skeletonFeedPost`,
+    v,
+  ) as ValidationResult<SkeletonFeedPost>
 }
 
-export function validateSkeletonFeedPost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#skeletonFeedPost', v)
+export function isValidSkeletonFeedPost<V>(
+  v: V,
+): v is V & $Typed<SkeletonFeedPost> {
+  return isSkeletonFeedPost(v) && validateSkeletonFeedPost(v).success
 }
 
 export interface SkeletonReasonRepost {
+  $type?: $Type<'app.bsky.feed.defs', 'skeletonReasonRepost'>
   repost: string
-  [k: string]: unknown
 }
 
-export function isSkeletonReasonRepost(v: unknown): v is SkeletonReasonRepost {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#skeletonReasonRepost'
-  )
+export function isSkeletonReasonRepost<V>(v: V) {
+  return is$typed(v, id, 'skeletonReasonRepost')
+}
+
+export function validateSkeletonReasonRepost(v: unknown) {
+  return lexicons.validate(
+    `${id}#skeletonReasonRepost`,
+    v,
+  ) as ValidationResult<SkeletonReasonRepost>
 }
 
-export function validateSkeletonReasonRepost(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#skeletonReasonRepost', v)
+export function isValidSkeletonReasonRepost<V>(
+  v: V,
+): v is V & $Typed<SkeletonReasonRepost> {
+  return isSkeletonReasonRepost(v) && validateSkeletonReasonRepost(v).success
 }
 
 export interface SkeletonReasonPin {
-  [k: string]: unknown
+  $type?: $Type<'app.bsky.feed.defs', 'skeletonReasonPin'>
+}
+
+export function isSkeletonReasonPin<V>(v: V) {
+  return is$typed(v, id, 'skeletonReasonPin')
 }
 
-export function isSkeletonReasonPin(v: unknown): v is SkeletonReasonPin {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#skeletonReasonPin'
-  )
+export function validateSkeletonReasonPin(v: unknown) {
+  return lexicons.validate(
+    `${id}#skeletonReasonPin`,
+    v,
+  ) as ValidationResult<SkeletonReasonPin>
 }
 
-export function validateSkeletonReasonPin(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#skeletonReasonPin', v)
+export function isValidSkeletonReasonPin<V>(
+  v: V,
+): v is V & $Typed<SkeletonReasonPin> {
+  return isSkeletonReasonPin(v) && validateSkeletonReasonPin(v).success
 }
 
 export interface ThreadgateView {
+  $type?: $Type<'app.bsky.feed.defs', 'threadgateView'>
   uri?: string
   cid?: string
-  record?: {}
+  record?: { [_ in string]: unknown }
   lists?: AppBskyGraphDefs.ListViewBasic[]
-  [k: string]: unknown
 }
 
-export function isThreadgateView(v: unknown): v is ThreadgateView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#threadgateView'
-  )
+export function isThreadgateView<V>(v: V) {
+  return is$typed(v, id, 'threadgateView')
 }
 
-export function validateThreadgateView(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#threadgateView', v)
+export function validateThreadgateView(v: unknown) {
+  return lexicons.validate(
+    `${id}#threadgateView`,
+    v,
+  ) as ValidationResult<ThreadgateView>
+}
+
+export function isValidThreadgateView<V>(
+  v: V,
+): v is V & $Typed<ThreadgateView> {
+  return isThreadgateView(v) && validateThreadgateView(v).success
 }
 
 export interface Interaction {
+  $type?: $Type<'app.bsky.feed.defs', 'interaction'>
   item?: string
   event?:
     | 'app.bsky.feed.defs#requestLess'
@@ -374,42 +432,44 @@ export interface Interaction {
     | (string & {})
   /** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. */
   feedContext?: string
-  [k: string]: unknown
 }
 
-export function isInteraction(v: unknown): v is Interaction {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.defs#interaction'
-  )
+export function isInteraction<V>(v: V) {
+  return is$typed(v, id, 'interaction')
+}
+
+export function validateInteraction(v: unknown) {
+  return lexicons.validate(
+    `${id}#interaction`,
+    v,
+  ) as ValidationResult<Interaction>
 }
 
-export function validateInteraction(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.defs#interaction', v)
+export function isValidInteraction<V>(v: V): v is V & $Typed<Interaction> {
+  return isInteraction(v) && validateInteraction(v).success
 }
 
 /** Request that less content like the given feed item be shown in the feed */
-export const REQUESTLESS = 'app.bsky.feed.defs#requestLess'
+export const REQUESTLESS = `${id}#requestLess`
 /** Request that more content like the given feed item be shown in the feed */
-export const REQUESTMORE = 'app.bsky.feed.defs#requestMore'
+export const REQUESTMORE = `${id}#requestMore`
 /** User clicked through to the feed item */
-export const CLICKTHROUGHITEM = 'app.bsky.feed.defs#clickthroughItem'
+export const CLICKTHROUGHITEM = `${id}#clickthroughItem`
 /** User clicked through to the author of the feed item */
-export const CLICKTHROUGHAUTHOR = 'app.bsky.feed.defs#clickthroughAuthor'
+export const CLICKTHROUGHAUTHOR = `${id}#clickthroughAuthor`
 /** User clicked through to the reposter of the feed item */
-export const CLICKTHROUGHREPOSTER = 'app.bsky.feed.defs#clickthroughReposter'
+export const CLICKTHROUGHREPOSTER = `${id}#clickthroughReposter`
 /** User clicked through to the embedded content of the feed item */
-export const CLICKTHROUGHEMBED = 'app.bsky.feed.defs#clickthroughEmbed'
+export const CLICKTHROUGHEMBED = `${id}#clickthroughEmbed`
 /** Feed item was seen by user */
-export const INTERACTIONSEEN = 'app.bsky.feed.defs#interactionSeen'
+export const INTERACTIONSEEN = `${id}#interactionSeen`
 /** User liked the feed item */
-export const INTERACTIONLIKE = 'app.bsky.feed.defs#interactionLike'
+export const INTERACTIONLIKE = `${id}#interactionLike`
 /** User reposted the feed item */
-export const INTERACTIONREPOST = 'app.bsky.feed.defs#interactionRepost'
+export const INTERACTIONREPOST = `${id}#interactionRepost`
 /** User replied to the feed item */
-export const INTERACTIONREPLY = 'app.bsky.feed.defs#interactionReply'
+export const INTERACTIONREPLY = `${id}#interactionReply`
 /** User quoted the feed item */
-export const INTERACTIONQUOTE = 'app.bsky.feed.defs#interactionQuote'
+export const INTERACTIONQUOTE = `${id}#interactionQuote`
 /** User shared the feed item */
-export const INTERACTIONSHARE = 'app.bsky.feed.defs#interactionShare'
+export const INTERACTIONSHARE = `${id}#interactionShare`