@atproto/api 0.0.3 → 0.0.5

package/dist/index.js

@@ -61,6 +61,9 @@ __export(src_exports, {
   AppBskyGraphGetFollows: () => getFollows_exports,
   AppBskyGraphGetMembers: () => getMembers_exports,
   AppBskyGraphGetMemberships: () => getMemberships_exports,
+  AppBskyGraphGetMutes: () => getMutes_exports,
+  AppBskyGraphMute: () => mute_exports,
+  AppBskyGraphUnmute: () => unmute_exports,
   AppBskyNotificationGetCount: () => getCount_exports,
   AppBskyNotificationList: () => list_exports,
   AppBskyNotificationUpdateSeen: () => updateSeen_exports,
@@ -3119,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-])*$/;
@@ -3352,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;
@@ -3929,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"]);
@@ -4166,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)) {
@@ -5240,6 +5278,9 @@ var schemaDict = {
           },
           member: {
             type: "string"
+          },
+          muted: {
+            type: "boolean"
           }
         }
       }
@@ -5351,15 +5392,15 @@ var schemaDict = {
             avatar: {
               type: "image",
               accept: ["image/png", "image/jpeg"],
-              maxWidth: 500,
-              maxHeight: 500,
+              maxWidth: 1e3,
+              maxHeight: 1e3,
               maxSize: 3e5
             },
             banner: {
               type: "image",
               accept: ["image/png", "image/jpeg"],
-              maxWidth: 1500,
-              maxHeight: 500,
+              maxWidth: 3e3,
+              maxHeight: 1e3,
               maxSize: 5e5
             }
           }
@@ -5404,6 +5445,18 @@ var schemaDict = {
           },
           avatar: {
             type: "string"
+          },
+          viewer: {
+            type: "ref",
+            ref: "lex:app.bsky.actor.ref#viewerState"
+          }
+        }
+      },
+      viewerState: {
+        type: "object",
+        properties: {
+          muted: {
+            type: "boolean"
           }
         }
       }
@@ -5655,9 +5708,9 @@ var schemaDict = {
           thumb: {
             type: "image",
             accept: ["image/*"],
-            maxWidth: 250,
-            maxHeight: 250,
-            maxSize: 1e5
+            maxWidth: 1e3,
+            maxHeight: 1e3,
+            maxSize: 3e5
           }
         }
       },
@@ -5717,8 +5770,8 @@ var schemaDict = {
           image: {
             type: "image",
             accept: ["image/*"],
-            maxWidth: 500,
-            maxHeight: 500,
+            maxWidth: 1e3,
+            maxHeight: 1e3,
             maxSize: 3e5
           },
           alt: {
@@ -6234,6 +6287,7 @@ var schemaDict = {
       },
       textSlice: {
         type: "object",
+        description: "A text segment. Start is inclusive, end is exclusive.",
         required: ["start", "end"],
         properties: {
           start: {
@@ -6954,6 +7008,116 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphGetMutes: {
+    lexicon: 1,
+    id: "app.bsky.graph.getMutes",
+    defs: {
+      main: {
+        type: "query",
+        description: "Who does the viewer mute?",
+        parameters: {
+          type: "params",
+          properties: {
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            before: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["mutes"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              mutes: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.graph.getMutes#mute"
+                }
+              }
+            }
+          }
+        }
+      },
+      mute: {
+        type: "object",
+        required: ["did", "declaration", "handle", "createdAt"],
+        properties: {
+          did: {
+            type: "string"
+          },
+          declaration: {
+            type: "ref",
+            ref: "lex:app.bsky.system.declRef"
+          },
+          handle: {
+            type: "string"
+          },
+          displayName: {
+            type: "string",
+            maxLength: 64
+          },
+          createdAt: {
+            type: "datetime"
+          }
+        }
+      }
+    }
+  },
+  AppBskyGraphMute: {
+    lexicon: 1,
+    id: "app.bsky.graph.mute",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Mute an actor by did or handle.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["user"],
+            properties: {
+              user: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyGraphUnmute: {
+    lexicon: 1,
+    id: "app.bsky.graph.unmute",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Unmute an actor by did or handle.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["user"],
+            properties: {
+              user: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyNotificationGetCount: {
     lexicon: 1,
     id: "app.bsky.notification.getCount",
@@ -7298,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 = {};
@@ -7353,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 = {};
@@ -7375,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 = {};
@@ -7490,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 = {};
@@ -7589,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) {
@@ -7603,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 = {};
@@ -7629,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 = {};
@@ -7651,64 +7937,153 @@ 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, {
+  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 = {};
+__export(mute_exports, {
+  toKnownErr: () => toKnownErr42
+});
+function toKnownErr42(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/graph/unmute.ts
+var unmute_exports = {};
+__export(unmute_exports, {
+  toKnownErr: () => toKnownErr43
+});
+function toKnownErr43(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
 
 // src/client/types/app/bsky/notification/getCount.ts
 var getCount_exports = {};
 __export(getCount_exports, {
-  toKnownErr: () => toKnownErr41
+  toKnownErr: () => toKnownErr44
 });
-function toKnownErr41(e) {
+function toKnownErr44(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7717,20 +8092,28 @@ function toKnownErr41(e) {
 // src/client/types/app/bsky/notification/list.ts
 var list_exports = {};
 __export(list_exports, {
-  toKnownErr: () => toKnownErr42
+  isNotification: () => isNotification,
+  toKnownErr: () => toKnownErr45,
+  validateNotification: () => validateNotification
 });
-function toKnownErr42(e) {
+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 = {};
 __export(updateSeen_exports, {
-  toKnownErr: () => toKnownErr43
+  toKnownErr: () => toKnownErr46
 });
-function toKnownErr43(e) {
+function toKnownErr46(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7738,33 +8121,261 @@ function toKnownErr43(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 = {};
@@ -7782,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 = {};
@@ -7805,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 = {
@@ -8322,6 +8983,21 @@ var GraphNS = class {
       throw toKnownErr40(e);
     });
   }
+  getMutes(params2, opts) {
+    return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
+      throw toKnownErr41(e);
+    });
+  }
+  mute(data, opts) {
+    return this._service.xrpc.call("app.bsky.graph.mute", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr42(e);
+    });
+  }
+  unmute(data, opts) {
+    return this._service.xrpc.call("app.bsky.graph.unmute", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr43(e);
+    });
+  }
 };
 var AssertionRecord = class {
   constructor(service) {
@@ -8440,17 +9116,17 @@ var NotificationNS = class {
   }
   getCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr41(e);
+      throw toKnownErr44(e);
     });
   }
   list(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.list", params2, void 0, opts).catch((e) => {
-      throw toKnownErr42(e);
+      throw toKnownErr45(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr43(e);
+      throw toKnownErr46(e);
     });
   }
 };
@@ -8658,6 +9334,9 @@ var SessionManager = class extends import_events.default {
   AppBskyGraphGetFollows,
   AppBskyGraphGetMembers,
   AppBskyGraphGetMemberships,
+  AppBskyGraphGetMutes,
+  AppBskyGraphMute,
+  AppBskyGraphUnmute,
   AppBskyNotificationGetCount,
   AppBskyNotificationList,
   AppBskyNotificationUpdateSeen,