@atproto/api 0.0.4 → 0.0.6

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod2) => function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -23,6 +26,55 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
 ));
 var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
+// ../../node_modules/iso-datestring-validator/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/iso-datestring-validator/dist/index.js"(exports) {
+    (() => {
+      "use strict";
+      var e = { d: (t2, r2) => {
+        for (var n2 in r2)
+          e.o(r2, n2) && !e.o(t2, n2) && Object.defineProperty(t2, n2, { enumerable: true, get: r2[n2] });
+      }, o: (e2, t2) => Object.prototype.hasOwnProperty.call(e2, t2), r: (e2) => {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e2, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e2, "__esModule", { value: true });
+      } }, t = {};
+      function r(e2, t2) {
+        return void 0 === t2 && (t2 = "-"), new RegExp("^(?!0{4}" + t2 + "0{2}" + t2 + "0{2})((?=[0-9]{4}" + t2 + "(((0[^2])|1[0-2])|02(?=" + t2 + "(([0-1][0-9])|2[0-8])))" + t2 + "[0-9]{2})|(?=((([13579][26])|([2468][048])|(0[48]))0{2})|([0-9]{2}((((0|[2468])[48])|[2468][048])|([13579][26])))" + t2 + "02" + t2 + "29))([0-9]{4})" + t2 + "(?!((0[469])|11)" + t2 + "31)((0[1,3-9]|1[0-2])|(02(?!" + t2 + "3)))" + t2 + "(0[1-9]|[1-2][0-9]|3[0-1])$").test(e2);
+      }
+      function n(e2) {
+        var t2 = /\D/.exec(e2);
+        return t2 ? t2[0] : "";
+      }
+      function i(e2, t2, r2) {
+        void 0 === t2 && (t2 = ":"), void 0 === r2 && (r2 = false);
+        var i2 = new RegExp("^([0-1]|2(?=([0-3])|4" + t2 + "00))[0-9]" + t2 + "[0-5][0-9](" + t2 + "([0-5]|6(?=0))[0-9])?(.[0-9]{1,9})?$");
+        if (!r2 || !/[Z+\-]/.test(e2))
+          return i2.test(e2);
+        if (/Z$/.test(e2))
+          return i2.test(e2.replace("Z", ""));
+        var o2 = e2.includes("+"), a2 = e2.split(/[+-]/), u2 = a2[0], d2 = a2[1];
+        return i2.test(u2) && function(e3, t3, r3) {
+          return void 0 === r3 && (r3 = ":"), new RegExp(t3 ? "^(0(?!(2" + r3 + "4)|0" + r3 + "3)|1(?=([0-1]|2(?=" + r3 + "[04])|[34](?=" + r3 + "0))))([03469](?=" + r3 + "[03])|[17](?=" + r3 + "0)|2(?=" + r3 + "[04])|5(?=" + r3 + "[034])|8(?=" + r3 + "[04]))" + r3 + "([03](?=0)|4(?=5))[05]$" : "^(0(?=[^0])|1(?=[0-2]))([39](?=" + r3 + "[03])|[0-24-8](?=" + r3 + "00))" + r3 + "[03]0$").test(e3);
+        }(d2, o2, n(d2));
+      }
+      function o(e2) {
+        var t2 = e2.split("T"), o2 = t2[0], a2 = t2[1], u2 = r(o2, n(o2));
+        if (!a2)
+          return false;
+        var d2, s = (d2 = a2.match(/([^Z+\-\d])(?=\d+\1)/), Array.isArray(d2) ? d2[0] : "");
+        return u2 && i(a2, s, true);
+      }
+      function a(e2, t2) {
+        return void 0 === t2 && (t2 = "-"), new RegExp("^[0-9]{4}" + t2 + "(0(?=[^0])|1(?=[0-2]))[0-9]$").test(e2);
+      }
+      e.r(t), e.d(t, { isValidDate: () => r, isValidISODateString: () => o, isValidTime: () => i, isValidYearMonth: () => a });
+      var u = exports;
+      for (var d in t)
+        u[d] = t[d];
+      t.__esModule && Object.defineProperty(u, "__esModule", { value: true });
+    })();
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -3122,6 +3174,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 +3419,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;
@@ -3381,6 +3445,7 @@ var LexiconDefNotFoundError = class extends Error {
 };
 
 // ../lexicon/src/validators/primitives.ts
+var import_iso_datestring_validator = __toESM(require_dist());
 function validate(lexicons2, path, def, value) {
   switch (def.type) {
     case "boolean":
@@ -3568,8 +3633,7 @@ function datetime(lexicons2, path, def, value) {
   }
   {
     try {
-      const date = new Date(Date.parse(value));
-      if (value !== date.toISOString()) {
+      if (typeof value !== "string" || !(0, import_iso_datestring_validator.isValidISODateString)(value)) {
         throw new ValidationError(
           `${path} must be an iso8601 formatted datetime`
         );
@@ -3932,6 +3996,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 +4247,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 +6419,6 @@ var schemaDict = {
           },
           downvote: {
             type: "string"
-          },
-          muted: {
-            type: "boolean"
           }
         }
       }
@@ -7430,13 +7514,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 +7603,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 +7633,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 +7756,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 +7895,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 +7913,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 +7959,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 +7989,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 +8144,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 +8173,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 +8445,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 +8498,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 = {