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

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

@@ -3,13 +3,19 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as AppBskyEmbedRecord from './record'
-import * as AppBskyEmbedImages from './images'
-import * as AppBskyEmbedVideo from './video'
-import * as AppBskyEmbedExternal from './external'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyEmbedRecord from './record'
+import type * as AppBskyEmbedImages from './images'
+import type * as AppBskyEmbedVideo from './video'
+import type * as AppBskyEmbedExternal from './external'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'app.bsky.embed.recordWithMedia'
 
 export interface Main {
@@ -22,16 +28,18 @@ export interface Main {
     | { $type: string }
 }
 
+const hashMain = 'main'
+
 export function isMain<V>(v: V) {
-  return is$typed(v, id, 'main')
+  return is$typed(v, id, hashMain)
 }
 
-export function validateMain(v: unknown) {
-  return lexicons.validate(`${id}#main`, v) as ValidationResult<Main>
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
 }
 
-export function isValidMain<V>(v: V): v is V & $Typed<Main> {
-  return isMain(v) && validateMain(v).success
+export function isValidMain<V>(v: V) {
+  return isValid<Main>(v, id, hashMain)
 }
 
 export interface View {
@@ -44,14 +52,16 @@ export interface View {
     | { $type: string }
 }
 
+const hashView = 'view'
+
 export function isView<V>(v: V) {
-  return is$typed(v, id, 'view')
+  return is$typed(v, id, hashView)
 }
 
-export function validateView(v: unknown) {
-  return lexicons.validate(`${id}#view`, v) as ValidationResult<View>
+export function validateView<V>(v: V) {
+  return validate<View & V>(v, id, hashView)
 }
 
-export function isValidView<V>(v: V): v is V & $Typed<View> {
-  return isView(v) && validateView(v).success
+export function isValidView<V>(v: V) {
+  return isValid<View>(v, id, hashView)
 }

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

@@ -3,10 +3,16 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as AppBskyEmbedDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyEmbedDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'app.bsky.embed.video'
 
 export interface Main {
@@ -18,16 +24,18 @@ export interface Main {
   aspectRatio?: AppBskyEmbedDefs.AspectRatio
 }
 
+const hashMain = 'main'
+
 export function isMain<V>(v: V) {
-  return is$typed(v, id, 'main')
+  return is$typed(v, id, hashMain)
 }
 
-export function validateMain(v: unknown) {
-  return lexicons.validate(`${id}#main`, v) as ValidationResult<Main>
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
 }
 
-export function isValidMain<V>(v: V): v is V & $Typed<Main> {
-  return isMain(v) && validateMain(v).success
+export function isValidMain<V>(v: V) {
+  return isValid<Main>(v, id, hashMain)
 }
 
 export interface Caption {
@@ -36,16 +44,18 @@ export interface Caption {
   file: BlobRef
 }
 
+const hashCaption = 'caption'
+
 export function isCaption<V>(v: V) {
-  return is$typed(v, id, 'caption')
+  return is$typed(v, id, hashCaption)
 }
 
-export function validateCaption(v: unknown) {
-  return lexicons.validate(`${id}#caption`, v) as ValidationResult<Caption>
+export function validateCaption<V>(v: V) {
+  return validate<Caption & V>(v, id, hashCaption)
 }
 
-export function isValidCaption<V>(v: V): v is V & $Typed<Caption> {
-  return isCaption(v) && validateCaption(v).success
+export function isValidCaption<V>(v: V) {
+  return isValid<Caption>(v, id, hashCaption)
 }
 
 export interface View {
@@ -57,14 +67,16 @@ export interface View {
   aspectRatio?: AppBskyEmbedDefs.AspectRatio
 }
 
+const hashView = 'view'
+
 export function isView<V>(v: V) {
-  return is$typed(v, id, 'view')
+  return is$typed(v, id, hashView)
 }
 
-export function validateView(v: unknown) {
-  return lexicons.validate(`${id}#view`, v) as ValidationResult<View>
+export function validateView<V>(v: V) {
+  return validate<View & V>(v, id, hashView)
 }
 
-export function isValidView<V>(v: V): v is V & $Typed<View> {
-  return isView(v) && validateView(v).success
+export function isValidView<V>(v: V) {
+  return isValid<View>(v, id, hashView)
 }

package/src/client/types/app/bsky/feed/defs.ts

@@ -3,18 +3,24 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as AppBskyActorDefs from '../actor/defs'
-import * as AppBskyEmbedImages from '../embed/images'
-import * as AppBskyEmbedVideo from '../embed/video'
-import * as AppBskyEmbedExternal from '../embed/external'
-import * as AppBskyEmbedRecord from '../embed/record'
-import * as AppBskyEmbedRecordWithMedia from '../embed/recordWithMedia'
-import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
-import * as AppBskyRichtextFacet from '../richtext/facet'
-import * as AppBskyGraphDefs from '../graph/defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyActorDefs from '../actor/defs'
+import type * as AppBskyEmbedImages from '../embed/images'
+import type * as AppBskyEmbedVideo from '../embed/video'
+import type * as AppBskyEmbedExternal from '../embed/external'
+import type * as AppBskyEmbedRecord from '../embed/record'
+import type * as AppBskyEmbedRecordWithMedia from '../embed/recordWithMedia'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+import type * as AppBskyRichtextFacet from '../richtext/facet'
+import type * as AppBskyGraphDefs from '../graph/defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'app.bsky.feed.defs'
 
 export interface PostView {
@@ -40,16 +46,18 @@ export interface PostView {
   threadgate?: ThreadgateView
 }
 
+const hashPostView = 'postView'
+
 export function isPostView<V>(v: V) {
-  return is$typed(v, id, 'postView')
+  return is$typed(v, id, hashPostView)
 }
 
-export function validatePostView(v: unknown) {
-  return lexicons.validate(`${id}#postView`, v) as ValidationResult<PostView>
+export function validatePostView<V>(v: V) {
+  return validate<PostView & V>(v, id, hashPostView)
 }
 
-export function isValidPostView<V>(v: V): v is V & $Typed<PostView> {
-  return isPostView(v) && validatePostView(v).success
+export function isValidPostView<V>(v: V) {
+  return isValid<PostView>(v, id, hashPostView)
 }
 
 /** Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests. */
@@ -63,19 +71,18 @@ export interface ViewerState {
   pinned?: boolean
 }
 
+const hashViewerState = 'viewerState'
+
 export function isViewerState<V>(v: V) {
-  return is$typed(v, id, 'viewerState')
+  return is$typed(v, id, hashViewerState)
 }
 
-export function validateViewerState(v: unknown) {
-  return lexicons.validate(
-    `${id}#viewerState`,
-    v,
-  ) as ValidationResult<ViewerState>
+export function validateViewerState<V>(v: V) {
+  return validate<ViewerState & V>(v, id, hashViewerState)
 }
 
-export function isValidViewerState<V>(v: V): v is V & $Typed<ViewerState> {
-  return isViewerState(v) && validateViewerState(v).success
+export function isValidViewerState<V>(v: V) {
+  return isValid<ViewerState>(v, id, hashViewerState)
 }
 
 export interface FeedViewPost {
@@ -87,19 +94,18 @@ export interface FeedViewPost {
   feedContext?: string
 }
 
+const hashFeedViewPost = 'feedViewPost'
+
 export function isFeedViewPost<V>(v: V) {
-  return is$typed(v, id, 'feedViewPost')
+  return is$typed(v, id, hashFeedViewPost)
 }
 
-export function validateFeedViewPost(v: unknown) {
-  return lexicons.validate(
-    `${id}#feedViewPost`,
-    v,
-  ) as ValidationResult<FeedViewPost>
+export function validateFeedViewPost<V>(v: V) {
+  return validate<FeedViewPost & V>(v, id, hashFeedViewPost)
 }
 
-export function isValidFeedViewPost<V>(v: V): v is V & $Typed<FeedViewPost> {
-  return isFeedViewPost(v) && validateFeedViewPost(v).success
+export function isValidFeedViewPost<V>(v: V) {
+  return isValid<FeedViewPost>(v, id, hashFeedViewPost)
 }
 
 export interface ReplyRef {
@@ -117,16 +123,18 @@ export interface ReplyRef {
   grandparentAuthor?: AppBskyActorDefs.ProfileViewBasic
 }
 
+const hashReplyRef = 'replyRef'
+
 export function isReplyRef<V>(v: V) {
-  return is$typed(v, id, 'replyRef')
+  return is$typed(v, id, hashReplyRef)
 }
 
-export function validateReplyRef(v: unknown) {
-  return lexicons.validate(`${id}#replyRef`, v) as ValidationResult<ReplyRef>
+export function validateReplyRef<V>(v: V) {
+  return validate<ReplyRef & V>(v, id, hashReplyRef)
 }
 
-export function isValidReplyRef<V>(v: V): v is V & $Typed<ReplyRef> {
-  return isReplyRef(v) && validateReplyRef(v).success
+export function isValidReplyRef<V>(v: V) {
+  return isValid<ReplyRef>(v, id, hashReplyRef)
 }
 
 export interface ReasonRepost {
@@ -135,35 +143,36 @@ export interface ReasonRepost {
   indexedAt: string
 }
 
+const hashReasonRepost = 'reasonRepost'
+
 export function isReasonRepost<V>(v: V) {
-  return is$typed(v, id, 'reasonRepost')
+  return is$typed(v, id, hashReasonRepost)
 }
 
-export function validateReasonRepost(v: unknown) {
-  return lexicons.validate(
-    `${id}#reasonRepost`,
-    v,
-  ) as ValidationResult<ReasonRepost>
+export function validateReasonRepost<V>(v: V) {
+  return validate<ReasonRepost & V>(v, id, hashReasonRepost)
 }
 
-export function isValidReasonRepost<V>(v: V): v is V & $Typed<ReasonRepost> {
-  return isReasonRepost(v) && validateReasonRepost(v).success
+export function isValidReasonRepost<V>(v: V) {
+  return isValid<ReasonRepost>(v, id, hashReasonRepost)
 }
 
 export interface ReasonPin {
   $type?: $Type<'app.bsky.feed.defs', 'reasonPin'>
 }
 
+const hashReasonPin = 'reasonPin'
+
 export function isReasonPin<V>(v: V) {
-  return is$typed(v, id, 'reasonPin')
+  return is$typed(v, id, hashReasonPin)
 }
 
-export function validateReasonPin(v: unknown) {
-  return lexicons.validate(`${id}#reasonPin`, v) as ValidationResult<ReasonPin>
+export function validateReasonPin<V>(v: V) {
+  return validate<ReasonPin & V>(v, id, hashReasonPin)
 }
 
-export function isValidReasonPin<V>(v: V): v is V & $Typed<ReasonPin> {
-  return isReasonPin(v) && validateReasonPin(v).success
+export function isValidReasonPin<V>(v: V) {
+  return isValid<ReasonPin>(v, id, hashReasonPin)
 }
 
 export interface ThreadViewPost {
@@ -182,21 +191,18 @@ export interface ThreadViewPost {
   )[]
 }
 
+const hashThreadViewPost = 'threadViewPost'
+
 export function isThreadViewPost<V>(v: V) {
-  return is$typed(v, id, 'threadViewPost')
+  return is$typed(v, id, hashThreadViewPost)
 }
 
-export function validateThreadViewPost(v: unknown) {
-  return lexicons.validate(
-    `${id}#threadViewPost`,
-    v,
-  ) as ValidationResult<ThreadViewPost>
+export function validateThreadViewPost<V>(v: V) {
+  return validate<ThreadViewPost & V>(v, id, hashThreadViewPost)
 }
 
-export function isValidThreadViewPost<V>(
-  v: V,
-): v is V & $Typed<ThreadViewPost> {
-  return isThreadViewPost(v) && validateThreadViewPost(v).success
+export function isValidThreadViewPost<V>(v: V) {
+  return isValid<ThreadViewPost>(v, id, hashThreadViewPost)
 }
 
 export interface NotFoundPost {
@@ -205,19 +211,18 @@ export interface NotFoundPost {
   notFound: true
 }
 
+const hashNotFoundPost = 'notFoundPost'
+
 export function isNotFoundPost<V>(v: V) {
-  return is$typed(v, id, 'notFoundPost')
+  return is$typed(v, id, hashNotFoundPost)
 }
 
-export function validateNotFoundPost(v: unknown) {
-  return lexicons.validate(
-    `${id}#notFoundPost`,
-    v,
-  ) as ValidationResult<NotFoundPost>
+export function validateNotFoundPost<V>(v: V) {
+  return validate<NotFoundPost & V>(v, id, hashNotFoundPost)
 }
 
-export function isValidNotFoundPost<V>(v: V): v is V & $Typed<NotFoundPost> {
-  return isNotFoundPost(v) && validateNotFoundPost(v).success
+export function isValidNotFoundPost<V>(v: V) {
+  return isValid<NotFoundPost>(v, id, hashNotFoundPost)
 }
 
 export interface BlockedPost {
@@ -227,19 +232,18 @@ export interface BlockedPost {
   author: BlockedAuthor
 }
 
+const hashBlockedPost = 'blockedPost'
+
 export function isBlockedPost<V>(v: V) {
-  return is$typed(v, id, 'blockedPost')
+  return is$typed(v, id, hashBlockedPost)
 }
 
-export function validateBlockedPost(v: unknown) {
-  return lexicons.validate(
-    `${id}#blockedPost`,
-    v,
-  ) as ValidationResult<BlockedPost>
+export function validateBlockedPost<V>(v: V) {
+  return validate<BlockedPost & V>(v, id, hashBlockedPost)
 }
 
-export function isValidBlockedPost<V>(v: V): v is V & $Typed<BlockedPost> {
-  return isBlockedPost(v) && validateBlockedPost(v).success
+export function isValidBlockedPost<V>(v: V) {
+  return isValid<BlockedPost>(v, id, hashBlockedPost)
 }
 
 export interface BlockedAuthor {
@@ -248,19 +252,18 @@ export interface BlockedAuthor {
   viewer?: AppBskyActorDefs.ViewerState
 }
 
+const hashBlockedAuthor = 'blockedAuthor'
+
 export function isBlockedAuthor<V>(v: V) {
-  return is$typed(v, id, 'blockedAuthor')
+  return is$typed(v, id, hashBlockedAuthor)
 }
 
-export function validateBlockedAuthor(v: unknown) {
-  return lexicons.validate(
-    `${id}#blockedAuthor`,
-    v,
-  ) as ValidationResult<BlockedAuthor>
+export function validateBlockedAuthor<V>(v: V) {
+  return validate<BlockedAuthor & V>(v, id, hashBlockedAuthor)
 }
 
-export function isValidBlockedAuthor<V>(v: V): v is V & $Typed<BlockedAuthor> {
-  return isBlockedAuthor(v) && validateBlockedAuthor(v).success
+export function isValidBlockedAuthor<V>(v: V) {
+  return isValid<BlockedAuthor>(v, id, hashBlockedAuthor)
 }
 
 export interface GeneratorView {
@@ -280,19 +283,18 @@ export interface GeneratorView {
   indexedAt: string
 }
 
+const hashGeneratorView = 'generatorView'
+
 export function isGeneratorView<V>(v: V) {
-  return is$typed(v, id, 'generatorView')
+  return is$typed(v, id, hashGeneratorView)
 }
 
-export function validateGeneratorView(v: unknown) {
-  return lexicons.validate(
-    `${id}#generatorView`,
-    v,
-  ) as ValidationResult<GeneratorView>
+export function validateGeneratorView<V>(v: V) {
+  return validate<GeneratorView & V>(v, id, hashGeneratorView)
 }
 
-export function isValidGeneratorView<V>(v: V): v is V & $Typed<GeneratorView> {
-  return isGeneratorView(v) && validateGeneratorView(v).success
+export function isValidGeneratorView<V>(v: V) {
+  return isValid<GeneratorView>(v, id, hashGeneratorView)
 }
 
 export interface GeneratorViewerState {
@@ -300,21 +302,18 @@ export interface GeneratorViewerState {
   like?: string
 }
 
+const hashGeneratorViewerState = 'generatorViewerState'
+
 export function isGeneratorViewerState<V>(v: V) {
-  return is$typed(v, id, 'generatorViewerState')
+  return is$typed(v, id, hashGeneratorViewerState)
 }
 
-export function validateGeneratorViewerState(v: unknown) {
-  return lexicons.validate(
-    `${id}#generatorViewerState`,
-    v,
-  ) as ValidationResult<GeneratorViewerState>
+export function validateGeneratorViewerState<V>(v: V) {
+  return validate<GeneratorViewerState & V>(v, id, hashGeneratorViewerState)
 }
 
-export function isValidGeneratorViewerState<V>(
-  v: V,
-): v is V & $Typed<GeneratorViewerState> {
-  return isGeneratorViewerState(v) && validateGeneratorViewerState(v).success
+export function isValidGeneratorViewerState<V>(v: V) {
+  return isValid<GeneratorViewerState>(v, id, hashGeneratorViewerState)
 }
 
 export interface SkeletonFeedPost {
@@ -328,21 +327,18 @@ export interface SkeletonFeedPost {
   feedContext?: string
 }
 
+const hashSkeletonFeedPost = 'skeletonFeedPost'
+
 export function isSkeletonFeedPost<V>(v: V) {
-  return is$typed(v, id, 'skeletonFeedPost')
+  return is$typed(v, id, hashSkeletonFeedPost)
 }
 
-export function validateSkeletonFeedPost(v: unknown) {
-  return lexicons.validate(
-    `${id}#skeletonFeedPost`,
-    v,
-  ) as ValidationResult<SkeletonFeedPost>
+export function validateSkeletonFeedPost<V>(v: V) {
+  return validate<SkeletonFeedPost & V>(v, id, hashSkeletonFeedPost)
 }
 
-export function isValidSkeletonFeedPost<V>(
-  v: V,
-): v is V & $Typed<SkeletonFeedPost> {
-  return isSkeletonFeedPost(v) && validateSkeletonFeedPost(v).success
+export function isValidSkeletonFeedPost<V>(v: V) {
+  return isValid<SkeletonFeedPost>(v, id, hashSkeletonFeedPost)
 }
 
 export interface SkeletonReasonRepost {
@@ -350,42 +346,36 @@ export interface SkeletonReasonRepost {
   repost: string
 }
 
+const hashSkeletonReasonRepost = 'skeletonReasonRepost'
+
 export function isSkeletonReasonRepost<V>(v: V) {
-  return is$typed(v, id, 'skeletonReasonRepost')
+  return is$typed(v, id, hashSkeletonReasonRepost)
 }
 
-export function validateSkeletonReasonRepost(v: unknown) {
-  return lexicons.validate(
-    `${id}#skeletonReasonRepost`,
-    v,
-  ) as ValidationResult<SkeletonReasonRepost>
+export function validateSkeletonReasonRepost<V>(v: V) {
+  return validate<SkeletonReasonRepost & V>(v, id, hashSkeletonReasonRepost)
 }
 
-export function isValidSkeletonReasonRepost<V>(
-  v: V,
-): v is V & $Typed<SkeletonReasonRepost> {
-  return isSkeletonReasonRepost(v) && validateSkeletonReasonRepost(v).success
+export function isValidSkeletonReasonRepost<V>(v: V) {
+  return isValid<SkeletonReasonRepost>(v, id, hashSkeletonReasonRepost)
 }
 
 export interface SkeletonReasonPin {
   $type?: $Type<'app.bsky.feed.defs', 'skeletonReasonPin'>
 }
 
+const hashSkeletonReasonPin = 'skeletonReasonPin'
+
 export function isSkeletonReasonPin<V>(v: V) {
-  return is$typed(v, id, 'skeletonReasonPin')
+  return is$typed(v, id, hashSkeletonReasonPin)
 }
 
-export function validateSkeletonReasonPin(v: unknown) {
-  return lexicons.validate(
-    `${id}#skeletonReasonPin`,
-    v,
-  ) as ValidationResult<SkeletonReasonPin>
+export function validateSkeletonReasonPin<V>(v: V) {
+  return validate<SkeletonReasonPin & V>(v, id, hashSkeletonReasonPin)
 }
 
-export function isValidSkeletonReasonPin<V>(
-  v: V,
-): v is V & $Typed<SkeletonReasonPin> {
-  return isSkeletonReasonPin(v) && validateSkeletonReasonPin(v).success
+export function isValidSkeletonReasonPin<V>(v: V) {
+  return isValid<SkeletonReasonPin>(v, id, hashSkeletonReasonPin)
 }
 
 export interface ThreadgateView {
@@ -396,21 +386,18 @@ export interface ThreadgateView {
   lists?: AppBskyGraphDefs.ListViewBasic[]
 }
 
+const hashThreadgateView = 'threadgateView'
+
 export function isThreadgateView<V>(v: V) {
-  return is$typed(v, id, 'threadgateView')
+  return is$typed(v, id, hashThreadgateView)
 }
 
-export function validateThreadgateView(v: unknown) {
-  return lexicons.validate(
-    `${id}#threadgateView`,
-    v,
-  ) as ValidationResult<ThreadgateView>
+export function validateThreadgateView<V>(v: V) {
+  return validate<ThreadgateView & V>(v, id, hashThreadgateView)
 }
 
-export function isValidThreadgateView<V>(
-  v: V,
-): v is V & $Typed<ThreadgateView> {
-  return isThreadgateView(v) && validateThreadgateView(v).success
+export function isValidThreadgateView<V>(v: V) {
+  return isValid<ThreadgateView>(v, id, hashThreadgateView)
 }
 
 export interface Interaction {
@@ -434,19 +421,18 @@ export interface Interaction {
   feedContext?: string
 }
 
+const hashInteraction = 'interaction'
+
 export function isInteraction<V>(v: V) {
-  return is$typed(v, id, 'interaction')
+  return is$typed(v, id, hashInteraction)
 }
 
-export function validateInteraction(v: unknown) {
-  return lexicons.validate(
-    `${id}#interaction`,
-    v,
-  ) as ValidationResult<Interaction>
+export function validateInteraction<V>(v: V) {
+  return validate<Interaction & V>(v, id, hashInteraction)
 }
 
-export function isValidInteraction<V>(v: V): v is V & $Typed<Interaction> {
-  return isInteraction(v) && validateInteraction(v).success
+export function isValidInteraction<V>(v: V) {
+  return isValid<Interaction>(v, id, hashInteraction)
 }
 
 /** Request that less content like the given feed item be shown in the feed */