@atproto/api 0.0.6 → 0.0.7

package/dist/index.js

@@ -82,7 +82,7 @@ __export(src_exports, {
   APP_BSKY_SYSTEM: () => APP_BSKY_SYSTEM,
   AccountNS: () => AccountNS,
   ActorNS: () => ActorNS,
-  AppBskyActorCreateScene: () => createScene_exports,
+  AdminNS: () => AdminNS,
   AppBskyActorGetProfile: () => getProfile_exports,
   AppBskyActorGetSuggestions: () => getSuggestions_exports,
   AppBskyActorProfile: () => profile_exports,
@@ -101,25 +101,20 @@ __export(src_exports, {
   AppBskyFeedPost: () => post_exports,
   AppBskyFeedRepost: () => repost_exports,
   AppBskyFeedSetVote: () => setVote_exports,
-  AppBskyFeedTrend: () => trend_exports,
   AppBskyFeedVote: () => vote_exports,
   AppBskyGraphAssertCreator: () => assertCreator_exports,
   AppBskyGraphAssertMember: () => assertMember_exports,
   AppBskyGraphAssertion: () => assertion_exports,
   AppBskyGraphConfirmation: () => confirmation_exports,
   AppBskyGraphFollow: () => follow_exports,
-  AppBskyGraphGetAssertions: () => getAssertions_exports,
   AppBskyGraphGetFollowers: () => getFollowers_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,
-  AppBskySystemActorScene: () => actorScene_exports,
   AppBskySystemActorUser: () => actorUser_exports,
   AppBskySystemDeclRef: () => declRef_exports,
   AppBskySystemDeclaration: () => declaration_exports,
@@ -128,6 +123,8 @@ __export(src_exports, {
   AtprotoNS: () => AtprotoNS,
   BlobNS: () => BlobNS,
   BskyNS: () => BskyNS,
+  COM_ATPROTO_ADMIN: () => COM_ATPROTO_ADMIN,
+  COM_ATPROTO_REPORT: () => COM_ATPROTO_REPORT,
   Client: () => Client2,
   ComAtprotoAccountCreate: () => create_exports,
   ComAtprotoAccountCreateInviteCode: () => createInviteCode_exports,
@@ -135,24 +132,45 @@ __export(src_exports, {
   ComAtprotoAccountGet: () => get_exports,
   ComAtprotoAccountRequestPasswordReset: () => requestPasswordReset_exports,
   ComAtprotoAccountResetPassword: () => resetPassword_exports,
+  ComAtprotoAdminGetModerationAction: () => getModerationAction_exports,
+  ComAtprotoAdminGetModerationActions: () => getModerationActions_exports,
+  ComAtprotoAdminGetModerationReport: () => getModerationReport_exports,
+  ComAtprotoAdminGetModerationReports: () => getModerationReports_exports,
+  ComAtprotoAdminGetRecord: () => getRecord_exports,
+  ComAtprotoAdminGetRepo: () => getRepo_exports,
+  ComAtprotoAdminModerationAction: () => moderationAction_exports,
+  ComAtprotoAdminModerationReport: () => moderationReport_exports,
+  ComAtprotoAdminRecord: () => record_exports,
+  ComAtprotoAdminRepo: () => repo_exports,
+  ComAtprotoAdminResolveModerationReports: () => resolveModerationReports_exports,
+  ComAtprotoAdminReverseModerationAction: () => reverseModerationAction_exports,
+  ComAtprotoAdminSearchRepos: () => searchRepos_exports,
+  ComAtprotoAdminTakeModerationAction: () => takeModerationAction_exports,
   ComAtprotoBlobUpload: () => upload_exports,
   ComAtprotoHandleResolve: () => resolve_exports,
   ComAtprotoRepoBatchWrite: () => batchWrite_exports,
   ComAtprotoRepoCreateRecord: () => createRecord_exports,
   ComAtprotoRepoDeleteRecord: () => deleteRecord_exports,
   ComAtprotoRepoDescribe: () => describe_exports,
-  ComAtprotoRepoGetRecord: () => getRecord_exports,
+  ComAtprotoRepoGetRecord: () => getRecord_exports2,
   ComAtprotoRepoListRecords: () => listRecords_exports,
   ComAtprotoRepoPutRecord: () => putRecord_exports,
+  ComAtprotoRepoRecordRef: () => recordRef_exports,
+  ComAtprotoRepoRepoRef: () => repoRef_exports,
   ComAtprotoRepoStrongRef: () => strongRef_exports,
+  ComAtprotoReportCreate: () => create_exports2,
+  ComAtprotoReportReasonType: () => reasonType_exports,
+  ComAtprotoReportSubject: () => subject_exports,
   ComAtprotoServerGetAccountsConfig: () => getAccountsConfig_exports,
-  ComAtprotoSessionCreate: () => create_exports2,
+  ComAtprotoSessionCreate: () => create_exports3,
   ComAtprotoSessionDelete: () => delete_exports2,
   ComAtprotoSessionGet: () => get_exports2,
   ComAtprotoSessionRefresh: () => refresh_exports,
-  ComAtprotoSyncGetRepo: () => getRepo_exports,
-  ComAtprotoSyncGetRoot: () => getRoot_exports,
-  ComAtprotoSyncUpdateRepo: () => updateRepo_exports,
+  ComAtprotoSyncGetCheckout: () => getCheckout_exports,
+  ComAtprotoSyncGetCommitPath: () => getCommitPath_exports,
+  ComAtprotoSyncGetHead: () => getHead_exports,
+  ComAtprotoSyncGetRecord: () => getRecord_exports3,
+  ComAtprotoSyncGetRepo: () => getRepo_exports2,
   ComNS: () => ComNS,
   ConfirmationRecord: () => ConfirmationRecord,
   DeclarationRecord: () => DeclarationRecord,
@@ -165,6 +183,7 @@ __export(src_exports, {
   PostRecord: () => PostRecord,
   ProfileRecord: () => ProfileRecord,
   RepoNS: () => RepoNS,
+  ReportNS: () => ReportNS,
   RepostRecord: () => RepostRecord,
   ServerNS: () => ServerNS,
   ServiceClient: () => ServiceClient2,
@@ -175,7 +194,6 @@ __export(src_exports, {
   SessionXrpcServiceClient: () => SessionXrpcServiceClient,
   SyncNS: () => SyncNS,
   SystemNS: () => SystemNS,
-  TrendRecord: () => TrendRecord,
   VoteRecord: () => VoteRecord,
   default: () => client_default,
   sessionClient: () => session_default
@@ -3335,6 +3353,11 @@ var lexArray = mod.object({
   minLength: mod.number().int().optional(),
   maxLength: mod.number().int().optional()
 });
+var lexPrimitiveArray = lexArray.merge(
+  mod.object({
+    items: lexPrimitive
+  })
+);
 var lexToken = mod.object({
   type: mod.literal("token"),
   description: mod.string().optional()
@@ -3349,7 +3372,7 @@ var lexXrpcParameters = mod.object({
   type: mod.literal("params"),
   description: mod.string().optional(),
   required: mod.string().array().optional(),
-  properties: mod.record(lexPrimitive)
+  properties: mod.record(mod.union([lexPrimitive, lexPrimitiveArray]))
 });
 var lexXrpcBody = mod.object({
   description: mod.string().optional(),
@@ -3721,7 +3744,6 @@ function validate2(lexicons2, path, def, value) {
   }
 }
 function array(lexicons2, path, def, value) {
-  def = def;
   if (!Array.isArray(value)) {
     return {
       success: false,
@@ -3769,7 +3791,7 @@ function object(lexicons2, path, def, value) {
   }
   if (Array.isArray(def.required)) {
     for (const key of def.required) {
-      if (!(key in value)) {
+      if (typeof value[key] === "undefined") {
         return {
           success: false,
           error: new ValidationError(`${path} must have the property "${key}"`)
@@ -3873,13 +3895,12 @@ function toConcreteTypes(lexicons2, def) {
 
 // ../lexicon/src/validators/xrpc.ts
 function params(lexicons2, path, def, value) {
-  def = def;
   if (!value || typeof value !== "object") {
     value = {};
   }
   if (Array.isArray(def.required)) {
     for (const key of def.required) {
-      if (!(key in value)) {
+      if (typeof value[key] === "undefined") {
         return {
           success: false,
           error: new ValidationError(`${path} must have the property "${key}"`)
@@ -3892,12 +3913,8 @@ function params(lexicons2, path, def, value) {
       continue;
     }
     const paramDef = def.properties[key];
-    const res = validate(
-      lexicons2,
-      key,
-      paramDef,
-      value[key]
-    );
+    const val = value[key];
+    const res = paramDef.type === "array" ? array(lexicons2, key, paramDef, val) : validate(lexicons2, key, paramDef, val);
     if (!res.success) {
       return res;
     }
@@ -4090,7 +4107,17 @@ function constructMethodCallUri(nsid, schema, serviceUri, params2) {
         throw new Error(`Invalid query parameter: ${key}`);
       }
       if (value !== void 0) {
-        uri.searchParams.set(key, encodeQueryParam(paramSchema.type, value));
+        if (paramSchema.type === "array") {
+          const vals = [];
+          vals.concat(value).forEach((val) => {
+            uri.searchParams.append(
+              key,
+              encodeQueryParam(paramSchema.items.type, val)
+            );
+          });
+        } else {
+          uri.searchParams.set(key, encodeQueryParam(paramSchema.type, value));
+        }
       }
     }
   }
@@ -4268,11 +4295,13 @@ var ServiceClient = class {
 };
 async function defaultFetchHandler(httpUri, httpMethod, httpHeaders, httpReqBody) {
   try {
-    const res = await fetch(httpUri, {
+    const reqInit = {
       method: httpMethod,
       headers: httpHeaders,
-      body: encodeMethodCallBody(httpHeaders, httpReqBody)
-    });
+      body: encodeMethodCallBody(httpHeaders, httpReqBody),
+      duplex: "half"
+    };
+    const res = await fetch(httpUri, reqInit);
     const resBody = await res.arrayBuffer();
     return {
       status: res.status,
@@ -4470,44 +4499,53 @@ var schemaDict = {
       }
     }
   },
-  ComAtprotoBlobUpload: {
+  ComAtprotoAdminGetModerationAction: {
     lexicon: 1,
-    id: "com.atproto.blob.upload",
+    id: "com.atproto.admin.getModerationAction",
     defs: {
       main: {
-        type: "procedure",
-        description: "Upload a new blob to be added to repo in a later request.",
-        input: {
-          encoding: "*/*"
+        type: "query",
+        description: "View details about a moderation action.",
+        parameters: {
+          type: "params",
+          required: ["id"],
+          properties: {
+            id: {
+              type: "number"
+            }
+          }
         },
         output: {
           encoding: "application/json",
           schema: {
-            type: "object",
-            required: ["cid"],
-            properties: {
-              cid: {
-                type: "string"
-              }
-            }
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#viewDetail"
           }
         }
       }
     }
   },
-  ComAtprotoHandleResolve: {
+  ComAtprotoAdminGetModerationActions: {
     lexicon: 1,
-    id: "com.atproto.handle.resolve",
+    id: "com.atproto.admin.getModerationActions",
     defs: {
       main: {
         type: "query",
-        description: "Provides the DID of a repo.",
+        description: "List moderation actions related to a subject.",
         parameters: {
           type: "params",
           properties: {
-            handle: {
-              type: "string",
-              description: "The handle to resolve. If not supplied, will resolve the host's own handle."
+            subject: {
+              type: "string"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            before: {
+              type: "string"
             }
           }
         },
@@ -4515,10 +4553,17 @@ var schemaDict = {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["did"],
+            required: ["actions"],
             properties: {
-              did: {
+              cursor: {
                 type: "string"
+              },
+              actions: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:com.atproto.admin.moderationAction#view"
+                }
               }
             }
           }
@@ -4526,130 +4571,56 @@ var schemaDict = {
       }
     }
   },
-  ComAtprotoRepoBatchWrite: {
+  ComAtprotoAdminGetModerationReport: {
     lexicon: 1,
-    id: "com.atproto.repo.batchWrite",
+    id: "com.atproto.admin.getModerationReport",
     defs: {
       main: {
-        type: "procedure",
-        description: "Apply a batch transaction of creates, puts, and deletes.",
-        input: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["did", "writes"],
-            properties: {
-              did: {
-                type: "string",
-                description: "The DID of the repo."
-              },
-              validate: {
-                type: "boolean",
-                default: true,
-                description: "Validate the records?"
-              },
-              writes: {
-                type: "array",
-                items: {
-                  type: "union",
-                  refs: [
-                    "lex:com.atproto.repo.batchWrite#create",
-                    "lex:com.atproto.repo.batchWrite#update",
-                    "lex:com.atproto.repo.batchWrite#delete"
-                  ],
-                  closed: true
-                }
-              }
+        type: "query",
+        description: "View details about a moderation report.",
+        parameters: {
+          type: "params",
+          required: ["id"],
+          properties: {
+            id: {
+              type: "number"
             }
           }
-        }
-      },
-      create: {
-        type: "object",
-        required: ["action", "collection", "value"],
-        properties: {
-          action: {
-            type: "string",
-            const: "create"
-          },
-          collection: {
-            type: "string"
-          },
-          rkey: {
-            type: "string"
-          },
-          value: {
-            type: "unknown"
-          }
-        }
-      },
-      update: {
-        type: "object",
-        required: ["action", "collection", "rkey", "value"],
-        properties: {
-          action: {
-            type: "string",
-            const: "update"
-          },
-          collection: {
-            type: "string"
-          },
-          rkey: {
-            type: "string"
-          },
-          value: {
-            type: "unknown"
-          }
-        }
-      },
-      delete: {
-        type: "object",
-        required: ["action", "collection", "rkey"],
-        properties: {
-          action: {
-            type: "string",
-            const: "delete"
-          },
-          collection: {
-            type: "string"
-          },
-          rkey: {
-            type: "string"
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationReport#viewDetail"
           }
         }
       }
     }
   },
-  ComAtprotoRepoCreateRecord: {
+  ComAtprotoAdminGetModerationReports: {
     lexicon: 1,
-    id: "com.atproto.repo.createRecord",
+    id: "com.atproto.admin.getModerationReports",
     defs: {
       main: {
-        type: "procedure",
-        description: "Create a new record.",
-        input: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["did", "collection", "record"],
-            properties: {
-              did: {
-                type: "string",
-                description: "The DID of the repo."
-              },
-              collection: {
-                type: "string",
-                description: "The NSID of the record collection."
-              },
-              validate: {
-                type: "boolean",
-                default: true,
-                description: "Validate the record?"
-              },
-              record: {
-                type: "unknown",
-                description: "The record to create."
-              }
+        type: "query",
+        description: "List moderation reports related to a subject.",
+        parameters: {
+          type: "params",
+          properties: {
+            subject: {
+              type: "string"
+            },
+            resolved: {
+              type: "boolean"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            before: {
+              type: "string"
             }
           }
         },
@@ -4657,13 +4628,17 @@ var schemaDict = {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["uri", "cid"],
+            required: ["reports"],
             properties: {
-              uri: {
+              cursor: {
                 type: "string"
               },
-              cid: {
-                type: "string"
+              reports: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:com.atproto.admin.moderationReport#view"
+                }
               }
             }
           }
@@ -4671,68 +4646,924 @@ var schemaDict = {
       }
     }
   },
-  ComAtprotoRepoDeleteRecord: {
+  ComAtprotoAdminGetRecord: {
     lexicon: 1,
-    id: "com.atproto.repo.deleteRecord",
+    id: "com.atproto.admin.getRecord",
     defs: {
       main: {
-        type: "procedure",
-        description: "Delete a record.",
-        input: {
+        type: "query",
+        description: "View details about a record.",
+        parameters: {
+          type: "params",
+          required: ["uri"],
+          properties: {
+            uri: {
+              type: "string"
+            },
+            cid: {
+              type: "string"
+            }
+          }
+        },
+        output: {
           encoding: "application/json",
           schema: {
-            type: "object",
-            required: ["did", "collection", "rkey"],
-            properties: {
-              did: {
-                type: "string",
-                description: "The DID of the repo."
-              },
-              collection: {
-                type: "string",
-                description: "The NSID of the record collection."
-              },
-              rkey: {
-                type: "string",
-                description: "The key of the record."
-              }
-            }
+            type: "ref",
+            ref: "lex:com.atproto.admin.record#viewDetail"
           }
         }
       }
     }
   },
-  ComAtprotoRepoDescribe: {
+  ComAtprotoAdminGetRepo: {
     lexicon: 1,
-    id: "com.atproto.repo.describe",
+    id: "com.atproto.admin.getRepo",
     defs: {
       main: {
         type: "query",
-        description: "Get information about the repo, including the list of collections.",
+        description: "View details about a repository.",
         parameters: {
           type: "params",
-          required: ["user"],
+          required: ["did"],
           properties: {
-            user: {
-              type: "string",
-              description: "The handle or DID of the repo."
+            did: {
+              type: "string"
             }
           }
         },
         output: {
           encoding: "application/json",
           schema: {
-            type: "object",
-            required: [
-              "handle",
-              "did",
-              "didDoc",
-              "collections",
-              "handleIsCorrect"
-            ],
-            properties: {
-              handle: {
-                type: "string"
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#viewDetail"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminModerationAction: {
+    lexicon: 1,
+    id: "com.atproto.admin.moderationAction",
+    defs: {
+      view: {
+        type: "object",
+        required: [
+          "id",
+          "action",
+          "subject",
+          "reason",
+          "createdBy",
+          "createdAt",
+          "resolvedReportIds"
+        ],
+        properties: {
+          id: {
+            type: "integer"
+          },
+          action: {
+            type: "string",
+            knownValues: [
+              "com.atproto.admin.moderationAction#takedown",
+              "com.atproto.admin.moderationAction#flag",
+              "com.atproto.admin.moderationAction#acknowledge"
+            ]
+          },
+          subject: {
+            type: "union",
+            refs: [
+              "lex:com.atproto.repo.repoRef",
+              "lex:com.atproto.repo.strongRef"
+            ]
+          },
+          reason: {
+            type: "string"
+          },
+          createdBy: {
+            type: "string"
+          },
+          createdAt: {
+            type: "string"
+          },
+          reversal: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#reversal"
+          },
+          resolvedReportIds: {
+            type: "array",
+            items: {
+              type: "integer"
+            }
+          }
+        }
+      },
+      viewDetail: {
+        type: "object",
+        required: [
+          "id",
+          "action",
+          "subject",
+          "reason",
+          "createdBy",
+          "createdAt",
+          "resolvedReports"
+        ],
+        properties: {
+          id: {
+            type: "integer"
+          },
+          action: {
+            type: "string",
+            knownValues: [
+              "com.atproto.admin.moderationAction#takedown",
+              "com.atproto.admin.moderationAction#flag",
+              "com.atproto.admin.moderationAction#acknowledge"
+            ]
+          },
+          subject: {
+            type: "union",
+            refs: [
+              "lex:com.atproto.admin.repo#view",
+              "lex:com.atproto.admin.record#view"
+            ]
+          },
+          reason: {
+            type: "string"
+          },
+          createdBy: {
+            type: "string"
+          },
+          createdAt: {
+            type: "string"
+          },
+          reversal: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#reversal"
+          },
+          resolvedReports: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationReport#view"
+            }
+          }
+        }
+      },
+      reversal: {
+        type: "object",
+        required: ["reason", "createdBy", "createdAt"],
+        properties: {
+          reason: {
+            type: "string"
+          },
+          createdBy: {
+            type: "string"
+          },
+          createdAt: {
+            type: "string"
+          }
+        }
+      },
+      takedown: {
+        type: "token",
+        description: "Moderation action type: Takedown. Indicates that content should not be served by the PDS."
+      },
+      flag: {
+        type: "token",
+        description: "Moderation action type: Flag. Indicates that the content was reviewed and considered to violate PDS rules, but may still be served."
+      },
+      acknowledge: {
+        type: "token",
+        description: "Moderation action type: Acknowledge. Indicates that the content was reviewed and not considered to violate PDS rules."
+      }
+    }
+  },
+  ComAtprotoAdminModerationReport: {
+    lexicon: 1,
+    id: "com.atproto.admin.moderationReport",
+    defs: {
+      view: {
+        type: "object",
+        required: [
+          "id",
+          "reasonType",
+          "subject",
+          "reportedByDid",
+          "createdAt",
+          "resolvedByActionIds"
+        ],
+        properties: {
+          id: {
+            type: "integer"
+          },
+          reasonType: {
+            type: "ref",
+            ref: "lex:com.atproto.report.reasonType"
+          },
+          reason: {
+            type: "string"
+          },
+          subject: {
+            type: "union",
+            refs: [
+              "lex:com.atproto.repo.repoRef",
+              "lex:com.atproto.repo.strongRef"
+            ]
+          },
+          reportedByDid: {
+            type: "string"
+          },
+          createdAt: {
+            type: "datetime"
+          },
+          resolvedByActionIds: {
+            type: "array",
+            items: {
+              type: "integer"
+            }
+          }
+        }
+      },
+      viewDetail: {
+        type: "object",
+        required: [
+          "id",
+          "reasonType",
+          "subject",
+          "reportedByDid",
+          "createdAt",
+          "resolvedByActions"
+        ],
+        properties: {
+          id: {
+            type: "integer"
+          },
+          reasonType: {
+            type: "ref",
+            ref: "lex:com.atproto.report.reasonType"
+          },
+          reason: {
+            type: "string"
+          },
+          subject: {
+            type: "union",
+            refs: [
+              "lex:com.atproto.admin.repo#view",
+              "lex:com.atproto.admin.record#view"
+            ]
+          },
+          reportedByDid: {
+            type: "string"
+          },
+          createdAt: {
+            type: "datetime"
+          },
+          resolvedByActions: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationAction#view"
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminRecord: {
+    lexicon: 1,
+    id: "com.atproto.admin.record",
+    defs: {
+      view: {
+        type: "object",
+        required: ["uri", "cid", "value", "indexedAt", "moderation", "repo"],
+        properties: {
+          uri: {
+            type: "string"
+          },
+          cid: {
+            type: "string"
+          },
+          value: {
+            type: "unknown"
+          },
+          indexedAt: {
+            type: "string"
+          },
+          moderation: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.record#moderation"
+          },
+          repo: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#view"
+          }
+        }
+      },
+      viewDetail: {
+        type: "object",
+        required: ["uri", "cid", "value", "indexedAt", "moderation", "repo"],
+        properties: {
+          uri: {
+            type: "string"
+          },
+          cid: {
+            type: "string"
+          },
+          value: {
+            type: "unknown"
+          },
+          indexedAt: {
+            type: "string"
+          },
+          moderation: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.record#moderationDetail"
+          },
+          repo: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#view"
+          }
+        }
+      },
+      moderation: {
+        type: "object",
+        required: [],
+        properties: {
+          takedownId: {
+            type: "integer"
+          }
+        }
+      },
+      moderationDetail: {
+        type: "object",
+        required: ["actions", "reports"],
+        properties: {
+          actions: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationAction#view"
+            }
+          },
+          reports: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationReport#view"
+            }
+          },
+          takedownId: {
+            type: "integer"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminRepo: {
+    lexicon: 1,
+    id: "com.atproto.admin.repo",
+    defs: {
+      view: {
+        type: "object",
+        required: [
+          "did",
+          "handle",
+          "relatedRecords",
+          "indexedAt",
+          "moderation"
+        ],
+        properties: {
+          did: {
+            type: "string"
+          },
+          handle: {
+            type: "string"
+          },
+          account: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#account"
+          },
+          relatedRecords: {
+            type: "array",
+            items: {
+              type: "unknown"
+            }
+          },
+          indexedAt: {
+            type: "string"
+          },
+          moderation: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#moderation"
+          }
+        }
+      },
+      viewDetail: {
+        type: "object",
+        required: [
+          "did",
+          "handle",
+          "relatedRecords",
+          "indexedAt",
+          "moderation"
+        ],
+        properties: {
+          did: {
+            type: "string"
+          },
+          handle: {
+            type: "string"
+          },
+          account: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#account"
+          },
+          relatedRecords: {
+            type: "array",
+            items: {
+              type: "unknown"
+            }
+          },
+          indexedAt: {
+            type: "string"
+          },
+          moderation: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.repo#moderationDetail"
+          }
+        }
+      },
+      account: {
+        type: "object",
+        required: ["email"],
+        properties: {
+          email: {
+            type: "string"
+          }
+        }
+      },
+      moderation: {
+        type: "object",
+        required: [],
+        properties: {
+          takedownId: {
+            type: "integer"
+          }
+        }
+      },
+      moderationDetail: {
+        type: "object",
+        required: ["actions", "reports"],
+        properties: {
+          actions: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationAction#view"
+            }
+          },
+          reports: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:com.atproto.admin.moderationReport#view"
+            }
+          },
+          takedownId: {
+            type: "integer"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminResolveModerationReports: {
+    lexicon: 1,
+    id: "com.atproto.admin.resolveModerationReports",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Resolve moderation reports by an action.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["actionId", "reportIds", "createdBy"],
+            properties: {
+              actionId: {
+                type: "integer"
+              },
+              reportIds: {
+                type: "array",
+                items: {
+                  type: "integer"
+                }
+              },
+              createdBy: {
+                type: "string"
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#view"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminReverseModerationAction: {
+    lexicon: 1,
+    id: "com.atproto.admin.reverseModerationAction",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Reverse a moderation action.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["id", "reason", "createdBy"],
+            properties: {
+              id: {
+                type: "integer"
+              },
+              reason: {
+                type: "string"
+              },
+              createdBy: {
+                type: "string"
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#view"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminSearchRepos: {
+    lexicon: 1,
+    id: "com.atproto.admin.searchRepos",
+    defs: {
+      main: {
+        type: "query",
+        description: "Find repositories based on a search term.",
+        parameters: {
+          type: "params",
+          properties: {
+            term: {
+              type: "string"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            before: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["repos"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              repos: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:com.atproto.admin.repo#view"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoAdminTakeModerationAction: {
+    lexicon: 1,
+    id: "com.atproto.admin.takeModerationAction",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Take a moderation action on a repo.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["action", "subject", "reason", "createdBy"],
+            properties: {
+              action: {
+                type: "string",
+                knownValues: [
+                  "com.atproto.admin.moderationAction#takedown",
+                  "com.atproto.admin.moderationAction#flag",
+                  "com.atproto.admin.moderationAction#acknowledge"
+                ]
+              },
+              subject: {
+                type: "union",
+                refs: [
+                  "lex:com.atproto.repo.repoRef",
+                  "lex:com.atproto.repo.recordRef"
+                ]
+              },
+              reason: {
+                type: "string"
+              },
+              createdBy: {
+                type: "string"
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:com.atproto.admin.moderationAction#view"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoBlobUpload: {
+    lexicon: 1,
+    id: "com.atproto.blob.upload",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Upload a new blob to be added to repo in a later request.",
+        input: {
+          encoding: "*/*"
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["cid"],
+            properties: {
+              cid: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoHandleResolve: {
+    lexicon: 1,
+    id: "com.atproto.handle.resolve",
+    defs: {
+      main: {
+        type: "query",
+        description: "Provides the DID of a repo.",
+        parameters: {
+          type: "params",
+          properties: {
+            handle: {
+              type: "string",
+              description: "The handle to resolve. If not supplied, will resolve the host's own handle."
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did"],
+            properties: {
+              did: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoRepoBatchWrite: {
+    lexicon: 1,
+    id: "com.atproto.repo.batchWrite",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Apply a batch transaction of creates, puts, and deletes.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did", "writes"],
+            properties: {
+              did: {
+                type: "string",
+                description: "The DID of the repo."
+              },
+              validate: {
+                type: "boolean",
+                default: true,
+                description: "Validate the records?"
+              },
+              writes: {
+                type: "array",
+                items: {
+                  type: "union",
+                  refs: [
+                    "lex:com.atproto.repo.batchWrite#create",
+                    "lex:com.atproto.repo.batchWrite#update",
+                    "lex:com.atproto.repo.batchWrite#delete"
+                  ],
+                  closed: true
+                }
+              }
+            }
+          }
+        }
+      },
+      create: {
+        type: "object",
+        required: ["action", "collection", "value"],
+        properties: {
+          action: {
+            type: "string",
+            const: "create"
+          },
+          collection: {
+            type: "string"
+          },
+          rkey: {
+            type: "string"
+          },
+          value: {
+            type: "unknown"
+          }
+        }
+      },
+      update: {
+        type: "object",
+        required: ["action", "collection", "rkey", "value"],
+        properties: {
+          action: {
+            type: "string",
+            const: "update"
+          },
+          collection: {
+            type: "string"
+          },
+          rkey: {
+            type: "string"
+          },
+          value: {
+            type: "unknown"
+          }
+        }
+      },
+      delete: {
+        type: "object",
+        required: ["action", "collection", "rkey"],
+        properties: {
+          action: {
+            type: "string",
+            const: "delete"
+          },
+          collection: {
+            type: "string"
+          },
+          rkey: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoRepoCreateRecord: {
+    lexicon: 1,
+    id: "com.atproto.repo.createRecord",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Create a new record.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did", "collection", "record"],
+            properties: {
+              did: {
+                type: "string",
+                description: "The DID of the repo."
+              },
+              collection: {
+                type: "string",
+                description: "The NSID of the record collection."
+              },
+              validate: {
+                type: "boolean",
+                default: true,
+                description: "Validate the record?"
+              },
+              record: {
+                type: "unknown",
+                description: "The record to create."
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["uri", "cid"],
+            properties: {
+              uri: {
+                type: "string"
+              },
+              cid: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoRepoDeleteRecord: {
+    lexicon: 1,
+    id: "com.atproto.repo.deleteRecord",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Delete a record.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did", "collection", "rkey"],
+            properties: {
+              did: {
+                type: "string",
+                description: "The DID of the repo."
+              },
+              collection: {
+                type: "string",
+                description: "The NSID of the record collection."
+              },
+              rkey: {
+                type: "string",
+                description: "The key of the record."
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoRepoDescribe: {
+    lexicon: 1,
+    id: "com.atproto.repo.describe",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get information about the repo, including the list of collections.",
+        parameters: {
+          type: "params",
+          required: ["user"],
+          properties: {
+            user: {
+              type: "string",
+              description: "The handle or DID of the repo."
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: [
+              "handle",
+              "did",
+              "didDoc",
+              "collections",
+              "handleIsCorrect"
+            ],
+            properties: {
+              handle: {
+                type: "string"
               },
               did: {
                 type: "string"
@@ -4937,6 +5768,41 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoRepoRecordRef: {
+    lexicon: 1,
+    id: "com.atproto.repo.recordRef",
+    description: "A URI with optional content-hash fingerprint.",
+    defs: {
+      main: {
+        type: "object",
+        required: ["uri"],
+        properties: {
+          uri: {
+            type: "string"
+          },
+          cid: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoRepoRepoRef: {
+    lexicon: 1,
+    id: "com.atproto.repo.repoRef",
+    description: "A did identifying a repository.",
+    defs: {
+      main: {
+        type: "object",
+        required: ["did"],
+        properties: {
+          did: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
   ComAtprotoRepoStrongRef: {
     lexicon: 1,
     id: "com.atproto.repo.strongRef",
@@ -4956,6 +5822,148 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoReportCreate: {
+    lexicon: 1,
+    id: "com.atproto.report.create",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Report a repo or a record.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["reasonType", "subject"],
+            properties: {
+              reasonType: {
+                type: "ref",
+                ref: "lex:com.atproto.report.reasonType"
+              },
+              reason: {
+                type: "string"
+              },
+              subject: {
+                type: "union",
+                refs: [
+                  "lex:com.atproto.repo.repoRef",
+                  "lex:com.atproto.repo.recordRef"
+                ]
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: [
+              "id",
+              "reasonType",
+              "subject",
+              "reportedByDid",
+              "createdAt"
+            ],
+            properties: {
+              id: {
+                type: "integer"
+              },
+              reasonType: {
+                type: "ref",
+                ref: "lex:com.atproto.report.reasonType"
+              },
+              reason: {
+                type: "string"
+              },
+              subject: {
+                type: "union",
+                refs: [
+                  "lex:com.atproto.repo.repoRef",
+                  "lex:com.atproto.repo.strongRef"
+                ]
+              },
+              reportedByDid: {
+                type: "string"
+              },
+              createdAt: {
+                type: "datetime"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  ComAtprotoReportReasonType: {
+    lexicon: 1,
+    id: "com.atproto.report.reasonType",
+    defs: {
+      main: {
+        type: "string",
+        knownValues: [
+          "com.atproto.report.reason#spam",
+          "com.atproto.report.reason#other"
+        ]
+      },
+      spam: {
+        type: "token",
+        description: "Moderation report reason: Spam."
+      },
+      other: {
+        type: "token",
+        description: "Moderation report reason: Other."
+      }
+    }
+  },
+  ComAtprotoReportSubject: {
+    lexicon: 1,
+    id: "com.atproto.report.subject",
+    defs: {
+      repo: {
+        type: "object",
+        required: ["did"],
+        properties: {
+          did: {
+            type: "string",
+            description: "The DID of the repo."
+          }
+        }
+      },
+      record: {
+        type: "object",
+        required: ["did", "collection", "rkey"],
+        properties: {
+          did: {
+            type: "string",
+            description: "The DID of the repo."
+          },
+          collection: {
+            type: "string",
+            description: "The NSID of the collection."
+          },
+          rkey: {
+            type: "string",
+            description: "The key of the record."
+          },
+          cid: {
+            type: "string",
+            description: "The CID of the version of the record. If not specified, defaults to the most recent version."
+          }
+        }
+      },
+      recordRef: {
+        type: "object",
+        required: ["uri", "cid"],
+        properties: {
+          uri: {
+            type: "string"
+          },
+          cid: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
   ComAtprotoServerGetAccountsConfig: {
     lexicon: 1,
     id: "com.atproto.server.getAccountsConfig",
@@ -5010,10 +6018,11 @@ var schemaDict = {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["handle", "password"],
+            required: ["password"],
             properties: {
-              handle: {
-                type: "string"
+              identifier: {
+                type: "string",
+                description: "Handle or other identifier supported by the server for the authenticating user."
               },
               password: {
                 type: "string"
@@ -5041,7 +6050,12 @@ var schemaDict = {
               }
             }
           }
-        }
+        },
+        errors: [
+          {
+            name: "AccountTakedown"
+          }
+        ]
       }
     }
   },
@@ -5107,17 +6121,49 @@ var schemaDict = {
               }
             }
           }
+        },
+        errors: [
+          {
+            name: "AccountTakedown"
+          }
+        ]
+      }
+    }
+  },
+  ComAtprotoSyncGetCheckout: {
+    lexicon: 1,
+    id: "com.atproto.sync.getCheckout",
+    defs: {
+      main: {
+        type: "query",
+        description: "Gets the repo state.",
+        parameters: {
+          type: "params",
+          required: ["did"],
+          properties: {
+            did: {
+              type: "string",
+              description: "The DID of the repo."
+            },
+            commit: {
+              type: "string",
+              description: "The commit to get the checkout from. Defaults to current HEAD."
+            }
+          }
+        },
+        output: {
+          encoding: "application/vnd.ipld.car"
         }
       }
     }
   },
-  ComAtprotoSyncGetRepo: {
+  ComAtprotoSyncGetCommitPath: {
     lexicon: 1,
-    id: "com.atproto.sync.getRepo",
+    id: "com.atproto.sync.getCommitPath",
     defs: {
       main: {
         type: "query",
-        description: "Gets the repo state.",
+        description: "Gets the path of repo commits",
         parameters: {
           type: "params",
           required: ["did"],
@@ -5126,25 +6172,41 @@ var schemaDict = {
               type: "string",
               description: "The DID of the repo."
             },
-            from: {
+            latest: {
               type: "string",
-              description: "A past commit CID."
+              description: "The most recent commit"
+            },
+            earliest: {
+              type: "string",
+              description: "The earliest commit to start from"
             }
           }
         },
         output: {
-          encoding: "application/cbor"
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["commits"],
+            properties: {
+              commits: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              }
+            }
+          }
         }
       }
     }
   },
-  ComAtprotoSyncGetRoot: {
+  ComAtprotoSyncGetHead: {
     lexicon: 1,
-    id: "com.atproto.sync.getRoot",
+    id: "com.atproto.sync.getHead",
     defs: {
       main: {
         type: "query",
-        description: "Gets the current root CID of a repo.",
+        description: "Gets the current HEAD CID of a repo.",
         parameters: {
           type: "params",
           required: ["did"],
@@ -5170,78 +6232,63 @@ var schemaDict = {
       }
     }
   },
-  ComAtprotoSyncUpdateRepo: {
+  ComAtprotoSyncGetRecord: {
     lexicon: 1,
-    id: "com.atproto.sync.updateRepo",
+    id: "com.atproto.sync.getRecord",
     defs: {
       main: {
-        type: "procedure",
-        description: "Writes commits to a repo.",
+        type: "query",
+        description: "Gets blocks needed for existence or non-existence of record.",
         parameters: {
           type: "params",
-          required: ["did"],
+          required: ["did", "collection", "rkey"],
           properties: {
             did: {
               type: "string",
               description: "The DID of the repo."
+            },
+            collection: {
+              type: "string"
+            },
+            rkey: {
+              type: "string"
+            },
+            commit: {
+              type: "string",
+              description: "An optional past commit CID."
             }
           }
         },
-        input: {
-          encoding: "application/cbor"
+        output: {
+          encoding: "application/vnd.ipld.car"
         }
       }
     }
   },
-  AppBskyActorCreateScene: {
+  ComAtprotoSyncGetRepo: {
     lexicon: 1,
-    id: "app.bsky.actor.createScene",
+    id: "com.atproto.sync.getRepo",
     defs: {
       main: {
-        type: "procedure",
-        description: "Create a scene.",
-        input: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["handle"],
-            properties: {
-              handle: {
-                type: "string"
-              },
-              recoveryKey: {
-                type: "string"
-              }
+        type: "query",
+        description: "Gets the repo state.",
+        parameters: {
+          type: "params",
+          required: ["did"],
+          properties: {
+            did: {
+              type: "string",
+              description: "The DID of the repo."
+            },
+            from: {
+              type: "string",
+              description: "A past commit CID."
             }
           }
         },
         output: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["handle", "did", "declaration"],
-            properties: {
-              handle: {
-                type: "string"
-              },
-              did: {
-                type: "string"
-              },
-              declaration: {
-                type: "ref",
-                ref: "lex:app.bsky.system.declRef"
-              }
-            }
-          }
-        },
-        errors: [
-          {
-            name: "InvalidHandle"
-          },
-          {
-            name: "HandleNotAvailable"
-          }
-        ]
+          encoding: "application/vnd.ipld.car"
+        }
       }
     }
   },
@@ -5271,7 +6318,6 @@ var schemaDict = {
               "creator",
               "followersCount",
               "followsCount",
-              "membersCount",
               "postsCount"
             ],
             properties: {
@@ -5308,9 +6354,6 @@ var schemaDict = {
               followsCount: {
                 type: "integer"
               },
-              membersCount: {
-                type: "integer"
-              },
               postsCount: {
                 type: "integer"
               },
@@ -5328,9 +6371,6 @@ var schemaDict = {
           follow: {
             type: "string"
           },
-          member: {
-            type: "string"
-          },
           muted: {
             type: "boolean"
           }
@@ -5523,7 +6563,6 @@ var schemaDict = {
         description: "Find users matching search criteria.",
         parameters: {
           type: "params",
-          required: ["term"],
           properties: {
             term: {
               type: "string"
@@ -5599,7 +6638,6 @@ var schemaDict = {
         description: "Find user suggestions for a search term.",
         parameters: {
           type: "params",
-          required: ["term"],
           properties: {
             term: {
               type: "string"
@@ -5666,9 +6704,6 @@ var schemaDict = {
           schema: {
             type: "object",
             properties: {
-              did: {
-                type: "string"
-              },
               displayName: {
                 type: "string",
                 maxLength: 64
@@ -5880,10 +6915,7 @@ var schemaDict = {
           },
           reason: {
             type: "union",
-            refs: [
-              "lex:app.bsky.feed.feedViewPost#reasonTrend",
-              "lex:app.bsky.feed.feedViewPost#reasonRepost"
-            ]
+            refs: ["lex:app.bsky.feed.feedViewPost#reasonRepost"]
           }
         }
       },
@@ -5901,19 +6933,6 @@ var schemaDict = {
           }
         }
       },
-      reasonTrend: {
-        type: "object",
-        required: ["by", "indexedAt"],
-        properties: {
-          by: {
-            type: "ref",
-            ref: "lex:app.bsky.actor.ref#withInfo"
-          },
-          indexedAt: {
-            type: "datetime"
-          }
-        }
-      },
       reasonRepost: {
         type: "object",
         required: ["by", "indexedAt"],
@@ -6488,29 +7507,6 @@ var schemaDict = {
       }
     }
   },
-  AppBskyFeedTrend: {
-    lexicon: 1,
-    id: "app.bsky.feed.trend",
-    defs: {
-      main: {
-        type: "record",
-        key: "tid",
-        record: {
-          type: "object",
-          required: ["subject", "createdAt"],
-          properties: {
-            subject: {
-              type: "ref",
-              ref: "lex:com.atproto.repo.strongRef"
-            },
-            createdAt: {
-              type: "datetime"
-            }
-          }
-        }
-      }
-    }
-  },
   AppBskyFeedVote: {
     lexicon: 1,
     id: "app.bsky.feed.vote",
@@ -6616,134 +7612,20 @@ var schemaDict = {
     id: "app.bsky.graph.follow",
     defs: {
       main: {
-        type: "record",
-        description: "A social follow.",
-        key: "tid",
-        record: {
-          type: "object",
-          required: ["subject", "createdAt"],
-          properties: {
-            subject: {
-              type: "ref",
-              ref: "lex:app.bsky.actor.ref"
-            },
-            createdAt: {
-              type: "datetime"
-            }
-          }
-        }
-      }
-    }
-  },
-  AppBskyGraphGetAssertions: {
-    lexicon: 1,
-    id: "app.bsky.graph.getAssertions",
-    defs: {
-      main: {
-        type: "query",
-        description: "General-purpose query for assertions.",
-        parameters: {
-          type: "params",
-          properties: {
-            author: {
-              type: "string"
-            },
-            subject: {
-              type: "string"
-            },
-            assertion: {
-              type: "string"
-            },
-            confirmed: {
-              type: "boolean"
-            },
-            limit: {
-              type: "integer",
-              minimum: 1,
-              maximum: 100,
-              default: 50
-            },
-            before: {
-              type: "string"
-            }
-          }
-        },
-        output: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["assertions"],
-            properties: {
-              cursor: {
-                type: "string"
-              },
-              assertions: {
-                type: "array",
-                items: {
-                  type: "ref",
-                  ref: "lex:app.bsky.graph.getAssertions#assertion"
-                }
-              }
-            }
-          }
-        }
-      },
-      assertion: {
-        type: "object",
-        required: [
-          "uri",
-          "cid",
-          "assertion",
-          "author",
-          "subject",
-          "indexedAt",
-          "createdAt"
-        ],
-        properties: {
-          uri: {
-            type: "string"
-          },
-          cid: {
-            type: "string"
-          },
-          assertion: {
-            type: "string"
-          },
-          confirmation: {
-            type: "ref",
-            ref: "lex:app.bsky.graph.getAssertions#confirmation"
-          },
-          author: {
-            type: "ref",
-            ref: "lex:app.bsky.actor.ref#withInfo"
-          },
-          subject: {
-            type: "ref",
-            ref: "lex:app.bsky.actor.ref#withInfo"
-          },
-          indexedAt: {
-            type: "datetime"
-          },
-          createdAt: {
-            type: "datetime"
-          }
-        }
-      },
-      confirmation: {
-        type: "object",
-        required: ["uri", "cid", "indexedAt", "createdAt"],
-        properties: {
-          uri: {
-            type: "string"
-          },
-          cid: {
-            type: "string"
-          },
-          indexedAt: {
-            type: "datetime"
-          },
-          createdAt: {
-            type: "datetime"
+        type: "record",
+        description: "A social follow.",
+        key: "tid",
+        record: {
+          type: "object",
+          required: ["subject", "createdAt"],
+          properties: {
+            subject: {
+              type: "ref",
+              ref: "lex:app.bsky.actor.ref"
+            },
+            createdAt: {
+              type: "datetime"
+            }
           }
         }
       }
@@ -6896,160 +7778,9 @@ var schemaDict = {
             type: "string",
             maxLength: 64
           },
-          createdAt: {
-            type: "datetime"
-          },
-          indexedAt: {
-            type: "datetime"
-          }
-        }
-      }
-    }
-  },
-  AppBskyGraphGetMembers: {
-    lexicon: 1,
-    id: "app.bsky.graph.getMembers",
-    defs: {
-      main: {
-        type: "query",
-        description: "Who is a member of the group?",
-        parameters: {
-          type: "params",
-          required: ["actor"],
-          properties: {
-            actor: {
-              type: "string"
-            },
-            limit: {
-              type: "integer",
-              minimum: 1,
-              maximum: 100,
-              default: 50
-            },
-            before: {
-              type: "string"
-            }
-          }
-        },
-        output: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["subject", "members"],
-            properties: {
-              subject: {
-                type: "ref",
-                ref: "lex:app.bsky.actor.ref#withInfo"
-              },
-              cursor: {
-                type: "string"
-              },
-              members: {
-                type: "array",
-                items: {
-                  type: "ref",
-                  ref: "lex:app.bsky.graph.getMembers#member"
-                }
-              }
-            }
-          }
-        }
-      },
-      member: {
-        type: "object",
-        required: ["did", "declaration", "handle", "indexedAt"],
-        properties: {
-          did: {
-            type: "string"
-          },
-          declaration: {
-            type: "ref",
-            ref: "lex:app.bsky.system.declRef"
-          },
-          handle: {
-            type: "string"
-          },
-          displayName: {
-            type: "string",
-            maxLength: 64
-          },
-          createdAt: {
-            type: "datetime"
-          },
-          indexedAt: {
-            type: "datetime"
-          }
-        }
-      }
-    }
-  },
-  AppBskyGraphGetMemberships: {
-    lexicon: 1,
-    id: "app.bsky.graph.getMemberships",
-    defs: {
-      main: {
-        type: "query",
-        description: "Which groups is the actor a member of?",
-        parameters: {
-          type: "params",
-          required: ["actor"],
-          properties: {
-            actor: {
-              type: "string"
-            },
-            limit: {
-              type: "integer",
-              minimum: 1,
-              maximum: 100,
-              default: 50
-            },
-            before: {
-              type: "string"
-            }
-          }
-        },
-        output: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["subject", "memberships"],
-            properties: {
-              subject: {
-                type: "ref",
-                ref: "lex:app.bsky.actor.ref#withInfo"
-              },
-              cursor: {
-                type: "string"
-              },
-              memberships: {
-                type: "array",
-                items: {
-                  type: "ref",
-                  ref: "lex:app.bsky.graph.getMemberships#membership"
-                }
-              }
-            }
-          }
-        }
-      },
-      membership: {
-        type: "object",
-        required: ["did", "declaration", "handle", "indexedAt"],
-        properties: {
-          did: {
-            type: "string"
-          },
-          declaration: {
-            type: "ref",
-            ref: "lex:app.bsky.system.declRef"
-          },
-          handle: {
+          avatar: {
             type: "string"
           },
-          displayName: {
-            type: "string",
-            maxLength: 64
-          },
           createdAt: {
             type: "datetime"
           },
@@ -7255,11 +7986,10 @@ var schemaDict = {
           },
           reason: {
             type: "string",
-            description: "Expected values are 'vote', 'repost', 'trend', 'follow', 'invite', 'mention' and 'reply'.",
+            description: "Expected values are 'vote', 'repost', 'follow', 'invite', 'mention' and 'reply'.",
             knownValues: [
               "vote",
               "repost",
-              "trend",
               "follow",
               "invite",
               "mention",
@@ -7304,16 +8034,6 @@ var schemaDict = {
       }
     }
   },
-  AppBskySystemActorScene: {
-    lexicon: 1,
-    id: "app.bsky.system.actorScene",
-    defs: {
-      main: {
-        type: "token",
-        description: "Actor type: Scene. Defined for app.bsky.system.declaration's actorType."
-      }
-    }
-  },
   AppBskySystemActorUser: {
     lexicon: 1,
     id: "app.bsky.system.actorUser",
@@ -7338,10 +8058,7 @@ var schemaDict = {
           },
           actorType: {
             type: "string",
-            knownValues: [
-              "app.bsky.system.actorUser",
-              "app.bsky.system.actorScene"
-            ]
+            knownValues: ["app.bsky.system.actorUser"]
           }
         }
       }
@@ -7361,10 +8078,7 @@ var schemaDict = {
           properties: {
             actorType: {
               type: "string",
-              knownValues: [
-                "app.bsky.system.actorUser",
-                "app.bsky.system.actorScene"
-              ]
+              knownValues: ["app.bsky.system.actorUser"]
             }
           }
         }
@@ -7462,29 +8176,139 @@ function toKnownErr5(e) {
   return e;
 }
 
-// src/client/types/com/atproto/account/resetPassword.ts
-var resetPassword_exports = {};
-__export(resetPassword_exports, {
-  ExpiredTokenError: () => ExpiredTokenError,
-  InvalidTokenError: () => InvalidTokenError,
-  toKnownErr: () => toKnownErr6
+// src/client/types/com/atproto/account/resetPassword.ts
+var resetPassword_exports = {};
+__export(resetPassword_exports, {
+  ExpiredTokenError: () => ExpiredTokenError,
+  InvalidTokenError: () => InvalidTokenError,
+  toKnownErr: () => toKnownErr6
+});
+var ExpiredTokenError = class extends XRPCError {
+  constructor(src) {
+    super(src.status, src.error, src.message);
+  }
+};
+var InvalidTokenError = class extends XRPCError {
+  constructor(src) {
+    super(src.status, src.error, src.message);
+  }
+};
+function toKnownErr6(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "ExpiredToken")
+      return new ExpiredTokenError(e);
+    if (e.error === "InvalidToken")
+      return new InvalidTokenError(e);
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getModerationAction.ts
+var getModerationAction_exports = {};
+__export(getModerationAction_exports, {
+  toKnownErr: () => toKnownErr7
+});
+function toKnownErr7(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getModerationActions.ts
+var getModerationActions_exports = {};
+__export(getModerationActions_exports, {
+  toKnownErr: () => toKnownErr8
+});
+function toKnownErr8(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getModerationReport.ts
+var getModerationReport_exports = {};
+__export(getModerationReport_exports, {
+  toKnownErr: () => toKnownErr9
+});
+function toKnownErr9(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getModerationReports.ts
+var getModerationReports_exports = {};
+__export(getModerationReports_exports, {
+  toKnownErr: () => toKnownErr10
+});
+function toKnownErr10(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getRecord.ts
+var getRecord_exports = {};
+__export(getRecord_exports, {
+  toKnownErr: () => toKnownErr11
+});
+function toKnownErr11(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/getRepo.ts
+var getRepo_exports = {};
+__export(getRepo_exports, {
+  toKnownErr: () => toKnownErr12
+});
+function toKnownErr12(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/resolveModerationReports.ts
+var resolveModerationReports_exports = {};
+__export(resolveModerationReports_exports, {
+  toKnownErr: () => toKnownErr13
+});
+function toKnownErr13(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/reverseModerationAction.ts
+var reverseModerationAction_exports = {};
+__export(reverseModerationAction_exports, {
+  toKnownErr: () => toKnownErr14
+});
+function toKnownErr14(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/searchRepos.ts
+var searchRepos_exports = {};
+__export(searchRepos_exports, {
+  toKnownErr: () => toKnownErr15
 });
-var ExpiredTokenError = class extends XRPCError {
-  constructor(src) {
-    super(src.status, src.error, src.message);
-  }
-};
-var InvalidTokenError = class extends XRPCError {
-  constructor(src) {
-    super(src.status, src.error, src.message);
+function toKnownErr15(e) {
+  if (e instanceof XRPCError) {
   }
-};
-function toKnownErr6(e) {
+  return e;
+}
+
+// src/client/types/com/atproto/admin/takeModerationAction.ts
+var takeModerationAction_exports = {};
+__export(takeModerationAction_exports, {
+  toKnownErr: () => toKnownErr16
+});
+function toKnownErr16(e) {
   if (e instanceof XRPCError) {
-    if (e.error === "ExpiredToken")
-      return new ExpiredTokenError(e);
-    if (e.error === "InvalidToken")
-      return new InvalidTokenError(e);
   }
   return e;
 }
@@ -7492,9 +8316,9 @@ function toKnownErr6(e) {
 // src/client/types/com/atproto/blob/upload.ts
 var upload_exports = {};
 __export(upload_exports, {
-  toKnownErr: () => toKnownErr7
+  toKnownErr: () => toKnownErr17
 });
-function toKnownErr7(e) {
+function toKnownErr17(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7503,9 +8327,9 @@ function toKnownErr7(e) {
 // src/client/types/com/atproto/handle/resolve.ts
 var resolve_exports = {};
 __export(resolve_exports, {
-  toKnownErr: () => toKnownErr8
+  toKnownErr: () => toKnownErr18
 });
-function toKnownErr8(e) {
+function toKnownErr18(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7517,7 +8341,7 @@ __export(batchWrite_exports, {
   isCreate: () => isCreate,
   isDelete: () => isDelete,
   isUpdate: () => isUpdate,
-  toKnownErr: () => toKnownErr9,
+  toKnownErr: () => toKnownErr19,
   validateCreate: () => validateCreate,
   validateDelete: () => validateDelete,
   validateUpdate: () => validateUpdate
@@ -7532,7 +8356,7 @@ function hasProp2(data, prop) {
 }
 
 // src/client/types/com/atproto/repo/batchWrite.ts
-function toKnownErr9(e) {
+function toKnownErr19(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7559,9 +8383,9 @@ function validateDelete(v) {
 // src/client/types/com/atproto/repo/createRecord.ts
 var createRecord_exports = {};
 __export(createRecord_exports, {
-  toKnownErr: () => toKnownErr10
+  toKnownErr: () => toKnownErr20
 });
-function toKnownErr10(e) {
+function toKnownErr20(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7570,9 +8394,9 @@ function toKnownErr10(e) {
 // src/client/types/com/atproto/repo/deleteRecord.ts
 var deleteRecord_exports = {};
 __export(deleteRecord_exports, {
-  toKnownErr: () => toKnownErr11
+  toKnownErr: () => toKnownErr21
 });
-function toKnownErr11(e) {
+function toKnownErr21(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7581,20 +8405,20 @@ function toKnownErr11(e) {
 // src/client/types/com/atproto/repo/describe.ts
 var describe_exports = {};
 __export(describe_exports, {
-  toKnownErr: () => toKnownErr12
+  toKnownErr: () => toKnownErr22
 });
-function toKnownErr12(e) {
+function toKnownErr22(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // src/client/types/com/atproto/repo/getRecord.ts
-var getRecord_exports = {};
-__export(getRecord_exports, {
-  toKnownErr: () => toKnownErr13
+var getRecord_exports2 = {};
+__export(getRecord_exports2, {
+  toKnownErr: () => toKnownErr23
 });
-function toKnownErr13(e) {
+function toKnownErr23(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7604,10 +8428,10 @@ function toKnownErr13(e) {
 var listRecords_exports = {};
 __export(listRecords_exports, {
   isRecord: () => isRecord,
-  toKnownErr: () => toKnownErr14,
+  toKnownErr: () => toKnownErr24,
   validateRecord: () => validateRecord
 });
-function toKnownErr14(e) {
+function toKnownErr24(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7622,9 +8446,20 @@ function validateRecord(v) {
 // src/client/types/com/atproto/repo/putRecord.ts
 var putRecord_exports = {};
 __export(putRecord_exports, {
-  toKnownErr: () => toKnownErr15
+  toKnownErr: () => toKnownErr25
 });
-function toKnownErr15(e) {
+function toKnownErr25(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/report/create.ts
+var create_exports2 = {};
+__export(create_exports2, {
+  toKnownErr: () => toKnownErr26
+});
+function toKnownErr26(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7634,10 +8469,10 @@ function toKnownErr15(e) {
 var getAccountsConfig_exports = {};
 __export(getAccountsConfig_exports, {
   isLinks: () => isLinks,
-  toKnownErr: () => toKnownErr16,
+  toKnownErr: () => toKnownErr27,
   validateLinks: () => validateLinks
 });
-function toKnownErr16(e) {
+function toKnownErr27(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7650,12 +8485,20 @@ function validateLinks(v) {
 }
 
 // src/client/types/com/atproto/session/create.ts
-var create_exports2 = {};
-__export(create_exports2, {
-  toKnownErr: () => toKnownErr17
+var create_exports3 = {};
+__export(create_exports3, {
+  AccountTakedownError: () => AccountTakedownError,
+  toKnownErr: () => toKnownErr28
 });
-function toKnownErr17(e) {
+var AccountTakedownError = class extends XRPCError {
+  constructor(src) {
+    super(src.status, src.error, src.message);
+  }
+};
+function toKnownErr28(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "AccountTakedown")
+      return new AccountTakedownError(e);
   }
   return e;
 }
@@ -7663,9 +8506,9 @@ function toKnownErr17(e) {
 // src/client/types/com/atproto/session/delete.ts
 var delete_exports2 = {};
 __export(delete_exports2, {
-  toKnownErr: () => toKnownErr18
+  toKnownErr: () => toKnownErr29
 });
-function toKnownErr18(e) {
+function toKnownErr29(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7674,9 +8517,9 @@ function toKnownErr18(e) {
 // src/client/types/com/atproto/session/get.ts
 var get_exports2 = {};
 __export(get_exports2, {
-  toKnownErr: () => toKnownErr19
+  toKnownErr: () => toKnownErr30
 });
-function toKnownErr19(e) {
+function toKnownErr30(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7685,70 +8528,73 @@ function toKnownErr19(e) {
 // src/client/types/com/atproto/session/refresh.ts
 var refresh_exports = {};
 __export(refresh_exports, {
-  toKnownErr: () => toKnownErr20
+  AccountTakedownError: () => AccountTakedownError2,
+  toKnownErr: () => toKnownErr31
 });
-function toKnownErr20(e) {
+var AccountTakedownError2 = class extends XRPCError {
+  constructor(src) {
+    super(src.status, src.error, src.message);
+  }
+};
+function toKnownErr31(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "AccountTakedown")
+      return new AccountTakedownError2(e);
   }
   return e;
 }
 
-// src/client/types/com/atproto/sync/getRepo.ts
-var getRepo_exports = {};
-__export(getRepo_exports, {
-  toKnownErr: () => toKnownErr21
+// src/client/types/com/atproto/sync/getCheckout.ts
+var getCheckout_exports = {};
+__export(getCheckout_exports, {
+  toKnownErr: () => toKnownErr32
 });
-function toKnownErr21(e) {
+function toKnownErr32(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// src/client/types/com/atproto/sync/getRoot.ts
-var getRoot_exports = {};
-__export(getRoot_exports, {
-  toKnownErr: () => toKnownErr22
+// src/client/types/com/atproto/sync/getCommitPath.ts
+var getCommitPath_exports = {};
+__export(getCommitPath_exports, {
+  toKnownErr: () => toKnownErr33
 });
-function toKnownErr22(e) {
+function toKnownErr33(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// src/client/types/com/atproto/sync/updateRepo.ts
-var updateRepo_exports = {};
-__export(updateRepo_exports, {
-  toKnownErr: () => toKnownErr23
+// src/client/types/com/atproto/sync/getHead.ts
+var getHead_exports = {};
+__export(getHead_exports, {
+  toKnownErr: () => toKnownErr34
 });
-function toKnownErr23(e) {
+function toKnownErr34(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// src/client/types/app/bsky/actor/createScene.ts
-var createScene_exports = {};
-__export(createScene_exports, {
-  HandleNotAvailableError: () => HandleNotAvailableError2,
-  InvalidHandleError: () => InvalidHandleError2,
-  toKnownErr: () => toKnownErr24
+// src/client/types/com/atproto/sync/getRecord.ts
+var getRecord_exports3 = {};
+__export(getRecord_exports3, {
+  toKnownErr: () => toKnownErr35
 });
-var InvalidHandleError2 = class extends XRPCError {
-  constructor(src) {
-    super(src.status, src.error, src.message);
-  }
-};
-var HandleNotAvailableError2 = class extends XRPCError {
-  constructor(src) {
-    super(src.status, src.error, src.message);
+function toKnownErr35(e) {
+  if (e instanceof XRPCError) {
   }
-};
-function toKnownErr24(e) {
+  return e;
+}
+
+// src/client/types/com/atproto/sync/getRepo.ts
+var getRepo_exports2 = {};
+__export(getRepo_exports2, {
+  toKnownErr: () => toKnownErr36
+});
+function toKnownErr36(e) {
   if (e instanceof XRPCError) {
-    if (e.error === "InvalidHandle")
-      return new InvalidHandleError2(e);
-    if (e.error === "HandleNotAvailable")
-      return new HandleNotAvailableError2(e);
   }
   return e;
 }
@@ -7757,10 +8603,10 @@ function toKnownErr24(e) {
 var getProfile_exports = {};
 __export(getProfile_exports, {
   isMyState: () => isMyState,
-  toKnownErr: () => toKnownErr25,
+  toKnownErr: () => toKnownErr37,
   validateMyState: () => validateMyState
 });
-function toKnownErr25(e) {
+function toKnownErr37(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7777,11 +8623,11 @@ var getSuggestions_exports = {};
 __export(getSuggestions_exports, {
   isActor: () => isActor,
   isMyState: () => isMyState2,
-  toKnownErr: () => toKnownErr26,
+  toKnownErr: () => toKnownErr38,
   validateActor: () => validateActor,
   validateMyState: () => validateMyState2
 });
-function toKnownErr26(e) {
+function toKnownErr38(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7803,10 +8649,10 @@ function validateMyState2(v) {
 var search_exports = {};
 __export(search_exports, {
   isUser: () => isUser,
-  toKnownErr: () => toKnownErr27,
+  toKnownErr: () => toKnownErr39,
   validateUser: () => validateUser
 });
-function toKnownErr27(e) {
+function toKnownErr39(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7822,10 +8668,10 @@ function validateUser(v) {
 var searchTypeahead_exports = {};
 __export(searchTypeahead_exports, {
   isUser: () => isUser2,
-  toKnownErr: () => toKnownErr28,
+  toKnownErr: () => toKnownErr40,
   validateUser: () => validateUser2
 });
-function toKnownErr28(e) {
+function toKnownErr40(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7844,7 +8690,7 @@ __export(updateProfile_exports, {
   InvalidBlobError: () => InvalidBlobError,
   InvalidImageDimensionsError: () => InvalidImageDimensionsError,
   InvalidMimeTypeError: () => InvalidMimeTypeError,
-  toKnownErr: () => toKnownErr29
+  toKnownErr: () => toKnownErr41
 });
 var InvalidBlobError = class extends XRPCError {
   constructor(src) {
@@ -7866,7 +8712,7 @@ var InvalidImageDimensionsError = class extends XRPCError {
     super(src.status, src.error, src.message);
   }
 };
-function toKnownErr29(e) {
+function toKnownErr41(e) {
   if (e instanceof XRPCError) {
     if (e.error === "InvalidBlob")
       return new InvalidBlobError(e);
@@ -7883,9 +8729,9 @@ function toKnownErr29(e) {
 // src/client/types/app/bsky/feed/getAuthorFeed.ts
 var getAuthorFeed_exports = {};
 __export(getAuthorFeed_exports, {
-  toKnownErr: () => toKnownErr30
+  toKnownErr: () => toKnownErr42
 });
-function toKnownErr30(e) {
+function toKnownErr42(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7897,7 +8743,7 @@ __export(getPostThread_exports, {
   NotFoundError: () => NotFoundError,
   isNotFoundPost: () => isNotFoundPost,
   isThreadViewPost: () => isThreadViewPost,
-  toKnownErr: () => toKnownErr31,
+  toKnownErr: () => toKnownErr43,
   validateNotFoundPost: () => validateNotFoundPost,
   validateThreadViewPost: () => validateThreadViewPost
 });
@@ -7906,7 +8752,7 @@ var NotFoundError = class extends XRPCError {
     super(src.status, src.error, src.message);
   }
 };
-function toKnownErr31(e) {
+function toKnownErr43(e) {
   if (e instanceof XRPCError) {
     if (e.error === "NotFound")
       return new NotFoundError(e);
@@ -7930,10 +8776,10 @@ function validateNotFoundPost(v) {
 var getRepostedBy_exports = {};
 __export(getRepostedBy_exports, {
   isRepostedBy: () => isRepostedBy,
-  toKnownErr: () => toKnownErr32,
+  toKnownErr: () => toKnownErr44,
   validateRepostedBy: () => validateRepostedBy
 });
-function toKnownErr32(e) {
+function toKnownErr44(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7948,9 +8794,9 @@ function validateRepostedBy(v) {
 // src/client/types/app/bsky/feed/getTimeline.ts
 var getTimeline_exports = {};
 __export(getTimeline_exports, {
-  toKnownErr: () => toKnownErr33
+  toKnownErr: () => toKnownErr45
 });
-function toKnownErr33(e) {
+function toKnownErr45(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7960,10 +8806,10 @@ function toKnownErr33(e) {
 var getVotes_exports = {};
 __export(getVotes_exports, {
   isVote: () => isVote,
-  toKnownErr: () => toKnownErr34,
+  toKnownErr: () => toKnownErr46,
   validateVote: () => validateVote
 });
-function toKnownErr34(e) {
+function toKnownErr46(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -7978,49 +8824,22 @@ function validateVote(v) {
 // src/client/types/app/bsky/feed/setVote.ts
 var setVote_exports = {};
 __export(setVote_exports, {
-  toKnownErr: () => toKnownErr35
-});
-function toKnownErr35(e) {
-  if (e instanceof XRPCError) {
-  }
-  return e;
-}
-
-// src/client/types/app/bsky/graph/getAssertions.ts
-var getAssertions_exports = {};
-__export(getAssertions_exports, {
-  isAssertion: () => isAssertion,
-  isConfirmation: () => isConfirmation,
-  toKnownErr: () => toKnownErr36,
-  validateAssertion: () => validateAssertion,
-  validateConfirmation: () => validateConfirmation
+  toKnownErr: () => toKnownErr47
 });
-function toKnownErr36(e) {
+function toKnownErr47(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, {
   isFollower: () => isFollower,
-  toKnownErr: () => toKnownErr37,
+  toKnownErr: () => toKnownErr48,
   validateFollower: () => validateFollower
 });
-function toKnownErr37(e) {
+function toKnownErr48(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8036,10 +8855,10 @@ function validateFollower(v) {
 var getFollows_exports = {};
 __export(getFollows_exports, {
   isFollow: () => isFollow,
-  toKnownErr: () => toKnownErr38,
+  toKnownErr: () => toKnownErr49,
   validateFollow: () => validateFollow
 });
-function toKnownErr38(e) {
+function toKnownErr49(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8051,52 +8870,14 @@ 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, {
-  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, {
-  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,
+  toKnownErr: () => toKnownErr50,
   validateMute: () => validateMute
 });
-function toKnownErr41(e) {
+function toKnownErr50(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8111,9 +8892,9 @@ function validateMute(v) {
 // src/client/types/app/bsky/graph/mute.ts
 var mute_exports = {};
 __export(mute_exports, {
-  toKnownErr: () => toKnownErr42
+  toKnownErr: () => toKnownErr51
 });
-function toKnownErr42(e) {
+function toKnownErr51(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8122,9 +8903,9 @@ function toKnownErr42(e) {
 // src/client/types/app/bsky/graph/unmute.ts
 var unmute_exports = {};
 __export(unmute_exports, {
-  toKnownErr: () => toKnownErr43
+  toKnownErr: () => toKnownErr52
 });
-function toKnownErr43(e) {
+function toKnownErr52(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8133,9 +8914,9 @@ function toKnownErr43(e) {
 // src/client/types/app/bsky/notification/getCount.ts
 var getCount_exports = {};
 __export(getCount_exports, {
-  toKnownErr: () => toKnownErr44
+  toKnownErr: () => toKnownErr53
 });
-function toKnownErr44(e) {
+function toKnownErr53(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8145,10 +8926,10 @@ function toKnownErr44(e) {
 var list_exports = {};
 __export(list_exports, {
   isNotification: () => isNotification,
-  toKnownErr: () => toKnownErr45,
+  toKnownErr: () => toKnownErr54,
   validateNotification: () => validateNotification
 });
-function toKnownErr45(e) {
+function toKnownErr54(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -8160,57 +8941,259 @@ 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: () => toKnownErr46
+// src/client/types/app/bsky/notification/updateSeen.ts
+var updateSeen_exports = {};
+__export(updateSeen_exports, {
+  toKnownErr: () => toKnownErr55
+});
+function toKnownErr55(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/com/atproto/admin/moderationAction.ts
+var moderationAction_exports = {};
+__export(moderationAction_exports, {
+  ACKNOWLEDGE: () => ACKNOWLEDGE,
+  FLAG: () => FLAG,
+  TAKEDOWN: () => TAKEDOWN,
+  isReversal: () => isReversal,
+  isView: () => isView,
+  isViewDetail: () => isViewDetail,
+  validateReversal: () => validateReversal,
+  validateView: () => validateView,
+  validateViewDetail: () => validateViewDetail
+});
+function isView(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.moderationAction#view";
+}
+function validateView(v) {
+  return lexicons.validate("com.atproto.admin.moderationAction#view", v);
+}
+function isViewDetail(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.moderationAction#viewDetail";
+}
+function validateViewDetail(v) {
+  return lexicons.validate("com.atproto.admin.moderationAction#viewDetail", v);
+}
+function isReversal(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.moderationAction#reversal";
+}
+function validateReversal(v) {
+  return lexicons.validate("com.atproto.admin.moderationAction#reversal", v);
+}
+var TAKEDOWN = "com.atproto.admin.moderationAction#takedown";
+var FLAG = "com.atproto.admin.moderationAction#flag";
+var ACKNOWLEDGE = "com.atproto.admin.moderationAction#acknowledge";
+
+// src/client/types/com/atproto/admin/moderationReport.ts
+var moderationReport_exports = {};
+__export(moderationReport_exports, {
+  isView: () => isView2,
+  isViewDetail: () => isViewDetail2,
+  validateView: () => validateView2,
+  validateViewDetail: () => validateViewDetail2
+});
+function isView2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.moderationReport#view";
+}
+function validateView2(v) {
+  return lexicons.validate("com.atproto.admin.moderationReport#view", v);
+}
+function isViewDetail2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.moderationReport#viewDetail";
+}
+function validateViewDetail2(v) {
+  return lexicons.validate("com.atproto.admin.moderationReport#viewDetail", v);
+}
+
+// src/client/types/com/atproto/admin/record.ts
+var record_exports = {};
+__export(record_exports, {
+  isModeration: () => isModeration,
+  isModerationDetail: () => isModerationDetail,
+  isView: () => isView3,
+  isViewDetail: () => isViewDetail3,
+  validateModeration: () => validateModeration,
+  validateModerationDetail: () => validateModerationDetail,
+  validateView: () => validateView3,
+  validateViewDetail: () => validateViewDetail3
+});
+function isView3(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.record#view";
+}
+function validateView3(v) {
+  return lexicons.validate("com.atproto.admin.record#view", v);
+}
+function isViewDetail3(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.record#viewDetail";
+}
+function validateViewDetail3(v) {
+  return lexicons.validate("com.atproto.admin.record#viewDetail", v);
+}
+function isModeration(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.record#moderation";
+}
+function validateModeration(v) {
+  return lexicons.validate("com.atproto.admin.record#moderation", v);
+}
+function isModerationDetail(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.record#moderationDetail";
+}
+function validateModerationDetail(v) {
+  return lexicons.validate("com.atproto.admin.record#moderationDetail", v);
+}
+
+// src/client/types/com/atproto/admin/repo.ts
+var repo_exports = {};
+__export(repo_exports, {
+  isAccount: () => isAccount,
+  isModeration: () => isModeration2,
+  isModerationDetail: () => isModerationDetail2,
+  isView: () => isView4,
+  isViewDetail: () => isViewDetail4,
+  validateAccount: () => validateAccount,
+  validateModeration: () => validateModeration2,
+  validateModerationDetail: () => validateModerationDetail2,
+  validateView: () => validateView4,
+  validateViewDetail: () => validateViewDetail4
+});
+function isView4(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.repo#view";
+}
+function validateView4(v) {
+  return lexicons.validate("com.atproto.admin.repo#view", v);
+}
+function isViewDetail4(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.repo#viewDetail";
+}
+function validateViewDetail4(v) {
+  return lexicons.validate("com.atproto.admin.repo#viewDetail", v);
+}
+function isAccount(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.repo#account";
+}
+function validateAccount(v) {
+  return lexicons.validate("com.atproto.admin.repo#account", v);
+}
+function isModeration2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.repo#moderation";
+}
+function validateModeration2(v) {
+  return lexicons.validate("com.atproto.admin.repo#moderation", v);
+}
+function isModerationDetail2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.admin.repo#moderationDetail";
+}
+function validateModerationDetail2(v) {
+  return lexicons.validate("com.atproto.admin.repo#moderationDetail", v);
+}
+
+// src/client/types/com/atproto/repo/recordRef.ts
+var recordRef_exports = {};
+__export(recordRef_exports, {
+  isMain: () => isMain,
+  validateMain: () => validateMain
+});
+function isMain(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "com.atproto.repo.recordRef#main" || v.$type === "com.atproto.repo.recordRef");
+}
+function validateMain(v) {
+  return lexicons.validate("com.atproto.repo.recordRef#main", v);
+}
+
+// src/client/types/com/atproto/repo/repoRef.ts
+var repoRef_exports = {};
+__export(repoRef_exports, {
+  isMain: () => isMain2,
+  validateMain: () => validateMain2
 });
-function toKnownErr46(e) {
-  if (e instanceof XRPCError) {
-  }
-  return e;
+function isMain2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "com.atproto.repo.repoRef#main" || v.$type === "com.atproto.repo.repoRef");
+}
+function validateMain2(v) {
+  return lexicons.validate("com.atproto.repo.repoRef#main", v);
 }
 
 // src/client/types/com/atproto/repo/strongRef.ts
 var strongRef_exports = {};
 __export(strongRef_exports, {
-  isMain: () => isMain,
-  validateMain: () => validateMain
+  isMain: () => isMain3,
+  validateMain: () => validateMain3
 });
-function isMain(v) {
+function isMain3(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "com.atproto.repo.strongRef#main" || v.$type === "com.atproto.repo.strongRef");
 }
-function validateMain(v) {
+function validateMain3(v) {
   return lexicons.validate("com.atproto.repo.strongRef#main", v);
 }
 
+// src/client/types/com/atproto/report/reasonType.ts
+var reasonType_exports = {};
+__export(reasonType_exports, {
+  OTHER: () => OTHER,
+  SPAM: () => SPAM
+});
+var SPAM = "com.atproto.report.reasonType#spam";
+var OTHER = "com.atproto.report.reasonType#other";
+
+// src/client/types/com/atproto/report/subject.ts
+var subject_exports = {};
+__export(subject_exports, {
+  isRecord: () => isRecord2,
+  isRecordRef: () => isRecordRef,
+  isRepo: () => isRepo,
+  validateRecord: () => validateRecord2,
+  validateRecordRef: () => validateRecordRef,
+  validateRepo: () => validateRepo
+});
+function isRepo(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.report.subject#repo";
+}
+function validateRepo(v) {
+  return lexicons.validate("com.atproto.report.subject#repo", v);
+}
+function isRecord2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.report.subject#record";
+}
+function validateRecord2(v) {
+  return lexicons.validate("com.atproto.report.subject#record", v);
+}
+function isRecordRef(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "com.atproto.report.subject#recordRef";
+}
+function validateRecordRef(v) {
+  return lexicons.validate("com.atproto.report.subject#recordRef", v);
+}
+
 // src/client/types/app/bsky/actor/profile.ts
 var profile_exports = {};
 __export(profile_exports, {
-  isRecord: () => isRecord2,
-  validateRecord: () => validateRecord2
+  isRecord: () => isRecord3,
+  validateRecord: () => validateRecord3
 });
-function isRecord2(v) {
+function isRecord3(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.actor.profile#main" || v.$type === "app.bsky.actor.profile");
 }
-function validateRecord2(v) {
+function validateRecord3(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,
+  isMain: () => isMain4,
   isViewerState: () => isViewerState,
   isWithInfo: () => isWithInfo,
-  validateMain: () => validateMain2,
+  validateMain: () => validateMain4,
   validateViewerState: () => validateViewerState,
   validateWithInfo: () => validateWithInfo
 });
-function isMain2(v) {
+function isMain4(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.actor.ref#main" || v.$type === "app.bsky.actor.ref");
 }
-function validateMain2(v) {
+function validateMain4(v) {
   return lexicons.validate("app.bsky.actor.ref#main", v);
 }
 function isWithInfo(v) {
@@ -8230,18 +9213,18 @@ function validateViewerState(v) {
 var external_exports = {};
 __export(external_exports, {
   isExternal: () => isExternal,
-  isMain: () => isMain3,
+  isMain: () => isMain5,
   isPresented: () => isPresented,
   isPresentedExternal: () => isPresentedExternal,
   validateExternal: () => validateExternal,
-  validateMain: () => validateMain3,
+  validateMain: () => validateMain5,
   validatePresented: () => validatePresented,
   validatePresentedExternal: () => validatePresentedExternal
 });
-function isMain3(v) {
+function isMain5(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.embed.external#main" || v.$type === "app.bsky.embed.external");
 }
-function validateMain3(v) {
+function validateMain5(v) {
   return lexicons.validate("app.bsky.embed.external#main", v);
 }
 function isExternal(v) {
@@ -8267,18 +9250,18 @@ function validatePresentedExternal(v) {
 var images_exports = {};
 __export(images_exports, {
   isImage: () => isImage,
-  isMain: () => isMain4,
+  isMain: () => isMain6,
   isPresented: () => isPresented2,
   isPresentedImage: () => isPresentedImage,
   validateImage: () => validateImage,
-  validateMain: () => validateMain4,
+  validateMain: () => validateMain6,
   validatePresented: () => validatePresented2,
   validatePresentedImage: () => validatePresentedImage
 });
-function isMain4(v) {
+function isMain6(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.embed.images#main" || v.$type === "app.bsky.embed.images");
 }
-function validateMain4(v) {
+function validateMain6(v) {
   return lexicons.validate("app.bsky.embed.images#main", v);
 }
 function isImage(v) {
@@ -8303,19 +9286,17 @@ function validatePresentedImage(v) {
 // src/client/types/app/bsky/feed/feedViewPost.ts
 var feedViewPost_exports = {};
 __export(feedViewPost_exports, {
-  isMain: () => isMain5,
+  isMain: () => isMain7,
   isReasonRepost: () => isReasonRepost,
-  isReasonTrend: () => isReasonTrend,
   isReplyRef: () => isReplyRef,
-  validateMain: () => validateMain5,
+  validateMain: () => validateMain7,
   validateReasonRepost: () => validateReasonRepost,
-  validateReasonTrend: () => validateReasonTrend,
   validateReplyRef: () => validateReplyRef
 });
-function isMain5(v) {
+function isMain7(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.feedViewPost#main" || v.$type === "app.bsky.feed.feedViewPost");
 }
-function validateMain5(v) {
+function validateMain7(v) {
   return lexicons.validate("app.bsky.feed.feedViewPost#main", v);
 }
 function isReplyRef(v) {
@@ -8324,12 +9305,6 @@ function isReplyRef(v) {
 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";
 }
@@ -8341,22 +9316,22 @@ function validateReasonRepost(v) {
 var post_exports = {};
 __export(post_exports, {
   isEntity: () => isEntity,
-  isRecord: () => isRecord3,
+  isRecord: () => isRecord4,
   isReplyRef: () => isReplyRef2,
   isTextSlice: () => isTextSlice,
-  isView: () => isView,
+  isView: () => isView5,
   isViewerState: () => isViewerState2,
   validateEntity: () => validateEntity,
-  validateRecord: () => validateRecord3,
+  validateRecord: () => validateRecord4,
   validateReplyRef: () => validateReplyRef2,
   validateTextSlice: () => validateTextSlice,
-  validateView: () => validateView,
+  validateView: () => validateView5,
   validateViewerState: () => validateViewerState2
 });
-function isRecord3(v) {
+function isRecord4(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.post#main" || v.$type === "app.bsky.feed.post");
 }
-function validateRecord3(v) {
+function validateRecord4(v) {
   return lexicons.validate("app.bsky.feed.post#main", v);
 }
 function isReplyRef2(v) {
@@ -8377,10 +9352,10 @@ function isTextSlice(v) {
 function validateTextSlice(v) {
   return lexicons.validate("app.bsky.feed.post#textSlice", v);
 }
-function isView(v) {
+function isView5(v) {
   return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.post#view";
 }
-function validateView(v) {
+function validateView5(v) {
   return lexicons.validate("app.bsky.feed.post#view", v);
 }
 function isViewerState2(v) {
@@ -8393,27 +9368,14 @@ function validateViewerState2(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");
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.repost#main" || v.$type === "app.bsky.feed.repost");
 }
 function validateRecord5(v) {
-  return lexicons.validate("app.bsky.feed.trend#main", v);
+  return lexicons.validate("app.bsky.feed.repost#main", v);
 }
 
 // src/client/types/app/bsky/feed/vote.ts
@@ -8482,30 +9444,23 @@ function validateRecord9(v) {
   return lexicons.validate("app.bsky.graph.follow#main", v);
 }
 
-// src/client/types/app/bsky/system/actorScene.ts
-var actorScene_exports = {};
-__export(actorScene_exports, {
-  MAIN: () => MAIN3
-});
-var MAIN3 = "app.bsky.system.actorScene#main";
-
 // src/client/types/app/bsky/system/actorUser.ts
 var actorUser_exports = {};
 __export(actorUser_exports, {
-  MAIN: () => MAIN4
+  MAIN: () => MAIN3
 });
-var MAIN4 = "app.bsky.system.actorUser#main";
+var MAIN3 = "app.bsky.system.actorUser#main";
 
 // src/client/types/app/bsky/system/declRef.ts
 var declRef_exports = {};
 __export(declRef_exports, {
-  isMain: () => isMain6,
-  validateMain: () => validateMain6
+  isMain: () => isMain8,
+  validateMain: () => validateMain8
 });
-function isMain6(v) {
+function isMain8(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.system.declRef#main" || v.$type === "app.bsky.system.declRef");
 }
-function validateMain6(v) {
+function validateMain8(v) {
   return lexicons.validate("app.bsky.system.declRef#main", v);
 }
 
@@ -8523,12 +9478,20 @@ function validateRecord10(v) {
 }
 
 // src/client/index.ts
+var COM_ATPROTO_ADMIN = {
+  ModerationActionTakedown: "com.atproto.admin.moderationAction#takedown",
+  ModerationActionFlag: "com.atproto.admin.moderationAction#flag",
+  ModerationActionAcknowledge: "com.atproto.admin.moderationAction#acknowledge"
+};
+var COM_ATPROTO_REPORT = {
+  ReasonTypeSpam: "com.atproto.report.reasonType#spam",
+  ReasonTypeOther: "com.atproto.report.reasonType#other"
+};
 var APP_BSKY_GRAPH = {
   AssertCreator: "app.bsky.graph.assertCreator",
   AssertMember: "app.bsky.graph.assertMember"
 };
 var APP_BSKY_SYSTEM = {
-  ActorScene: "app.bsky.system.actorScene",
   ActorUser: "app.bsky.system.actorUser"
 };
 var Client2 = class {
@@ -8563,9 +9526,11 @@ var AtprotoNS = class {
   constructor(service) {
     this._service = service;
     this.account = new AccountNS(service);
+    this.admin = new AdminNS(service);
     this.blob = new BlobNS(service);
     this.handle = new HandleNS(service);
     this.repo = new RepoNS(service);
+    this.report = new ReportNS(service);
     this.server = new ServerNS(service);
     this.session = new SessionNS(service);
     this.sync = new SyncNS(service);
@@ -8606,13 +9571,68 @@ var AccountNS = class {
     });
   }
 };
+var AdminNS = class {
+  constructor(service) {
+    this._service = service;
+  }
+  getModerationAction(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getModerationAction", params2, void 0, opts).catch((e) => {
+      throw toKnownErr7(e);
+    });
+  }
+  getModerationActions(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getModerationActions", params2, void 0, opts).catch((e) => {
+      throw toKnownErr8(e);
+    });
+  }
+  getModerationReport(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getModerationReport", params2, void 0, opts).catch((e) => {
+      throw toKnownErr9(e);
+    });
+  }
+  getModerationReports(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getModerationReports", params2, void 0, opts).catch((e) => {
+      throw toKnownErr10(e);
+    });
+  }
+  getRecord(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getRecord", params2, void 0, opts).catch((e) => {
+      throw toKnownErr11(e);
+    });
+  }
+  getRepo(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.getRepo", params2, void 0, opts).catch((e) => {
+      throw toKnownErr12(e);
+    });
+  }
+  resolveModerationReports(data, opts) {
+    return this._service.xrpc.call("com.atproto.admin.resolveModerationReports", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr13(e);
+    });
+  }
+  reverseModerationAction(data, opts) {
+    return this._service.xrpc.call("com.atproto.admin.reverseModerationAction", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr14(e);
+    });
+  }
+  searchRepos(params2, opts) {
+    return this._service.xrpc.call("com.atproto.admin.searchRepos", params2, void 0, opts).catch((e) => {
+      throw toKnownErr15(e);
+    });
+  }
+  takeModerationAction(data, opts) {
+    return this._service.xrpc.call("com.atproto.admin.takeModerationAction", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr16(e);
+    });
+  }
+};
 var BlobNS = class {
   constructor(service) {
     this._service = service;
   }
   upload(data, opts) {
     return this._service.xrpc.call("com.atproto.blob.upload", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr7(e);
+      throw toKnownErr17(e);
     });
   }
 };
@@ -8622,7 +9642,7 @@ var HandleNS = class {
   }
   resolve(params2, opts) {
     return this._service.xrpc.call("com.atproto.handle.resolve", params2, void 0, opts).catch((e) => {
-      throw toKnownErr8(e);
+      throw toKnownErr18(e);
     });
   }
 };
@@ -8632,37 +9652,47 @@ var RepoNS = class {
   }
   batchWrite(data, opts) {
     return this._service.xrpc.call("com.atproto.repo.batchWrite", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr9(e);
+      throw toKnownErr19(e);
     });
   }
   createRecord(data, opts) {
     return this._service.xrpc.call("com.atproto.repo.createRecord", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr10(e);
+      throw toKnownErr20(e);
     });
   }
   deleteRecord(data, opts) {
     return this._service.xrpc.call("com.atproto.repo.deleteRecord", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr11(e);
+      throw toKnownErr21(e);
     });
   }
   describe(params2, opts) {
     return this._service.xrpc.call("com.atproto.repo.describe", params2, void 0, opts).catch((e) => {
-      throw toKnownErr12(e);
+      throw toKnownErr22(e);
     });
   }
   getRecord(params2, opts) {
     return this._service.xrpc.call("com.atproto.repo.getRecord", params2, void 0, opts).catch((e) => {
-      throw toKnownErr13(e);
+      throw toKnownErr23(e);
     });
   }
   listRecords(params2, opts) {
     return this._service.xrpc.call("com.atproto.repo.listRecords", params2, void 0, opts).catch((e) => {
-      throw toKnownErr14(e);
+      throw toKnownErr24(e);
     });
   }
   putRecord(data, opts) {
     return this._service.xrpc.call("com.atproto.repo.putRecord", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr15(e);
+      throw toKnownErr25(e);
+    });
+  }
+};
+var ReportNS = class {
+  constructor(service) {
+    this._service = service;
+  }
+  create(data, opts) {
+    return this._service.xrpc.call("com.atproto.report.create", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr26(e);
     });
   }
 };
@@ -8672,7 +9702,7 @@ var ServerNS = class {
   }
   getAccountsConfig(params2, opts) {
     return this._service.xrpc.call("com.atproto.server.getAccountsConfig", params2, void 0, opts).catch((e) => {
-      throw toKnownErr16(e);
+      throw toKnownErr27(e);
     });
   }
 };
@@ -8682,22 +9712,22 @@ var SessionNS = class {
   }
   create(data, opts) {
     return this._service.xrpc.call("com.atproto.session.create", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr17(e);
+      throw toKnownErr28(e);
     });
   }
   delete(data, opts) {
     return this._service.xrpc.call("com.atproto.session.delete", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr18(e);
+      throw toKnownErr29(e);
     });
   }
   get(params2, opts) {
     return this._service.xrpc.call("com.atproto.session.get", params2, void 0, opts).catch((e) => {
-      throw toKnownErr19(e);
+      throw toKnownErr30(e);
     });
   }
   refresh(data, opts) {
     return this._service.xrpc.call("com.atproto.session.refresh", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr20(e);
+      throw toKnownErr31(e);
     });
   }
 };
@@ -8705,19 +9735,29 @@ var SyncNS = class {
   constructor(service) {
     this._service = service;
   }
-  getRepo(params2, opts) {
-    return this._service.xrpc.call("com.atproto.sync.getRepo", params2, void 0, opts).catch((e) => {
-      throw toKnownErr21(e);
+  getCheckout(params2, opts) {
+    return this._service.xrpc.call("com.atproto.sync.getCheckout", params2, void 0, opts).catch((e) => {
+      throw toKnownErr32(e);
     });
   }
-  getRoot(params2, opts) {
-    return this._service.xrpc.call("com.atproto.sync.getRoot", params2, void 0, opts).catch((e) => {
-      throw toKnownErr22(e);
+  getCommitPath(params2, opts) {
+    return this._service.xrpc.call("com.atproto.sync.getCommitPath", params2, void 0, opts).catch((e) => {
+      throw toKnownErr33(e);
     });
   }
-  updateRepo(data, opts) {
-    return this._service.xrpc.call("com.atproto.sync.updateRepo", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr23(e);
+  getHead(params2, opts) {
+    return this._service.xrpc.call("com.atproto.sync.getHead", params2, void 0, opts).catch((e) => {
+      throw toKnownErr34(e);
+    });
+  }
+  getRecord(params2, opts) {
+    return this._service.xrpc.call("com.atproto.sync.getRecord", params2, void 0, opts).catch((e) => {
+      throw toKnownErr35(e);
+    });
+  }
+  getRepo(params2, opts) {
+    return this._service.xrpc.call("com.atproto.sync.getRepo", params2, void 0, opts).catch((e) => {
+      throw toKnownErr36(e);
     });
   }
 };
@@ -8743,34 +9783,29 @@ var ActorNS = class {
     this._service = service;
     this.profile = new ProfileRecord(service);
   }
-  createScene(data, opts) {
-    return this._service.xrpc.call("app.bsky.actor.createScene", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr24(e);
-    });
-  }
   getProfile(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getProfile", params2, void 0, opts).catch((e) => {
-      throw toKnownErr25(e);
+      throw toKnownErr37(e);
     });
   }
   getSuggestions(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getSuggestions", params2, void 0, opts).catch((e) => {
-      throw toKnownErr26(e);
+      throw toKnownErr38(e);
     });
   }
   search(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.search", params2, void 0, opts).catch((e) => {
-      throw toKnownErr27(e);
+      throw toKnownErr39(e);
     });
   }
   searchTypeahead(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.searchTypeahead", params2, void 0, opts).catch((e) => {
-      throw toKnownErr28(e);
+      throw toKnownErr40(e);
     });
   }
   updateProfile(data, opts) {
     return this._service.xrpc.call("app.bsky.actor.updateProfile", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr29(e);
+      throw toKnownErr41(e);
     });
   }
 };
@@ -8821,37 +9856,36 @@ var FeedNS = class {
     this._service = service;
     this.post = new PostRecord(service);
     this.repost = new RepostRecord(service);
-    this.trend = new TrendRecord(service);
     this.vote = new VoteRecord(service);
   }
   getAuthorFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getAuthorFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr30(e);
+      throw toKnownErr42(e);
     });
   }
   getPostThread(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPostThread", params2, void 0, opts).catch((e) => {
-      throw toKnownErr31(e);
+      throw toKnownErr43(e);
     });
   }
   getRepostedBy(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getRepostedBy", params2, void 0, opts).catch((e) => {
-      throw toKnownErr32(e);
+      throw toKnownErr44(e);
     });
   }
   getTimeline(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getTimeline", params2, void 0, opts).catch((e) => {
-      throw toKnownErr33(e);
+      throw toKnownErr45(e);
     });
   }
   getVotes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getVotes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr34(e);
+      throw toKnownErr46(e);
     });
   }
   setVote(data, opts) {
     return this._service.xrpc.call("app.bsky.feed.setVote", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr35(e);
+      throw toKnownErr47(e);
     });
   }
 };
@@ -8929,43 +9963,6 @@ var RepostRecord = class {
     );
   }
 };
-var TrendRecord = class {
-  constructor(service) {
-    this._service = service;
-  }
-  async list(params2) {
-    const res = await this._service.xrpc.call("com.atproto.repo.listRecords", {
-      collection: "app.bsky.feed.trend",
-      ...params2
-    });
-    return res.data;
-  }
-  async get(params2) {
-    const res = await this._service.xrpc.call("com.atproto.repo.getRecord", {
-      collection: "app.bsky.feed.trend",
-      ...params2
-    });
-    return res.data;
-  }
-  async create(params2, record, headers) {
-    record.$type = "app.bsky.feed.trend";
-    const res = await this._service.xrpc.call(
-      "com.atproto.repo.createRecord",
-      void 0,
-      { collection: "app.bsky.feed.trend", ...params2, record },
-      { encoding: "application/json", headers }
-    );
-    return res.data;
-  }
-  async delete(params2, headers) {
-    await this._service.xrpc.call(
-      "com.atproto.repo.deleteRecord",
-      void 0,
-      { collection: "app.bsky.feed.trend", ...params2 },
-      { headers }
-    );
-  }
-};
 var VoteRecord = class {
   constructor(service) {
     this._service = service;
@@ -9010,44 +10007,29 @@ var GraphNS = class {
     this.confirmation = new ConfirmationRecord(service);
     this.follow = new FollowRecord(service);
   }
-  getAssertions(params2, opts) {
-    return this._service.xrpc.call("app.bsky.graph.getAssertions", params2, void 0, opts).catch((e) => {
-      throw toKnownErr36(e);
-    });
-  }
   getFollowers(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollowers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr37(e);
+      throw toKnownErr48(e);
     });
   }
   getFollows(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollows", params2, void 0, opts).catch((e) => {
-      throw toKnownErr38(e);
-    });
-  }
-  getMembers(params2, opts) {
-    return this._service.xrpc.call("app.bsky.graph.getMembers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr39(e);
-    });
-  }
-  getMemberships(params2, opts) {
-    return this._service.xrpc.call("app.bsky.graph.getMemberships", params2, void 0, opts).catch((e) => {
-      throw toKnownErr40(e);
+      throw toKnownErr49(e);
     });
   }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr41(e);
+      throw toKnownErr50(e);
     });
   }
   mute(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.mute", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr42(e);
+      throw toKnownErr51(e);
     });
   }
   unmute(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmute", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr43(e);
+      throw toKnownErr52(e);
     });
   }
 };
@@ -9168,17 +10150,17 @@ var NotificationNS = class {
   }
   getCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr44(e);
+      throw toKnownErr53(e);
     });
   }
   list(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.list", params2, void 0, opts).catch((e) => {
-      throw toKnownErr45(e);
+      throw toKnownErr54(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr46(e);
+      throw toKnownErr55(e);
     });
   }
 };
@@ -9355,7 +10337,7 @@ var SessionManager = class extends import_events.default {
   APP_BSKY_SYSTEM,
   AccountNS,
   ActorNS,
-  AppBskyActorCreateScene,
+  AdminNS,
   AppBskyActorGetProfile,
   AppBskyActorGetSuggestions,
   AppBskyActorProfile,
@@ -9374,25 +10356,20 @@ var SessionManager = class extends import_events.default {
   AppBskyFeedPost,
   AppBskyFeedRepost,
   AppBskyFeedSetVote,
-  AppBskyFeedTrend,
   AppBskyFeedVote,
   AppBskyGraphAssertCreator,
   AppBskyGraphAssertMember,
   AppBskyGraphAssertion,
   AppBskyGraphConfirmation,
   AppBskyGraphFollow,
-  AppBskyGraphGetAssertions,
   AppBskyGraphGetFollowers,
   AppBskyGraphGetFollows,
-  AppBskyGraphGetMembers,
-  AppBskyGraphGetMemberships,
   AppBskyGraphGetMutes,
   AppBskyGraphMute,
   AppBskyGraphUnmute,
   AppBskyNotificationGetCount,
   AppBskyNotificationList,
   AppBskyNotificationUpdateSeen,
-  AppBskySystemActorScene,
   AppBskySystemActorUser,
   AppBskySystemDeclRef,
   AppBskySystemDeclaration,
@@ -9401,6 +10378,8 @@ var SessionManager = class extends import_events.default {
   AtprotoNS,
   BlobNS,
   BskyNS,
+  COM_ATPROTO_ADMIN,
+  COM_ATPROTO_REPORT,
   Client,
   ComAtprotoAccountCreate,
   ComAtprotoAccountCreateInviteCode,
@@ -9408,6 +10387,20 @@ var SessionManager = class extends import_events.default {
   ComAtprotoAccountGet,
   ComAtprotoAccountRequestPasswordReset,
   ComAtprotoAccountResetPassword,
+  ComAtprotoAdminGetModerationAction,
+  ComAtprotoAdminGetModerationActions,
+  ComAtprotoAdminGetModerationReport,
+  ComAtprotoAdminGetModerationReports,
+  ComAtprotoAdminGetRecord,
+  ComAtprotoAdminGetRepo,
+  ComAtprotoAdminModerationAction,
+  ComAtprotoAdminModerationReport,
+  ComAtprotoAdminRecord,
+  ComAtprotoAdminRepo,
+  ComAtprotoAdminResolveModerationReports,
+  ComAtprotoAdminReverseModerationAction,
+  ComAtprotoAdminSearchRepos,
+  ComAtprotoAdminTakeModerationAction,
   ComAtprotoBlobUpload,
   ComAtprotoHandleResolve,
   ComAtprotoRepoBatchWrite,
@@ -9417,15 +10410,22 @@ var SessionManager = class extends import_events.default {
   ComAtprotoRepoGetRecord,
   ComAtprotoRepoListRecords,
   ComAtprotoRepoPutRecord,
+  ComAtprotoRepoRecordRef,
+  ComAtprotoRepoRepoRef,
   ComAtprotoRepoStrongRef,
+  ComAtprotoReportCreate,
+  ComAtprotoReportReasonType,
+  ComAtprotoReportSubject,
   ComAtprotoServerGetAccountsConfig,
   ComAtprotoSessionCreate,
   ComAtprotoSessionDelete,
   ComAtprotoSessionGet,
   ComAtprotoSessionRefresh,
+  ComAtprotoSyncGetCheckout,
+  ComAtprotoSyncGetCommitPath,
+  ComAtprotoSyncGetHead,
+  ComAtprotoSyncGetRecord,
   ComAtprotoSyncGetRepo,
-  ComAtprotoSyncGetRoot,
-  ComAtprotoSyncUpdateRepo,
   ComNS,
   ConfirmationRecord,
   DeclarationRecord,
@@ -9438,6 +10438,7 @@ var SessionManager = class extends import_events.default {
   PostRecord,
   ProfileRecord,
   RepoNS,
+  ReportNS,
   RepostRecord,
   ServerNS,
   ServiceClient,
@@ -9448,7 +10449,6 @@ var SessionManager = class extends import_events.default {
   SessionXrpcServiceClient,
   SyncNS,
   SystemNS,
-  TrendRecord,
   VoteRecord,
   sessionClient
 });