@atproto/api 0.13.20 → 0.14.0-next.0

package/src/client/types/app/bsky/feed/post.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 AppBskyRichtextFacet from '../richtext/facet'
 import * as AppBskyEmbedImages from '../embed/images'
 import * as AppBskyEmbedVideo from '../embed/video'
@@ -14,7 +14,10 @@ import * as AppBskyEmbedRecordWithMedia from '../embed/recordWithMedia'
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
 
+const id = 'app.bsky.feed.post'
+
 export interface Record {
+  $type?: $Type<'app.bsky.feed.post', 'main'>
   /** The primary post content. May be an empty string, if there are embeds. */
   text: string
   /** DEPRECATED: replaced by app.bsky.richtext.facet. */
@@ -23,17 +26,15 @@ export interface Record {
   facets?: AppBskyRichtextFacet.Main[]
   reply?: ReplyRef
   embed?:
-    | AppBskyEmbedImages.Main
-    | AppBskyEmbedVideo.Main
-    | AppBskyEmbedExternal.Main
-    | AppBskyEmbedRecord.Main
-    | AppBskyEmbedRecordWithMedia.Main
-    | { $type: string; [k: string]: unknown }
+    | $Typed<AppBskyEmbedImages.Main>
+    | $Typed<AppBskyEmbedVideo.Main>
+    | $Typed<AppBskyEmbedExternal.Main>
+    | $Typed<AppBskyEmbedRecord.Main>
+    | $Typed<AppBskyEmbedRecordWithMedia.Main>
+    | { $type: string }
   /** Indicates human language of post primary text content. */
   langs?: string[]
-  labels?:
-    | ComAtprotoLabelDefs.SelfLabels
-    | { $type: string; [k: string]: unknown }
+  labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }
   /** Additional hashtags, in addition to any included in post text and facets. */
   tags?: string[]
   /** Client-declared timestamp when this post was originally created. */
@@ -41,68 +42,72 @@ export interface Record {
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.feed.post#main' || v.$type === 'app.bsky.feed.post')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.post#main', v)
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
+}
+
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }
 
 export interface ReplyRef {
+  $type?: $Type<'app.bsky.feed.post', 'replyRef'>
   root: ComAtprotoRepoStrongRef.Main
   parent: ComAtprotoRepoStrongRef.Main
-  [k: string]: unknown
 }
 
-export function isReplyRef(v: unknown): v is ReplyRef {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.post#replyRef'
-  )
+export function isReplyRef<V>(v: V) {
+  return is$typed(v, id, 'replyRef')
+}
+
+export function validateReplyRef(v: unknown) {
+  return lexicons.validate(`${id}#replyRef`, v) as ValidationResult<ReplyRef>
 }
 
-export function validateReplyRef(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.post#replyRef', v)
+export function isValidReplyRef<V>(v: V): v is V & $Typed<ReplyRef> {
+  return isReplyRef(v) && validateReplyRef(v).success
 }
 
 /** Deprecated: use facets instead. */
 export interface Entity {
+  $type?: $Type<'app.bsky.feed.post', 'entity'>
   index: TextSlice
   /** Expected values are 'mention' and 'link'. */
   type: string
   value: string
-  [k: string]: unknown
 }
 
-export function isEntity(v: unknown): v is Entity {
-  return (
-    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.post#entity'
-  )
+export function isEntity<V>(v: V) {
+  return is$typed(v, id, 'entity')
+}
+
+export function validateEntity(v: unknown) {
+  return lexicons.validate(`${id}#entity`, v) as ValidationResult<Entity>
 }
 
-export function validateEntity(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.post#entity', v)
+export function isValidEntity<V>(v: V): v is V & $Typed<Entity> {
+  return isEntity(v) && validateEntity(v).success
 }
 
 /** Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings. */
 export interface TextSlice {
+  $type?: $Type<'app.bsky.feed.post', 'textSlice'>
   start: number
   end: number
-  [k: string]: unknown
 }
 
-export function isTextSlice(v: unknown): v is TextSlice {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.post#textSlice'
-  )
+export function isTextSlice<V>(v: V) {
+  return is$typed(v, id, 'textSlice')
+}
+
+export function validateTextSlice(v: unknown) {
+  return lexicons.validate(`${id}#textSlice`, v) as ValidationResult<TextSlice>
 }
 
-export function validateTextSlice(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.post#textSlice', v)
+export function isValidTextSlice<V>(v: V): v is V & $Typed<TextSlice> {
+  return isTextSlice(v) && validateTextSlice(v).success
 }

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

@@ -2,46 +2,51 @@
  * 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'
+
+const id = 'app.bsky.feed.postgate'
 
 export interface Record {
+  $type?: $Type<'app.bsky.feed.postgate', 'main'>
   createdAt: string
   /** Reference (AT-URI) to the post record. */
   post: string
   /** List of AT-URIs embedding this post that the author has detached from. */
   detachedEmbeddingUris?: string[]
-  embeddingRules?: (DisableRule | { $type: string; [k: string]: unknown })[]
+  embeddingRules?: ($Typed<DisableRule> | { $type: string })[]
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.feed.postgate#main' ||
-      v.$type === 'app.bsky.feed.postgate')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
+}
+
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.postgate#main', v)
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }
 
 /** Disables embedding of this post. */
 export interface DisableRule {
-  [k: string]: unknown
+  $type?: $Type<'app.bsky.feed.postgate', 'disableRule'>
+}
+
+export function isDisableRule<V>(v: V) {
+  return is$typed(v, id, 'disableRule')
 }
 
-export function isDisableRule(v: unknown): v is DisableRule {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.postgate#disableRule'
-  )
+export function validateDisableRule(v: unknown) {
+  return lexicons.validate(
+    `${id}#disableRule`,
+    v,
+  ) as ValidationResult<DisableRule>
 }
 
-export function validateDisableRule(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.postgate#disableRule', v)
+export function isValidDisableRule<V>(v: V): v is V & $Typed<DisableRule> {
+  return isDisableRule(v) && validateDisableRule(v).success
 }

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

@@ -2,26 +2,28 @@
  * 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 ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
 
+const id = 'app.bsky.feed.repost'
+
 export interface Record {
+  $type?: $Type<'app.bsky.feed.repost', 'main'>
   subject: ComAtprotoRepoStrongRef.Main
   createdAt: string
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.feed.repost#main' ||
-      v.$type === 'app.bsky.feed.repost')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
+}
+
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.repost#main', v)
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }

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

@@ -3,11 +3,13 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 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 AppBskyFeedDefs from './defs'
 
+const id = 'app.bsky.feed.searchPosts'
+
 export interface QueryParams {
   /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */
   q: string
@@ -41,7 +43,6 @@ export interface OutputSchema {
   /** Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits. */
   hitsTotal?: number
   posts: AppBskyFeedDefs.PostView[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {

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

@@ -3,21 +3,20 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 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 AppBskyFeedDefs from './defs'
 
+const id = 'app.bsky.feed.sendInteractions'
+
 export interface QueryParams {}
 
 export interface InputSchema {
   interactions: AppBskyFeedDefs.Interaction[]
-  [k: string]: unknown
 }
 
-export interface OutputSchema {
-  [k: string]: unknown
-}
+export interface OutputSchema {}
 
 export interface CallOptions {
   signal?: AbortSignal

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

@@ -2,18 +2,21 @@
  * 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'
+
+const id = 'app.bsky.feed.threadgate'
 
 export interface Record {
+  $type?: $Type<'app.bsky.feed.threadgate', 'main'>
   /** Reference (AT-URI) to the post record. */
   post: string
   allow?: (
-    | MentionRule
-    | FollowingRule
-    | ListRule
-    | { $type: string; [k: string]: unknown }
+    | $Typed<MentionRule>
+    | $Typed<FollowingRule>
+    | $Typed<ListRule>
+    | { $type: string }
   )[]
   createdAt: string
   /** List of hidden reply URIs. */
@@ -21,67 +24,72 @@ export interface Record {
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.feed.threadgate#main' ||
-      v.$type === 'app.bsky.feed.threadgate')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.threadgate#main', v)
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
+}
+
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }
 
 /** Allow replies from actors mentioned in your post. */
 export interface MentionRule {
-  [k: string]: unknown
+  $type?: $Type<'app.bsky.feed.threadgate', 'mentionRule'>
+}
+
+export function isMentionRule<V>(v: V) {
+  return is$typed(v, id, 'mentionRule')
 }
 
-export function isMentionRule(v: unknown): v is MentionRule {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.threadgate#mentionRule'
-  )
+export function validateMentionRule(v: unknown) {
+  return lexicons.validate(
+    `${id}#mentionRule`,
+    v,
+  ) as ValidationResult<MentionRule>
 }
 
-export function validateMentionRule(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.threadgate#mentionRule', v)
+export function isValidMentionRule<V>(v: V): v is V & $Typed<MentionRule> {
+  return isMentionRule(v) && validateMentionRule(v).success
 }
 
 /** Allow replies from actors you follow. */
 export interface FollowingRule {
-  [k: string]: unknown
+  $type?: $Type<'app.bsky.feed.threadgate', 'followingRule'>
+}
+
+export function isFollowingRule<V>(v: V) {
+  return is$typed(v, id, 'followingRule')
 }
 
-export function isFollowingRule(v: unknown): v is FollowingRule {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.threadgate#followingRule'
-  )
+export function validateFollowingRule(v: unknown) {
+  return lexicons.validate(
+    `${id}#followingRule`,
+    v,
+  ) as ValidationResult<FollowingRule>
 }
 
-export function validateFollowingRule(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.threadgate#followingRule', v)
+export function isValidFollowingRule<V>(v: V): v is V & $Typed<FollowingRule> {
+  return isFollowingRule(v) && validateFollowingRule(v).success
 }
 
 /** Allow replies from actors on a list. */
 export interface ListRule {
+  $type?: $Type<'app.bsky.feed.threadgate', 'listRule'>
   list: string
-  [k: string]: unknown
 }
 
-export function isListRule(v: unknown): v is ListRule {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'app.bsky.feed.threadgate#listRule'
-  )
+export function isListRule<V>(v: V) {
+  return is$typed(v, id, 'listRule')
+}
+
+export function validateListRule(v: unknown) {
+  return lexicons.validate(`${id}#listRule`, v) as ValidationResult<ListRule>
 }
 
-export function validateListRule(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.feed.threadgate#listRule', v)
+export function isValidListRule<V>(v: V): v is V & $Typed<ListRule> {
+  return isListRule(v) && validateListRule(v).success
 }

package/src/client/types/app/bsky/graph/block.ts

@@ -2,26 +2,28 @@
  * 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'
+
+const id = 'app.bsky.graph.block'
 
 export interface Record {
+  $type?: $Type<'app.bsky.graph.block', 'main'>
   /** DID of the account to be blocked. */
   subject: string
   createdAt: string
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.graph.block#main' ||
-      v.$type === 'app.bsky.graph.block')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
+}
+
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.graph.block#main', v)
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }