@atproto/api 0.0.4 → 0.0.5

package/dist/index.js

@@ -3122,6 +3122,18 @@ var XRPCError = class extends Error {
     }
   }
 };
+var XRPCInvalidResponseError = class extends XRPCError {
+  constructor(lexiconNsid, validationError, responseBody) {
+    super(
+      2 /* InvalidResponse */,
+      ResponseTypeStrings[2 /* InvalidResponse */],
+      `The server gave an invalid response and may be out of date.`
+    );
+    this.lexiconNsid = lexiconNsid;
+    this.validationError = validationError;
+    this.responseBody = responseBody;
+  }
+};
 
 // ../nsid/src/index.ts
 var SEGMENT_RE = /^[a-zA-Z]([a-zA-Z0-9-])*$/;
@@ -3355,7 +3367,7 @@ var lexiconDoc = mod.object({
   }
 });
 function isObj(obj) {
-  return !!obj && typeof obj === "object";
+  return obj !== null && typeof obj === "object";
 }
 function hasProp(data, prop) {
   return prop in data;
@@ -3932,6 +3944,20 @@ var Lexicons = class {
     }
     return def;
   }
+  validate(lexUri, value) {
+    lexUri = toLexUri(lexUri);
+    const def = this.getDefOrThrow(lexUri, ["record", "object"]);
+    if (!isObj(value)) {
+      throw new ValidationError(`Value must be an object`);
+    }
+    if (def.type === "record") {
+      return object(this, "Record", def.record, value);
+    } else if (def.type === "object") {
+      return object(this, "Object", def, value);
+    } else {
+      throw new InvalidLexiconError("Definition must be a record or object");
+    }
+  }
   assertValidRecord(lexUri, value) {
     lexUri = toLexUri(lexUri);
     const def = this.getDefOrThrow(lexUri, ["record"]);
@@ -4169,6 +4195,15 @@ var ServiceClient = class {
     );
     const resCode = httpResponseCodeToEnum(res.status);
     if (resCode === 200 /* Success */) {
+      try {
+        this.baseClient.lex.assertValidXrpcOutput(methodNsid, res.body);
+      } catch (e) {
+        if (e instanceof ValidationError) {
+          throw new XRPCInvalidResponseError(methodNsid, e, res.body);
+        } else {
+          throw e;
+        }
+      }
       return new XRPCResponse(res.body, res.headers);
     } else {
       if (res.body && isErrorResponseBody(res.body)) {
@@ -6332,9 +6367,6 @@ var schemaDict = {
           },
           downvote: {
             type: "string"
-          },
-          muted: {
-            type: "boolean"
           }
         }
       }
@@ -7430,13 +7462,47 @@ function toKnownErr8(e) {
 // src/client/types/com/atproto/repo/batchWrite.ts
 var batchWrite_exports = {};
 __export(batchWrite_exports, {
-  toKnownErr: () => toKnownErr9
+  isCreate: () => isCreate,
+  isDelete: () => isDelete,
+  isUpdate: () => isUpdate,
+  toKnownErr: () => toKnownErr9,
+  validateCreate: () => validateCreate,
+  validateDelete: () => validateDelete,
+  validateUpdate: () => validateUpdate
 });
+
+// src/client/util.ts
+function isObj2(v) {
+  return typeof v === "object" && v !== null;
+}
+function hasProp2(data, prop) {
+  return prop in data;
+}
+
+// src/client/types/com/atproto/repo/batchWrite.ts
 function toKnownErr9(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isCreate(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.repo.batchWrite#create";
+}
+function validateCreate(v) {
+  return lexicons.validate("com.atproto.repo.batchWrite#create", v);
+}
+function isUpdate(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.repo.batchWrite#update";
+}
+function validateUpdate(v) {
+  return lexicons.validate("com.atproto.repo.batchWrite#update", v);
+}
+function isDelete(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.repo.batchWrite#delete";
+}
+function validateDelete(v) {
+  return lexicons.validate("com.atproto.repo.batchWrite#delete", v);
+}
 
 // src/client/types/com/atproto/repo/createRecord.ts
 var createRecord_exports = {};
@@ -7485,13 +7551,21 @@ function toKnownErr13(e) {
 // src/client/types/com/atproto/repo/listRecords.ts
 var listRecords_exports = {};
 __export(listRecords_exports, {
-  toKnownErr: () => toKnownErr14
+  isRecord: () => isRecord,
+  toKnownErr: () => toKnownErr14,
+  validateRecord: () => validateRecord
 });
 function toKnownErr14(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isRecord(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.repo.listRecords#record";
+}
+function validateRecord(v) {
+  return lexicons.validate("com.atproto.repo.listRecords#record", v);
+}
 
 // src/client/types/com/atproto/repo/putRecord.ts
 var putRecord_exports = {};
@@ -7507,13 +7581,21 @@ function toKnownErr15(e) {
 // src/client/types/com/atproto/server/getAccountsConfig.ts
 var getAccountsConfig_exports = {};
 __export(getAccountsConfig_exports, {
-  toKnownErr: () => toKnownErr16
+  isLinks: () => isLinks,
+  toKnownErr: () => toKnownErr16,
+  validateLinks: () => validateLinks
 });
 function toKnownErr16(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isLinks(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.server.getAccountsConfig#links";
+}
+function validateLinks(v) {
+  return lexicons.validate("com.atproto.server.getAccountsConfig#links", v);
+}
 
 // src/client/types/com/atproto/session/create.ts
 var create_exports2 = {};
@@ -7622,46 +7704,86 @@ function toKnownErr24(e) {
 // src/client/types/app/bsky/actor/getProfile.ts
 var getProfile_exports = {};
 __export(getProfile_exports, {
-  toKnownErr: () => toKnownErr25
+  isMyState: () => isMyState,
+  toKnownErr: () => toKnownErr25,
+  validateMyState: () => validateMyState
 });
 function toKnownErr25(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isMyState(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.getProfile#myState";
+}
+function validateMyState(v) {
+  return lexicons.validate("app.bsky.actor.getProfile#myState", v);
+}
 
 // src/client/types/app/bsky/actor/getSuggestions.ts
 var getSuggestions_exports = {};
 __export(getSuggestions_exports, {
-  toKnownErr: () => toKnownErr26
+  isActor: () => isActor,
+  isMyState: () => isMyState2,
+  toKnownErr: () => toKnownErr26,
+  validateActor: () => validateActor,
+  validateMyState: () => validateMyState2
 });
 function toKnownErr26(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isActor(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.getSuggestions#actor";
+}
+function validateActor(v) {
+  return lexicons.validate("app.bsky.actor.getSuggestions#actor", v);
+}
+function isMyState2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.getSuggestions#myState";
+}
+function validateMyState2(v) {
+  return lexicons.validate("app.bsky.actor.getSuggestions#myState", v);
+}
 
 // src/client/types/app/bsky/actor/search.ts
 var search_exports = {};
 __export(search_exports, {
-  toKnownErr: () => toKnownErr27
+  isUser: () => isUser,
+  toKnownErr: () => toKnownErr27,
+  validateUser: () => validateUser
 });
 function toKnownErr27(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isUser(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.search#user";
+}
+function validateUser(v) {
+  return lexicons.validate("app.bsky.actor.search#user", v);
+}
 
 // src/client/types/app/bsky/actor/searchTypeahead.ts
 var searchTypeahead_exports = {};
 __export(searchTypeahead_exports, {
-  toKnownErr: () => toKnownErr28
+  isUser: () => isUser2,
+  toKnownErr: () => toKnownErr28,
+  validateUser: () => validateUser2
 });
 function toKnownErr28(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isUser2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.searchTypeahead#user";
+}
+function validateUser2(v) {
+  return lexicons.validate("app.bsky.actor.searchTypeahead#user", v);
+}
 
 // src/client/types/app/bsky/actor/updateProfile.ts
 var updateProfile_exports = {};
@@ -7721,7 +7843,11 @@ function toKnownErr30(e) {
 var getPostThread_exports = {};
 __export(getPostThread_exports, {
   NotFoundError: () => NotFoundError,
-  toKnownErr: () => toKnownErr31
+  isNotFoundPost: () => isNotFoundPost,
+  isThreadViewPost: () => isThreadViewPost,
+  toKnownErr: () => toKnownErr31,
+  validateNotFoundPost: () => validateNotFoundPost,
+  validateThreadViewPost: () => validateThreadViewPost
 });
 var NotFoundError = class extends XRPCError {
   constructor(src) {
@@ -7735,17 +7861,37 @@ function toKnownErr31(e) {
   }
   return e;
 }
+function isThreadViewPost(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.getPostThread#threadViewPost";
+}
+function validateThreadViewPost(v) {
+  return lexicons.validate("app.bsky.feed.getPostThread#threadViewPost", v);
+}
+function isNotFoundPost(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.getPostThread#notFoundPost";
+}
+function validateNotFoundPost(v) {
+  return lexicons.validate("app.bsky.feed.getPostThread#notFoundPost", v);
+}
 
 // src/client/types/app/bsky/feed/getRepostedBy.ts
 var getRepostedBy_exports = {};
 __export(getRepostedBy_exports, {
-  toKnownErr: () => toKnownErr32
+  isRepostedBy: () => isRepostedBy,
+  toKnownErr: () => toKnownErr32,
+  validateRepostedBy: () => validateRepostedBy
 });
 function toKnownErr32(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isRepostedBy(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.getRepostedBy#repostedBy";
+}
+function validateRepostedBy(v) {
+  return lexicons.validate("app.bsky.feed.getRepostedBy#repostedBy", v);
+}
 
 // src/client/types/app/bsky/feed/getTimeline.ts
 var getTimeline_exports = {};
@@ -7761,13 +7907,21 @@ function toKnownErr33(e) {
 // src/client/types/app/bsky/feed/getVotes.ts
 var getVotes_exports = {};
 __export(getVotes_exports, {
-  toKnownErr: () => toKnownErr34
+  isVote: () => isVote,
+  toKnownErr: () => toKnownErr34,
+  validateVote: () => validateVote
 });
 function toKnownErr34(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isVote(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.getVotes#vote";
+}
+function validateVote(v) {
+  return lexicons.validate("app.bsky.feed.getVotes#vote", v);
+}
 
 // src/client/types/app/bsky/feed/setVote.ts
 var setVote_exports = {};
@@ -7783,68 +7937,124 @@ function toKnownErr35(e) {
 // src/client/types/app/bsky/graph/getAssertions.ts
 var getAssertions_exports = {};
 __export(getAssertions_exports, {
-  toKnownErr: () => toKnownErr36
+  isAssertion: () => isAssertion,
+  isConfirmation: () => isConfirmation,
+  toKnownErr: () => toKnownErr36,
+  validateAssertion: () => validateAssertion,
+  validateConfirmation: () => validateConfirmation
 });
 function toKnownErr36(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isAssertion(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getAssertions#assertion";
+}
+function validateAssertion(v) {
+  return lexicons.validate("app.bsky.graph.getAssertions#assertion", v);
+}
+function isConfirmation(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getAssertions#confirmation";
+}
+function validateConfirmation(v) {
+  return lexicons.validate("app.bsky.graph.getAssertions#confirmation", v);
+}
 
 // src/client/types/app/bsky/graph/getFollowers.ts
 var getFollowers_exports = {};
 __export(getFollowers_exports, {
-  toKnownErr: () => toKnownErr37
+  isFollower: () => isFollower,
+  toKnownErr: () => toKnownErr37,
+  validateFollower: () => validateFollower
 });
 function toKnownErr37(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isFollower(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getFollowers#follower";
+}
+function validateFollower(v) {
+  return lexicons.validate("app.bsky.graph.getFollowers#follower", v);
+}
 
 // src/client/types/app/bsky/graph/getFollows.ts
 var getFollows_exports = {};
 __export(getFollows_exports, {
-  toKnownErr: () => toKnownErr38
+  isFollow: () => isFollow,
+  toKnownErr: () => toKnownErr38,
+  validateFollow: () => validateFollow
 });
 function toKnownErr38(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isFollow(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getFollows#follow";
+}
+function validateFollow(v) {
+  return lexicons.validate("app.bsky.graph.getFollows#follow", v);
+}
 
 // src/client/types/app/bsky/graph/getMembers.ts
 var getMembers_exports = {};
 __export(getMembers_exports, {
-  toKnownErr: () => toKnownErr39
+  isMember: () => isMember,
+  toKnownErr: () => toKnownErr39,
+  validateMember: () => validateMember
 });
 function toKnownErr39(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isMember(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getMembers#member";
+}
+function validateMember(v) {
+  return lexicons.validate("app.bsky.graph.getMembers#member", v);
+}
 
 // src/client/types/app/bsky/graph/getMemberships.ts
 var getMemberships_exports = {};
 __export(getMemberships_exports, {
-  toKnownErr: () => toKnownErr40
+  isMembership: () => isMembership,
+  toKnownErr: () => toKnownErr40,
+  validateMembership: () => validateMembership
 });
 function toKnownErr40(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isMembership(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getMemberships#membership";
+}
+function validateMembership(v) {
+  return lexicons.validate("app.bsky.graph.getMemberships#membership", v);
+}
 
 // src/client/types/app/bsky/graph/getMutes.ts
 var getMutes_exports = {};
 __export(getMutes_exports, {
-  toKnownErr: () => toKnownErr41
+  isMute: () => isMute,
+  toKnownErr: () => toKnownErr41,
+  validateMute: () => validateMute
 });
 function toKnownErr41(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isMute(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.getMutes#mute";
+}
+function validateMute(v) {
+  return lexicons.validate("app.bsky.graph.getMutes#mute", v);
+}
 
 // src/client/types/app/bsky/graph/mute.ts
 var mute_exports = {};
@@ -7882,13 +8092,21 @@ function toKnownErr44(e) {
 // src/client/types/app/bsky/notification/list.ts
 var list_exports = {};
 __export(list_exports, {
-  toKnownErr: () => toKnownErr45
+  isNotification: () => isNotification,
+  toKnownErr: () => toKnownErr45,
+  validateNotification: () => validateNotification
 });
 function toKnownErr45(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
+function isNotification(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.notification.list#notification";
+}
+function validateNotification(v) {
+  return lexicons.validate("app.bsky.notification.list#notification", v);
+}
 
 // src/client/types/app/bsky/notification/updateSeen.ts
 var updateSeen_exports = {};
@@ -7903,33 +8121,261 @@ function toKnownErr46(e) {
 
 // src/client/types/com/atproto/repo/strongRef.ts
 var strongRef_exports = {};
+__export(strongRef_exports, {
+  isMain: () => isMain,
+  validateMain: () => validateMain
+});
+function isMain(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "com.atproto.repo.strongRef#main" || v.$type === "com.atproto.repo.strongRef");
+}
+function validateMain(v) {
+  return lexicons.validate("com.atproto.repo.strongRef#main", v);
+}
 
 // src/client/types/app/bsky/actor/profile.ts
 var profile_exports = {};
+__export(profile_exports, {
+  isRecord: () => isRecord2,
+  validateRecord: () => validateRecord2
+});
+function isRecord2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.actor.profile#main" || v.$type === "app.bsky.actor.profile");
+}
+function validateRecord2(v) {
+  return lexicons.validate("app.bsky.actor.profile#main", v);
+}
 
 // src/client/types/app/bsky/actor/ref.ts
 var ref_exports = {};
+__export(ref_exports, {
+  isMain: () => isMain2,
+  isViewerState: () => isViewerState,
+  isWithInfo: () => isWithInfo,
+  validateMain: () => validateMain2,
+  validateViewerState: () => validateViewerState,
+  validateWithInfo: () => validateWithInfo
+});
+function isMain2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.actor.ref#main" || v.$type === "app.bsky.actor.ref");
+}
+function validateMain2(v) {
+  return lexicons.validate("app.bsky.actor.ref#main", v);
+}
+function isWithInfo(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.ref#withInfo";
+}
+function validateWithInfo(v) {
+  return lexicons.validate("app.bsky.actor.ref#withInfo", v);
+}
+function isViewerState(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.ref#viewerState";
+}
+function validateViewerState(v) {
+  return lexicons.validate("app.bsky.actor.ref#viewerState", v);
+}
 
 // src/client/types/app/bsky/embed/external.ts
 var external_exports = {};
+__export(external_exports, {
+  isExternal: () => isExternal,
+  isMain: () => isMain3,
+  isPresented: () => isPresented,
+  isPresentedExternal: () => isPresentedExternal,
+  validateExternal: () => validateExternal,
+  validateMain: () => validateMain3,
+  validatePresented: () => validatePresented,
+  validatePresentedExternal: () => validatePresentedExternal
+});
+function isMain3(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.embed.external#main" || v.$type === "app.bsky.embed.external");
+}
+function validateMain3(v) {
+  return lexicons.validate("app.bsky.embed.external#main", v);
+}
+function isExternal(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.external#external";
+}
+function validateExternal(v) {
+  return lexicons.validate("app.bsky.embed.external#external", v);
+}
+function isPresented(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.external#presented";
+}
+function validatePresented(v) {
+  return lexicons.validate("app.bsky.embed.external#presented", v);
+}
+function isPresentedExternal(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.external#presentedExternal";
+}
+function validatePresentedExternal(v) {
+  return lexicons.validate("app.bsky.embed.external#presentedExternal", v);
+}
 
 // src/client/types/app/bsky/embed/images.ts
 var images_exports = {};
+__export(images_exports, {
+  isImage: () => isImage,
+  isMain: () => isMain4,
+  isPresented: () => isPresented2,
+  isPresentedImage: () => isPresentedImage,
+  validateImage: () => validateImage,
+  validateMain: () => validateMain4,
+  validatePresented: () => validatePresented2,
+  validatePresentedImage: () => validatePresentedImage
+});
+function isMain4(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.embed.images#main" || v.$type === "app.bsky.embed.images");
+}
+function validateMain4(v) {
+  return lexicons.validate("app.bsky.embed.images#main", v);
+}
+function isImage(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.images#image";
+}
+function validateImage(v) {
+  return lexicons.validate("app.bsky.embed.images#image", v);
+}
+function isPresented2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.images#presented";
+}
+function validatePresented2(v) {
+  return lexicons.validate("app.bsky.embed.images#presented", v);
+}
+function isPresentedImage(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.embed.images#presentedImage";
+}
+function validatePresentedImage(v) {
+  return lexicons.validate("app.bsky.embed.images#presentedImage", v);
+}
 
 // src/client/types/app/bsky/feed/feedViewPost.ts
 var feedViewPost_exports = {};
+__export(feedViewPost_exports, {
+  isMain: () => isMain5,
+  isReasonRepost: () => isReasonRepost,
+  isReasonTrend: () => isReasonTrend,
+  isReplyRef: () => isReplyRef,
+  validateMain: () => validateMain5,
+  validateReasonRepost: () => validateReasonRepost,
+  validateReasonTrend: () => validateReasonTrend,
+  validateReplyRef: () => validateReplyRef
+});
+function isMain5(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.feedViewPost#main" || v.$type === "app.bsky.feed.feedViewPost");
+}
+function validateMain5(v) {
+  return lexicons.validate("app.bsky.feed.feedViewPost#main", v);
+}
+function isReplyRef(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.feedViewPost#replyRef";
+}
+function validateReplyRef(v) {
+  return lexicons.validate("app.bsky.feed.feedViewPost#replyRef", v);
+}
+function isReasonTrend(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.feedViewPost#reasonTrend";
+}
+function validateReasonTrend(v) {
+  return lexicons.validate("app.bsky.feed.feedViewPost#reasonTrend", v);
+}
+function isReasonRepost(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.feedViewPost#reasonRepost";
+}
+function validateReasonRepost(v) {
+  return lexicons.validate("app.bsky.feed.feedViewPost#reasonRepost", v);
+}
 
 // src/client/types/app/bsky/feed/post.ts
 var post_exports = {};
+__export(post_exports, {
+  isEntity: () => isEntity,
+  isRecord: () => isRecord3,
+  isReplyRef: () => isReplyRef2,
+  isTextSlice: () => isTextSlice,
+  isView: () => isView,
+  isViewerState: () => isViewerState2,
+  validateEntity: () => validateEntity,
+  validateRecord: () => validateRecord3,
+  validateReplyRef: () => validateReplyRef2,
+  validateTextSlice: () => validateTextSlice,
+  validateView: () => validateView,
+  validateViewerState: () => validateViewerState2
+});
+function isRecord3(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.post#main" || v.$type === "app.bsky.feed.post");
+}
+function validateRecord3(v) {
+  return lexicons.validate("app.bsky.feed.post#main", v);
+}
+function isReplyRef2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#replyRef";
+}
+function validateReplyRef2(v) {
+  return lexicons.validate("app.bsky.feed.post#replyRef", v);
+}
+function isEntity(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#entity";
+}
+function validateEntity(v) {
+  return lexicons.validate("app.bsky.feed.post#entity", v);
+}
+function isTextSlice(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#textSlice";
+}
+function validateTextSlice(v) {
+  return lexicons.validate("app.bsky.feed.post#textSlice", v);
+}
+function isView(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#view";
+}
+function validateView(v) {
+  return lexicons.validate("app.bsky.feed.post#view", v);
+}
+function isViewerState2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#viewerState";
+}
+function validateViewerState2(v) {
+  return lexicons.validate("app.bsky.feed.post#viewerState", v);
+}
 
 // src/client/types/app/bsky/feed/repost.ts
 var repost_exports = {};
+__export(repost_exports, {
+  isRecord: () => isRecord4,
+  validateRecord: () => validateRecord4
+});
+function isRecord4(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.repost#main" || v.$type === "app.bsky.feed.repost");
+}
+function validateRecord4(v) {
+  return lexicons.validate("app.bsky.feed.repost#main", v);
+}
 
 // src/client/types/app/bsky/feed/trend.ts
 var trend_exports = {};
+__export(trend_exports, {
+  isRecord: () => isRecord5,
+  validateRecord: () => validateRecord5
+});
+function isRecord5(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.trend#main" || v.$type === "app.bsky.feed.trend");
+}
+function validateRecord5(v) {
+  return lexicons.validate("app.bsky.feed.trend#main", v);
+}
 
 // src/client/types/app/bsky/feed/vote.ts
 var vote_exports = {};
+__export(vote_exports, {
+  isRecord: () => isRecord6,
+  validateRecord: () => validateRecord6
+});
+function isRecord6(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.vote#main" || v.$type === "app.bsky.feed.vote");
+}
+function validateRecord6(v) {
+  return lexicons.validate("app.bsky.feed.vote#main", v);
+}
 
 // src/client/types/app/bsky/graph/assertCreator.ts
 var assertCreator_exports = {};
@@ -7947,12 +8393,42 @@ var MAIN2 = "app.bsky.graph.assertMember#main";
 
 // src/client/types/app/bsky/graph/assertion.ts
 var assertion_exports = {};
+__export(assertion_exports, {
+  isRecord: () => isRecord7,
+  validateRecord: () => validateRecord7
+});
+function isRecord7(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.assertion#main" || v.$type === "app.bsky.graph.assertion");
+}
+function validateRecord7(v) {
+  return lexicons.validate("app.bsky.graph.assertion#main", v);
+}
 
 // src/client/types/app/bsky/graph/confirmation.ts
 var confirmation_exports = {};
+__export(confirmation_exports, {
+  isRecord: () => isRecord8,
+  validateRecord: () => validateRecord8
+});
+function isRecord8(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.confirmation#main" || v.$type === "app.bsky.graph.confirmation");
+}
+function validateRecord8(v) {
+  return lexicons.validate("app.bsky.graph.confirmation#main", v);
+}
 
 // src/client/types/app/bsky/graph/follow.ts
 var follow_exports = {};
+__export(follow_exports, {
+  isRecord: () => isRecord9,
+  validateRecord: () => validateRecord9
+});
+function isRecord9(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.follow#main" || v.$type === "app.bsky.graph.follow");
+}
+function validateRecord9(v) {
+  return lexicons.validate("app.bsky.graph.follow#main", v);
+}
 
 // src/client/types/app/bsky/system/actorScene.ts
 var actorScene_exports = {};
@@ -7970,9 +8446,29 @@ var MAIN4 = "app.bsky.system.actorUser#main";
 
 // src/client/types/app/bsky/system/declRef.ts
 var declRef_exports = {};
+__export(declRef_exports, {
+  isMain: () => isMain6,
+  validateMain: () => validateMain6
+});
+function isMain6(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.system.declRef#main" || v.$type === "app.bsky.system.declRef");
+}
+function validateMain6(v) {
+  return lexicons.validate("app.bsky.system.declRef#main", v);
+}
 
 // src/client/types/app/bsky/system/declaration.ts
 var declaration_exports = {};
+__export(declaration_exports, {
+  isRecord: () => isRecord10,
+  validateRecord: () => validateRecord10
+});
+function isRecord10(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.system.declaration#main" || v.$type === "app.bsky.system.declaration");
+}
+function validateRecord10(v) {
+  return lexicons.validate("app.bsky.system.declaration#main", v);
+}
 
 // src/client/index.ts
 var APP_BSKY_GRAPH = {