@atproto/api 0.3.6 → 0.3.8

package/dist/index.js

@@ -8889,7 +8889,14 @@ __export(src_exports4, {
   AppBskyEmbedRecord: () => record_exports,
   AppBskyEmbedRecordWithMedia: () => recordWithMedia_exports,
   AppBskyFeedDefs: () => defs_exports6,
+  AppBskyFeedDescribeFeedGenerator: () => describeFeedGenerator_exports,
+  AppBskyFeedGenerator: () => generator_exports,
+  AppBskyFeedGetActorFeeds: () => getActorFeeds_exports,
   AppBskyFeedGetAuthorFeed: () => getAuthorFeed_exports,
+  AppBskyFeedGetFeed: () => getFeed_exports,
+  AppBskyFeedGetFeedGenerator: () => getFeedGenerator_exports,
+  AppBskyFeedGetFeedGenerators: () => getFeedGenerators_exports,
+  AppBskyFeedGetFeedSkeleton: () => getFeedSkeleton_exports,
   AppBskyFeedGetLikes: () => getLikes_exports,
   AppBskyFeedGetPostThread: () => getPostThread_exports,
   AppBskyFeedGetPosts: () => getPosts_exports,
@@ -8919,6 +8926,7 @@ __export(src_exports4, {
   AppBskyNotificationUpdateSeen: () => updateSeen_exports,
   AppBskyRichtextFacet: () => facet_exports,
   AppBskyUnspeccedGetPopular: () => getPopular_exports,
+  AppBskyUnspeccedGetPopularFeedGenerators: () => getPopularFeedGenerators_exports,
   AppNS: () => AppNS,
   AtUri: () => AtUri,
   AtpAgent: () => AtpAgent,
@@ -8998,6 +9006,7 @@ __export(src_exports4, {
   EmbedNS: () => EmbedNS,
   FeedNS: () => FeedNS,
   FollowRecord: () => FollowRecord,
+  GeneratorRecord: () => GeneratorRecord,
   GraphNS: () => GraphNS,
   IdentityNS: () => IdentityNS,
   LabelNS: () => LabelNS,
@@ -15206,218 +15215,6 @@ function parseRelative(str) {
   return void 0;
 }
 
-// ../lexicon/src/types.ts
-var lexBoolean = z.object({
-  type: z.literal("boolean"),
-  description: z.string().optional(),
-  default: z.boolean().optional(),
-  const: z.boolean().optional()
-});
-var lexInteger = z.object({
-  type: z.literal("integer"),
-  description: z.string().optional(),
-  default: z.number().int().optional(),
-  minimum: z.number().int().optional(),
-  maximum: z.number().int().optional(),
-  enum: z.number().int().array().optional(),
-  const: z.number().int().optional()
-});
-var lexStringFormat = z.enum([
-  "datetime",
-  "uri",
-  "at-uri",
-  "did",
-  "handle",
-  "at-identifier",
-  "nsid",
-  "cid"
-]);
-var lexString = z.object({
-  type: z.literal("string"),
-  format: lexStringFormat.optional(),
-  description: z.string().optional(),
-  default: z.string().optional(),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-  minGraphemes: z.number().int().optional(),
-  maxGraphemes: z.number().int().optional(),
-  enum: z.string().array().optional(),
-  const: z.string().optional(),
-  knownValues: z.string().array().optional()
-});
-var lexUnknown = z.object({
-  type: z.literal("unknown"),
-  description: z.string().optional()
-});
-var lexPrimitive = z.discriminatedUnion("type", [
-  lexBoolean,
-  lexInteger,
-  lexString,
-  lexUnknown
-]);
-var lexBytes = z.object({
-  type: z.literal("bytes"),
-  description: z.string().optional(),
-  maxLength: z.number().optional(),
-  minLength: z.number().optional()
-});
-var lexCidLink = z.object({
-  type: z.literal("cid-link"),
-  description: z.string().optional()
-});
-var lexIpldType = z.discriminatedUnion("type", [lexBytes, lexCidLink]);
-var lexRef = z.object({
-  type: z.literal("ref"),
-  description: z.string().optional(),
-  ref: z.string()
-});
-var lexRefUnion = z.object({
-  type: z.literal("union"),
-  description: z.string().optional(),
-  refs: z.string().array(),
-  closed: z.boolean().optional()
-});
-var lexRefVariant = z.discriminatedUnion("type", [lexRef, lexRefUnion]);
-var lexBlob = z.object({
-  type: z.literal("blob"),
-  description: z.string().optional(),
-  accept: z.string().array().optional(),
-  maxSize: z.number().optional()
-});
-var lexArray = z.object({
-  type: z.literal("array"),
-  description: z.string().optional(),
-  items: z.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional()
-});
-var lexPrimitiveArray = lexArray.merge(
-  z.object({
-    items: lexPrimitive
-  })
-);
-var lexToken = z.object({
-  type: z.literal("token"),
-  description: z.string().optional()
-});
-var lexObject = z.object({
-  type: z.literal("object"),
-  description: z.string().optional(),
-  required: z.string().array().optional(),
-  nullable: z.string().array().optional(),
-  properties: z.record(
-    z.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive])
-  ).optional()
-});
-var lexXrpcParameters = z.object({
-  type: z.literal("params"),
-  description: z.string().optional(),
-  required: z.string().array().optional(),
-  properties: z.record(z.union([lexPrimitive, lexPrimitiveArray]))
-});
-var lexXrpcBody = z.object({
-  description: z.string().optional(),
-  encoding: z.string(),
-  schema: z.union([lexRefVariant, lexObject]).optional()
-});
-var lexXrpcSubscriptionMessage = z.object({
-  description: z.string().optional(),
-  schema: z.union([lexRefVariant, lexObject]).optional()
-});
-var lexXrpcError = z.object({
-  name: z.string(),
-  description: z.string().optional()
-});
-var lexXrpcQuery = z.object({
-  type: z.literal("query"),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  output: lexXrpcBody.optional(),
-  errors: lexXrpcError.array().optional()
-});
-var lexXrpcProcedure = z.object({
-  type: z.literal("procedure"),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  input: lexXrpcBody.optional(),
-  output: lexXrpcBody.optional(),
-  errors: lexXrpcError.array().optional()
-});
-var lexXrpcSubscription = z.object({
-  type: z.literal("subscription"),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  message: lexXrpcSubscriptionMessage.optional(),
-  infos: lexXrpcError.array().optional(),
-  errors: lexXrpcError.array().optional()
-});
-var lexRecord = z.object({
-  type: z.literal("record"),
-  description: z.string().optional(),
-  key: z.string().optional(),
-  record: lexObject
-});
-var lexUserType = z.discriminatedUnion("type", [
-  lexRecord,
-  lexXrpcQuery,
-  lexXrpcProcedure,
-  lexXrpcSubscription,
-  lexBlob,
-  lexArray,
-  lexToken,
-  lexObject,
-  lexBoolean,
-  lexInteger,
-  lexString,
-  lexBytes,
-  lexCidLink,
-  lexUnknown
-]);
-var lexiconDoc = z.object({
-  lexicon: z.literal(1),
-  id: z.string().refine((v) => NSID.isValid(v), {
-    message: "Must be a valid NSID"
-  }),
-  revision: z.number().optional(),
-  description: z.string().optional(),
-  defs: z.record(lexUserType)
-}).superRefine((doc, ctx) => {
-  for (const defId in doc.defs) {
-    const def2 = doc.defs[defId];
-    if (defId !== "main" && (def2.type === "record" || def2.type === "procedure" || def2.type === "query" || def2.type === "subscription")) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Records, procedures, queries, and subscriptions must be the main definition.`
-      });
-    }
-  }
-});
-function isObj(obj) {
-  return obj !== null && typeof obj === "object";
-}
-function hasProp(data, prop) {
-  return prop in data;
-}
-var discriminatedObject = z.object({ $type: z.string() });
-function isDiscriminatedObject(value) {
-  return discriminatedObject.safeParse(value).success;
-}
-var LexiconDocMalformedError = class extends Error {
-  constructor(message, schemaDef, issues) {
-    super(message);
-    this.schemaDef = schemaDef;
-    this.issues = issues;
-    this.schemaDef = schemaDef;
-    this.issues = issues;
-  }
-};
-var ValidationError = class extends Error {
-};
-var InvalidLexiconError = class extends Error {
-};
-var LexiconDefNotFoundError = class extends Error {
-};
-
 // ../lexicon/src/validators/formats.ts
 var import_iso_datestring_validator = __toESM(require_dist());
 function datetime(path, value) {
@@ -16008,6 +15805,290 @@ function toConcreteTypes(lexicons2, def2) {
     return [def2];
   }
 }
+function requiredPropertiesRefinement(object2, ctx) {
+  if (object2.required === void 0) {
+    return;
+  }
+  if (!Array.isArray(object2.required)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.invalid_type,
+      received: typeof object2.required,
+      expected: "array"
+    });
+    return;
+  }
+  if (object2.properties === void 0) {
+    if (object2.required.length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Required fields defined but no properties defined`
+      });
+    }
+    return;
+  }
+  for (const field of object2.required) {
+    if (object2.properties[field] === void 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Required field "${field}" not defined`
+      });
+    }
+  }
+}
+
+// ../lexicon/src/types.ts
+var lexBoolean = z.object({
+  type: z.literal("boolean"),
+  description: z.string().optional(),
+  default: z.boolean().optional(),
+  const: z.boolean().optional()
+});
+var lexInteger = z.object({
+  type: z.literal("integer"),
+  description: z.string().optional(),
+  default: z.number().int().optional(),
+  minimum: z.number().int().optional(),
+  maximum: z.number().int().optional(),
+  enum: z.number().int().array().optional(),
+  const: z.number().int().optional()
+});
+var lexStringFormat = z.enum([
+  "datetime",
+  "uri",
+  "at-uri",
+  "did",
+  "handle",
+  "at-identifier",
+  "nsid",
+  "cid"
+]);
+var lexString = z.object({
+  type: z.literal("string"),
+  format: lexStringFormat.optional(),
+  description: z.string().optional(),
+  default: z.string().optional(),
+  minLength: z.number().int().optional(),
+  maxLength: z.number().int().optional(),
+  minGraphemes: z.number().int().optional(),
+  maxGraphemes: z.number().int().optional(),
+  enum: z.string().array().optional(),
+  const: z.string().optional(),
+  knownValues: z.string().array().optional()
+});
+var lexUnknown = z.object({
+  type: z.literal("unknown"),
+  description: z.string().optional()
+});
+var lexPrimitive = z.discriminatedUnion("type", [
+  lexBoolean,
+  lexInteger,
+  lexString,
+  lexUnknown
+]);
+var lexBytes = z.object({
+  type: z.literal("bytes"),
+  description: z.string().optional(),
+  maxLength: z.number().optional(),
+  minLength: z.number().optional()
+});
+var lexCidLink = z.object({
+  type: z.literal("cid-link"),
+  description: z.string().optional()
+});
+var lexIpldType = z.discriminatedUnion("type", [lexBytes, lexCidLink]);
+var lexRef = z.object({
+  type: z.literal("ref"),
+  description: z.string().optional(),
+  ref: z.string()
+});
+var lexRefUnion = z.object({
+  type: z.literal("union"),
+  description: z.string().optional(),
+  refs: z.string().array(),
+  closed: z.boolean().optional()
+});
+var lexRefVariant = z.discriminatedUnion("type", [lexRef, lexRefUnion]);
+var lexBlob = z.object({
+  type: z.literal("blob"),
+  description: z.string().optional(),
+  accept: z.string().array().optional(),
+  maxSize: z.number().optional()
+});
+var lexArray = z.object({
+  type: z.literal("array"),
+  description: z.string().optional(),
+  items: z.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
+  minLength: z.number().int().optional(),
+  maxLength: z.number().int().optional()
+});
+var lexPrimitiveArray = lexArray.merge(
+  z.object({
+    items: lexPrimitive
+  })
+);
+var lexToken = z.object({
+  type: z.literal("token"),
+  description: z.string().optional()
+});
+var lexObject = z.object({
+  type: z.literal("object"),
+  description: z.string().optional(),
+  required: z.string().array().optional(),
+  nullable: z.string().array().optional(),
+  properties: z.record(
+    z.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive])
+  ).optional()
+}).superRefine(requiredPropertiesRefinement);
+var lexXrpcParameters = z.object({
+  type: z.literal("params"),
+  description: z.string().optional(),
+  required: z.string().array().optional(),
+  properties: z.record(z.union([lexPrimitive, lexPrimitiveArray]))
+}).superRefine(requiredPropertiesRefinement);
+var lexXrpcBody = z.object({
+  description: z.string().optional(),
+  encoding: z.string(),
+  schema: z.union([lexRefVariant, lexObject]).optional()
+});
+var lexXrpcSubscriptionMessage = z.object({
+  description: z.string().optional(),
+  schema: z.union([lexRefVariant, lexObject]).optional()
+});
+var lexXrpcError = z.object({
+  name: z.string(),
+  description: z.string().optional()
+});
+var lexXrpcQuery = z.object({
+  type: z.literal("query"),
+  description: z.string().optional(),
+  parameters: lexXrpcParameters.optional(),
+  output: lexXrpcBody.optional(),
+  errors: lexXrpcError.array().optional()
+});
+var lexXrpcProcedure = z.object({
+  type: z.literal("procedure"),
+  description: z.string().optional(),
+  parameters: lexXrpcParameters.optional(),
+  input: lexXrpcBody.optional(),
+  output: lexXrpcBody.optional(),
+  errors: lexXrpcError.array().optional()
+});
+var lexXrpcSubscription = z.object({
+  type: z.literal("subscription"),
+  description: z.string().optional(),
+  parameters: lexXrpcParameters.optional(),
+  message: lexXrpcSubscriptionMessage.optional(),
+  infos: lexXrpcError.array().optional(),
+  errors: lexXrpcError.array().optional()
+});
+var lexRecord = z.object({
+  type: z.literal("record"),
+  description: z.string().optional(),
+  key: z.string().optional(),
+  record: lexObject
+});
+var lexUserType = z.custom(
+  (val) => {
+    if (!val || typeof val !== "object") {
+      return;
+    }
+    if (val["type"] === void 0) {
+      return;
+    }
+    switch (val["type"]) {
+      case "record":
+        return lexRecord.parse(val);
+      case "query":
+        return lexXrpcQuery.parse(val);
+      case "procedure":
+        return lexXrpcProcedure.parse(val);
+      case "subscription":
+        return lexXrpcSubscription.parse(val);
+      case "blob":
+        return lexBlob.parse(val);
+      case "array":
+        return lexArray.parse(val);
+      case "token":
+        return lexToken.parse(val);
+      case "object":
+        return lexObject.parse(val);
+      case "boolean":
+        return lexBoolean.parse(val);
+      case "integer":
+        return lexInteger.parse(val);
+      case "string":
+        return lexString.parse(val);
+      case "bytes":
+        return lexBytes.parse(val);
+      case "cid-link":
+        return lexCidLink.parse(val);
+      case "unknown":
+        return lexUnknown.parse(val);
+    }
+  },
+  (val) => {
+    if (!val || typeof val !== "object") {
+      return {
+        message: "Must be an object",
+        fatal: true
+      };
+    }
+    if (val["type"] === void 0) {
+      return {
+        message: "Must have a type",
+        fatal: true
+      };
+    }
+    return {
+      message: `Invalid type: ${val["type"]} must be one of: record, query, procedure, subscription, blob, array, token, object, boolean, integer, string, bytes, cid-link, unknown`,
+      fatal: true
+    };
+  }
+);
+var lexiconDoc = z.object({
+  lexicon: z.literal(1),
+  id: z.string().refine((v) => NSID.isValid(v), {
+    message: "Must be a valid NSID"
+  }),
+  revision: z.number().optional(),
+  description: z.string().optional(),
+  defs: z.record(lexUserType)
+}).superRefine((doc, ctx) => {
+  for (const defId in doc.defs) {
+    const def2 = doc.defs[defId];
+    if (defId !== "main" && (def2.type === "record" || def2.type === "procedure" || def2.type === "query" || def2.type === "subscription")) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Records, procedures, queries, and subscriptions must be the main definition.`
+      });
+    }
+  }
+});
+function isObj(obj) {
+  return obj !== null && typeof obj === "object";
+}
+function hasProp(data, prop) {
+  return prop in data;
+}
+var discriminatedObject = z.object({ $type: z.string() });
+function isDiscriminatedObject(value) {
+  return discriminatedObject.safeParse(value).success;
+}
+var LexiconDocMalformedError = class extends Error {
+  constructor(message, schemaDef, issues) {
+    super(message);
+    this.schemaDef = schemaDef;
+    this.issues = issues;
+    this.schemaDef = schemaDef;
+    this.issues = issues;
+  }
+};
+var ValidationError = class extends Error {
+};
+var InvalidLexiconError = class extends Error {
+};
+var LexiconDefNotFoundError = class extends Error {
+};
 
 // ../lexicon/src/validators/xrpc.ts
 function params(lexicons2, path, def2, val) {
@@ -16427,6 +16508,13 @@ function encodeQueryParam(type, value) {
   }
   throw new Error(`Unsupported query param type: ${type}`);
 }
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [header, value] of Object.entries(headers)) {
+    normalized[header.toLowerCase()] = value;
+  }
+  return normalized;
+}
 function constructMethodCallHeaders(schema2, data, opts) {
   const headers = opts?.headers || {};
   if (schema2.type === "procedure") {
@@ -16442,16 +16530,16 @@ function constructMethodCallHeaders(schema2, data, opts) {
   return headers;
 }
 function encodeMethodCallBody(headers, data) {
-  if (!headers["Content-Type"] || typeof data === "undefined") {
+  if (!headers["content-type"] || typeof data === "undefined") {
     return void 0;
   }
   if (data instanceof ArrayBuffer) {
     return data;
   }
-  if (headers["Content-Type"].startsWith("text/")) {
+  if (headers["content-type"].startsWith("text/")) {
     return new TextEncoder().encode(data.toString());
   }
-  if (headers["Content-Type"].startsWith("application/json")) {
+  if (headers["content-type"].startsWith("application/json")) {
     return new TextEncoder().encode(stringifyLex(data));
   }
   return data;
@@ -16584,10 +16672,11 @@ var ServiceClient = class {
 };
 async function defaultFetchHandler(httpUri, httpMethod, httpHeaders, httpReqBody) {
   try {
+    const headers = normalizeHeaders(httpHeaders);
     const reqInit = {
       method: httpMethod,
-      headers: httpHeaders,
-      body: encodeMethodCallBody(httpHeaders, httpReqBody),
+      headers,
+      body: encodeMethodCallBody(headers, httpReqBody),
       duplex: "half"
     };
     const res = await fetch(httpUri, reqInit);
@@ -18203,7 +18292,7 @@ var schemaDict = {
       create: {
         type: "object",
         description: "Create a new record.",
-        required: ["action", "collection", "value"],
+        required: ["collection", "value"],
         properties: {
           collection: {
             type: "string",
@@ -18221,15 +18310,14 @@ var schemaDict = {
       update: {
         type: "object",
         description: "Update an existing record.",
-        required: ["action", "collection", "rkey", "value"],
+        required: ["collection", "rkey", "value"],
         properties: {
           collection: {
             type: "string",
             format: "nsid"
           },
           rkey: {
-            type: "string",
-            maxLength: 15
+            type: "string"
           },
           value: {
             type: "unknown"
@@ -18239,7 +18327,7 @@ var schemaDict = {
       delete: {
         type: "object",
         description: "Delete an existing record.",
-        required: ["action", "collection", "rkey"],
+        required: ["collection", "rkey"],
         properties: {
           collection: {
             type: "string",
@@ -20145,7 +20233,8 @@ var schemaDict = {
           type: "union",
           refs: [
             "lex:app.bsky.actor.defs#adultContentPref",
-            "lex:app.bsky.actor.defs#contentLabelPref"
+            "lex:app.bsky.actor.defs#contentLabelPref",
+            "lex:app.bsky.actor.defs#savedFeedsPref"
           ]
         }
       },
@@ -20171,6 +20260,26 @@ var schemaDict = {
             knownValues: ["show", "warn", "hide"]
           }
         }
+      },
+      savedFeedsPref: {
+        type: "object",
+        required: ["pinned", "saved"],
+        properties: {
+          pinned: {
+            type: "array",
+            items: {
+              type: "string",
+              format: "at-uri"
+            }
+          },
+          saved: {
+            type: "array",
+            items: {
+              type: "string",
+              format: "at-uri"
+            }
+          }
+        }
       }
     }
   },
@@ -20608,7 +20717,8 @@ var schemaDict = {
             refs: [
               "lex:app.bsky.embed.record#viewRecord",
               "lex:app.bsky.embed.record#viewNotFound",
-              "lex:app.bsky.embed.record#viewBlocked"
+              "lex:app.bsky.embed.record#viewBlocked",
+              "lex:app.bsky.feed.defs#generatorView"
             ]
           }
         }
@@ -20811,12 +20921,20 @@ var schemaDict = {
         required: ["root", "parent"],
         properties: {
           root: {
-            type: "ref",
-            ref: "lex:app.bsky.feed.defs#postView"
+            type: "union",
+            refs: [
+              "lex:app.bsky.feed.defs#postView",
+              "lex:app.bsky.feed.defs#notFoundPost",
+              "lex:app.bsky.feed.defs#blockedPost"
+            ]
           },
           parent: {
-            type: "ref",
-            ref: "lex:app.bsky.feed.defs#postView"
+            type: "union",
+            refs: [
+              "lex:app.bsky.feed.defs#postView",
+              "lex:app.bsky.feed.defs#notFoundPost",
+              "lex:app.bsky.feed.defs#blockedPost"
+            ]
           }
         }
       },
@@ -20890,6 +21008,241 @@ var schemaDict = {
             const: true
           }
         }
+      },
+      generatorView: {
+        type: "object",
+        required: ["uri", "cid", "creator", "displayName", "indexedAt"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          },
+          cid: {
+            type: "string",
+            format: "cid"
+          },
+          did: {
+            type: "string",
+            format: "did"
+          },
+          creator: {
+            type: "ref",
+            ref: "lex:app.bsky.actor.defs#profileView"
+          },
+          displayName: {
+            type: "string"
+          },
+          description: {
+            type: "string",
+            maxGraphemes: 300,
+            maxLength: 3e3
+          },
+          descriptionFacets: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:app.bsky.richtext.facet"
+            }
+          },
+          avatar: {
+            type: "string"
+          },
+          likeCount: {
+            type: "integer",
+            minimum: 0
+          },
+          viewer: {
+            type: "ref",
+            ref: "lex:app.bsky.feed.defs#generatorViewerState"
+          },
+          indexedAt: {
+            type: "string",
+            format: "datetime"
+          }
+        }
+      },
+      generatorViewerState: {
+        type: "object",
+        properties: {
+          like: {
+            type: "string",
+            format: "at-uri"
+          }
+        }
+      },
+      skeletonFeedPost: {
+        type: "object",
+        required: ["post"],
+        properties: {
+          post: {
+            type: "string",
+            format: "at-uri"
+          },
+          reason: {
+            type: "union",
+            refs: ["lex:app.bsky.feed.defs#skeletonReasonRepost"]
+          }
+        }
+      },
+      skeletonReasonRepost: {
+        type: "object",
+        required: ["repost"],
+        properties: {
+          repost: {
+            type: "string",
+            format: "at-uri"
+          }
+        }
+      }
+    }
+  },
+  AppBskyFeedDescribeFeedGenerator: {
+    lexicon: 1,
+    id: "app.bsky.feed.describeFeedGenerator",
+    defs: {
+      main: {
+        type: "query",
+        description: "Returns information about a given feed generator including TOS & offered feed URIs",
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did", "feeds"],
+            properties: {
+              did: {
+                type: "string",
+                format: "did"
+              },
+              feeds: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.describeFeedGenerator#feed"
+                }
+              },
+              links: {
+                type: "ref",
+                ref: "lex:app.bsky.feed.describeFeedGenerator#links"
+              }
+            }
+          }
+        }
+      },
+      feed: {
+        type: "object",
+        required: ["uri"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          }
+        }
+      },
+      links: {
+        type: "object",
+        properties: {
+          privacyPolicy: {
+            type: "string"
+          },
+          termsOfService: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
+  AppBskyFeedGenerator: {
+    lexicon: 1,
+    id: "app.bsky.feed.generator",
+    defs: {
+      main: {
+        type: "record",
+        description: "A declaration of the existence of a feed generator",
+        key: "any",
+        record: {
+          type: "object",
+          required: ["did", "displayName", "createdAt"],
+          properties: {
+            did: {
+              type: "string",
+              format: "did"
+            },
+            displayName: {
+              type: "string",
+              maxGraphemes: 24,
+              maxLength: 240
+            },
+            description: {
+              type: "string",
+              maxGraphemes: 300,
+              maxLength: 3e3
+            },
+            descriptionFacets: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "lex:app.bsky.richtext.facet"
+              }
+            },
+            avatar: {
+              type: "blob",
+              accept: ["image/png", "image/jpeg"],
+              maxSize: 1e6
+            },
+            createdAt: {
+              type: "string",
+              format: "datetime"
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyFeedGetActorFeeds: {
+    lexicon: 1,
+    id: "app.bsky.feed.getActorFeeds",
+    defs: {
+      main: {
+        type: "query",
+        description: "Retrieve a list of feeds created by a given actor",
+        parameters: {
+          type: "params",
+          required: ["actor"],
+          properties: {
+            actor: {
+              type: "string",
+              format: "at-identifier"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feeds"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              feeds: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#generatorView"
+                }
+              }
+            }
+          }
+        }
       }
     }
   },
@@ -20949,6 +21302,190 @@ var schemaDict = {
       }
     }
   },
+  AppBskyFeedGetFeed: {
+    lexicon: 1,
+    id: "app.bsky.feed.getFeed",
+    defs: {
+      main: {
+        type: "query",
+        description: "Compose and hydrate a feed from a user's selected feed generator",
+        parameters: {
+          type: "params",
+          required: ["feed"],
+          properties: {
+            feed: {
+              type: "string",
+              format: "at-uri"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feed"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              feed: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#feedViewPost"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "UnknownFeed"
+          }
+        ]
+      }
+    }
+  },
+  AppBskyFeedGetFeedGenerator: {
+    lexicon: 1,
+    id: "app.bsky.feed.getFeedGenerator",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get information about a specific feed offered by a feed generator, such as its online status",
+        parameters: {
+          type: "params",
+          required: ["feed"],
+          properties: {
+            feed: {
+              type: "string",
+              format: "at-uri"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["view", "isOnline", "isValid"],
+            properties: {
+              view: {
+                type: "ref",
+                ref: "lex:app.bsky.feed.defs#generatorView"
+              },
+              isOnline: {
+                type: "boolean"
+              },
+              isValid: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyFeedGetFeedGenerators: {
+    lexicon: 1,
+    id: "app.bsky.feed.getFeedGenerators",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get information about a list of feed generators",
+        parameters: {
+          type: "params",
+          required: ["feeds"],
+          properties: {
+            feeds: {
+              type: "array",
+              items: {
+                type: "string",
+                format: "at-uri"
+              }
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feeds"],
+            properties: {
+              feeds: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#generatorView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyFeedGetFeedSkeleton: {
+    lexicon: 1,
+    id: "app.bsky.feed.getFeedSkeleton",
+    defs: {
+      main: {
+        type: "query",
+        description: "A skeleton of a feed provided by a feed generator",
+        parameters: {
+          type: "params",
+          required: ["feed"],
+          properties: {
+            feed: {
+              type: "string",
+              format: "at-uri"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feed"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              feed: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#skeletonFeedPost"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "UnknownFeed"
+          }
+        ]
+      }
+    }
+  },
   AppBskyFeedGetLikes: {
     lexicon: 1,
     id: "app.bsky.feed.getLikes",
@@ -21394,7 +21931,7 @@ var schemaDict = {
     defs: {
       listViewBasic: {
         type: "object",
-        required: ["uri", "creator", "name", "purpose"],
+        required: ["uri", "name", "purpose"],
         properties: {
           uri: {
             type: "string",
@@ -22289,6 +22826,32 @@ var schemaDict = {
         }
       }
     }
+  },
+  AppBskyUnspeccedGetPopularFeedGenerators: {
+    lexicon: 1,
+    id: "app.bsky.unspecced.getPopularFeedGenerators",
+    defs: {
+      main: {
+        type: "query",
+        description: "An unspecced view of globally popular feed generators",
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feeds"],
+            properties: {
+              feeds: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#generatorView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
   }
 };
 var schemas = Object.values(schemaDict);
@@ -23245,51 +23808,149 @@ function toKnownErr61(e) {
   return e;
 }
 
-// src/client/types/app/bsky/actor/searchActors.ts
-var searchActors_exports = {};
-__export(searchActors_exports, {
-  toKnownErr: () => toKnownErr62
+// src/client/types/app/bsky/actor/searchActors.ts
+var searchActors_exports = {};
+__export(searchActors_exports, {
+  toKnownErr: () => toKnownErr62
+});
+function toKnownErr62(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/actor/searchActorsTypeahead.ts
+var searchActorsTypeahead_exports = {};
+__export(searchActorsTypeahead_exports, {
+  toKnownErr: () => toKnownErr63
+});
+function toKnownErr63(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/feed/describeFeedGenerator.ts
+var describeFeedGenerator_exports = {};
+__export(describeFeedGenerator_exports, {
+  isFeed: () => isFeed,
+  isLinks: () => isLinks2,
+  toKnownErr: () => toKnownErr64,
+  validateFeed: () => validateFeed,
+  validateLinks: () => validateLinks2
+});
+function toKnownErr64(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+function isFeed(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.describeFeedGenerator#feed";
+}
+function validateFeed(v) {
+  return lexicons.validate("app.bsky.feed.describeFeedGenerator#feed", v);
+}
+function isLinks2(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.describeFeedGenerator#links";
+}
+function validateLinks2(v) {
+  return lexicons.validate("app.bsky.feed.describeFeedGenerator#links", v);
+}
+
+// src/client/types/app/bsky/feed/getActorFeeds.ts
+var getActorFeeds_exports = {};
+__export(getActorFeeds_exports, {
+  toKnownErr: () => toKnownErr65
+});
+function toKnownErr65(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/feed/getAuthorFeed.ts
+var getAuthorFeed_exports = {};
+__export(getAuthorFeed_exports, {
+  BlockedActorError: () => BlockedActorError,
+  BlockedByActorError: () => BlockedByActorError,
+  toKnownErr: () => toKnownErr66
+});
+var BlockedActorError = class extends XRPCError {
+  constructor(src2) {
+    super(src2.status, src2.error, src2.message);
+  }
+};
+var BlockedByActorError = class extends XRPCError {
+  constructor(src2) {
+    super(src2.status, src2.error, src2.message);
+  }
+};
+function toKnownErr66(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "BlockedActor")
+      return new BlockedActorError(e);
+    if (e.error === "BlockedByActor")
+      return new BlockedByActorError(e);
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/feed/getFeed.ts
+var getFeed_exports = {};
+__export(getFeed_exports, {
+  UnknownFeedError: () => UnknownFeedError,
+  toKnownErr: () => toKnownErr67
+});
+var UnknownFeedError = class extends XRPCError {
+  constructor(src2) {
+    super(src2.status, src2.error, src2.message);
+  }
+};
+function toKnownErr67(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "UnknownFeed")
+      return new UnknownFeedError(e);
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/feed/getFeedGenerator.ts
+var getFeedGenerator_exports = {};
+__export(getFeedGenerator_exports, {
+  toKnownErr: () => toKnownErr68
 });
-function toKnownErr62(e) {
+function toKnownErr68(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// src/client/types/app/bsky/actor/searchActorsTypeahead.ts
-var searchActorsTypeahead_exports = {};
-__export(searchActorsTypeahead_exports, {
-  toKnownErr: () => toKnownErr63
+// src/client/types/app/bsky/feed/getFeedGenerators.ts
+var getFeedGenerators_exports = {};
+__export(getFeedGenerators_exports, {
+  toKnownErr: () => toKnownErr69
 });
-function toKnownErr63(e) {
+function toKnownErr69(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// src/client/types/app/bsky/feed/getAuthorFeed.ts
-var getAuthorFeed_exports = {};
-__export(getAuthorFeed_exports, {
-  BlockedActorError: () => BlockedActorError,
-  BlockedByActorError: () => BlockedByActorError,
-  toKnownErr: () => toKnownErr64
+// src/client/types/app/bsky/feed/getFeedSkeleton.ts
+var getFeedSkeleton_exports = {};
+__export(getFeedSkeleton_exports, {
+  UnknownFeedError: () => UnknownFeedError2,
+  toKnownErr: () => toKnownErr70
 });
-var BlockedActorError = class extends XRPCError {
-  constructor(src2) {
-    super(src2.status, src2.error, src2.message);
-  }
-};
-var BlockedByActorError = class extends XRPCError {
+var UnknownFeedError2 = class extends XRPCError {
   constructor(src2) {
     super(src2.status, src2.error, src2.message);
   }
 };
-function toKnownErr64(e) {
+function toKnownErr70(e) {
   if (e instanceof XRPCError) {
-    if (e.error === "BlockedActor")
-      return new BlockedActorError(e);
-    if (e.error === "BlockedByActor")
-      return new BlockedByActorError(e);
+    if (e.error === "UnknownFeed")
+      return new UnknownFeedError2(e);
   }
   return e;
 }
@@ -23298,10 +23959,10 @@ function toKnownErr64(e) {
 var getLikes_exports = {};
 __export(getLikes_exports, {
   isLike: () => isLike,
-  toKnownErr: () => toKnownErr65,
+  toKnownErr: () => toKnownErr71,
   validateLike: () => validateLike
 });
-function toKnownErr65(e) {
+function toKnownErr71(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23317,14 +23978,14 @@ function validateLike(v) {
 var getPostThread_exports = {};
 __export(getPostThread_exports, {
   NotFoundError: () => NotFoundError,
-  toKnownErr: () => toKnownErr66
+  toKnownErr: () => toKnownErr72
 });
 var NotFoundError = class extends XRPCError {
   constructor(src2) {
     super(src2.status, src2.error, src2.message);
   }
 };
-function toKnownErr66(e) {
+function toKnownErr72(e) {
   if (e instanceof XRPCError) {
     if (e.error === "NotFound")
       return new NotFoundError(e);
@@ -23335,9 +23996,9 @@ function toKnownErr66(e) {
 // src/client/types/app/bsky/feed/getPosts.ts
 var getPosts_exports = {};
 __export(getPosts_exports, {
-  toKnownErr: () => toKnownErr67
+  toKnownErr: () => toKnownErr73
 });
-function toKnownErr67(e) {
+function toKnownErr73(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23346,9 +24007,9 @@ function toKnownErr67(e) {
 // src/client/types/app/bsky/feed/getRepostedBy.ts
 var getRepostedBy_exports = {};
 __export(getRepostedBy_exports, {
-  toKnownErr: () => toKnownErr68
+  toKnownErr: () => toKnownErr74
 });
-function toKnownErr68(e) {
+function toKnownErr74(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23357,9 +24018,9 @@ function toKnownErr68(e) {
 // src/client/types/app/bsky/feed/getTimeline.ts
 var getTimeline_exports = {};
 __export(getTimeline_exports, {
-  toKnownErr: () => toKnownErr69
+  toKnownErr: () => toKnownErr75
 });
-function toKnownErr69(e) {
+function toKnownErr75(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23368,9 +24029,9 @@ function toKnownErr69(e) {
 // src/client/types/app/bsky/graph/getBlocks.ts
 var getBlocks_exports2 = {};
 __export(getBlocks_exports2, {
-  toKnownErr: () => toKnownErr70
+  toKnownErr: () => toKnownErr76
 });
-function toKnownErr70(e) {
+function toKnownErr76(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23379,9 +24040,9 @@ function toKnownErr70(e) {
 // src/client/types/app/bsky/graph/getFollowers.ts
 var getFollowers_exports = {};
 __export(getFollowers_exports, {
-  toKnownErr: () => toKnownErr71
+  toKnownErr: () => toKnownErr77
 });
-function toKnownErr71(e) {
+function toKnownErr77(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23390,9 +24051,9 @@ function toKnownErr71(e) {
 // src/client/types/app/bsky/graph/getFollows.ts
 var getFollows_exports = {};
 __export(getFollows_exports, {
-  toKnownErr: () => toKnownErr72
+  toKnownErr: () => toKnownErr78
 });
-function toKnownErr72(e) {
+function toKnownErr78(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23401,9 +24062,9 @@ function toKnownErr72(e) {
 // src/client/types/app/bsky/graph/getList.ts
 var getList_exports = {};
 __export(getList_exports, {
-  toKnownErr: () => toKnownErr73
+  toKnownErr: () => toKnownErr79
 });
-function toKnownErr73(e) {
+function toKnownErr79(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23412,9 +24073,9 @@ function toKnownErr73(e) {
 // src/client/types/app/bsky/graph/getListMutes.ts
 var getListMutes_exports = {};
 __export(getListMutes_exports, {
-  toKnownErr: () => toKnownErr74
+  toKnownErr: () => toKnownErr80
 });
-function toKnownErr74(e) {
+function toKnownErr80(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23423,9 +24084,9 @@ function toKnownErr74(e) {
 // src/client/types/app/bsky/graph/getLists.ts
 var getLists_exports = {};
 __export(getLists_exports, {
-  toKnownErr: () => toKnownErr75
+  toKnownErr: () => toKnownErr81
 });
-function toKnownErr75(e) {
+function toKnownErr81(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23434,9 +24095,9 @@ function toKnownErr75(e) {
 // src/client/types/app/bsky/graph/getMutes.ts
 var getMutes_exports = {};
 __export(getMutes_exports, {
-  toKnownErr: () => toKnownErr76
+  toKnownErr: () => toKnownErr82
 });
-function toKnownErr76(e) {
+function toKnownErr82(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23445,9 +24106,9 @@ function toKnownErr76(e) {
 // src/client/types/app/bsky/graph/muteActor.ts
 var muteActor_exports = {};
 __export(muteActor_exports, {
-  toKnownErr: () => toKnownErr77
+  toKnownErr: () => toKnownErr83
 });
-function toKnownErr77(e) {
+function toKnownErr83(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23456,9 +24117,9 @@ function toKnownErr77(e) {
 // src/client/types/app/bsky/graph/muteActorList.ts
 var muteActorList_exports = {};
 __export(muteActorList_exports, {
-  toKnownErr: () => toKnownErr78
+  toKnownErr: () => toKnownErr84
 });
-function toKnownErr78(e) {
+function toKnownErr84(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23467,9 +24128,9 @@ function toKnownErr78(e) {
 // src/client/types/app/bsky/graph/unmuteActor.ts
 var unmuteActor_exports = {};
 __export(unmuteActor_exports, {
-  toKnownErr: () => toKnownErr79
+  toKnownErr: () => toKnownErr85
 });
-function toKnownErr79(e) {
+function toKnownErr85(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23478,9 +24139,9 @@ function toKnownErr79(e) {
 // src/client/types/app/bsky/graph/unmuteActorList.ts
 var unmuteActorList_exports = {};
 __export(unmuteActorList_exports, {
-  toKnownErr: () => toKnownErr80
+  toKnownErr: () => toKnownErr86
 });
-function toKnownErr80(e) {
+function toKnownErr86(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23489,9 +24150,9 @@ function toKnownErr80(e) {
 // src/client/types/app/bsky/notification/getUnreadCount.ts
 var getUnreadCount_exports = {};
 __export(getUnreadCount_exports, {
-  toKnownErr: () => toKnownErr81
+  toKnownErr: () => toKnownErr87
 });
-function toKnownErr81(e) {
+function toKnownErr87(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23501,10 +24162,10 @@ function toKnownErr81(e) {
 var listNotifications_exports = {};
 __export(listNotifications_exports, {
   isNotification: () => isNotification,
-  toKnownErr: () => toKnownErr82,
+  toKnownErr: () => toKnownErr88,
   validateNotification: () => validateNotification
 });
-function toKnownErr82(e) {
+function toKnownErr88(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23522,9 +24183,9 @@ function validateNotification(v) {
 // src/client/types/app/bsky/notification/updateSeen.ts
 var updateSeen_exports = {};
 __export(updateSeen_exports, {
-  toKnownErr: () => toKnownErr83
+  toKnownErr: () => toKnownErr89
 });
-function toKnownErr83(e) {
+function toKnownErr89(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23533,9 +24194,20 @@ function toKnownErr83(e) {
 // src/client/types/app/bsky/unspecced/getPopular.ts
 var getPopular_exports = {};
 __export(getPopular_exports, {
-  toKnownErr: () => toKnownErr84
+  toKnownErr: () => toKnownErr90
 });
-function toKnownErr84(e) {
+function toKnownErr90(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/unspecced/getPopularFeedGenerators.ts
+var getPopularFeedGenerators_exports = {};
+__export(getPopularFeedGenerators_exports, {
+  toKnownErr: () => toKnownErr91
+});
+function toKnownErr91(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -23844,12 +24516,14 @@ __export(defs_exports5, {
   isProfileView: () => isProfileView,
   isProfileViewBasic: () => isProfileViewBasic,
   isProfileViewDetailed: () => isProfileViewDetailed,
+  isSavedFeedsPref: () => isSavedFeedsPref,
   isViewerState: () => isViewerState,
   validateAdultContentPref: () => validateAdultContentPref,
   validateContentLabelPref: () => validateContentLabelPref,
   validateProfileView: () => validateProfileView,
   validateProfileViewBasic: () => validateProfileViewBasic,
   validateProfileViewDetailed: () => validateProfileViewDetailed,
+  validateSavedFeedsPref: () => validateSavedFeedsPref,
   validateViewerState: () => validateViewerState
 });
 function isProfileViewBasic(v) {
@@ -23888,6 +24562,12 @@ function isContentLabelPref(v) {
 function validateContentLabelPref(v) {
   return lexicons.validate("app.bsky.actor.defs#contentLabelPref", v);
 }
+function isSavedFeedsPref(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.actor.defs#savedFeedsPref";
+}
+function validateSavedFeedsPref(v) {
+  return lexicons.validate("app.bsky.actor.defs#savedFeedsPref", v);
+}
 
 // src/client/types/app/bsky/actor/profile.ts
 var profile_exports = {};
@@ -24047,18 +24727,26 @@ var defs_exports6 = {};
 __export(defs_exports6, {
   isBlockedPost: () => isBlockedPost,
   isFeedViewPost: () => isFeedViewPost,
+  isGeneratorView: () => isGeneratorView,
+  isGeneratorViewerState: () => isGeneratorViewerState,
   isNotFoundPost: () => isNotFoundPost,
   isPostView: () => isPostView,
   isReasonRepost: () => isReasonRepost,
   isReplyRef: () => isReplyRef,
+  isSkeletonFeedPost: () => isSkeletonFeedPost,
+  isSkeletonReasonRepost: () => isSkeletonReasonRepost,
   isThreadViewPost: () => isThreadViewPost,
   isViewerState: () => isViewerState2,
   validateBlockedPost: () => validateBlockedPost,
   validateFeedViewPost: () => validateFeedViewPost,
+  validateGeneratorView: () => validateGeneratorView,
+  validateGeneratorViewerState: () => validateGeneratorViewerState,
   validateNotFoundPost: () => validateNotFoundPost,
   validatePostView: () => validatePostView,
   validateReasonRepost: () => validateReasonRepost,
   validateReplyRef: () => validateReplyRef,
+  validateSkeletonFeedPost: () => validateSkeletonFeedPost,
+  validateSkeletonReasonRepost: () => validateSkeletonReasonRepost,
   validateThreadViewPost: () => validateThreadViewPost,
   validateViewerState: () => validateViewerState2
 });
@@ -24110,17 +24798,54 @@ function isBlockedPost(v) {
 function validateBlockedPost(v) {
   return lexicons.validate("app.bsky.feed.defs#blockedPost", v);
 }
+function isGeneratorView(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.defs#generatorView";
+}
+function validateGeneratorView(v) {
+  return lexicons.validate("app.bsky.feed.defs#generatorView", v);
+}
+function isGeneratorViewerState(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.defs#generatorViewerState";
+}
+function validateGeneratorViewerState(v) {
+  return lexicons.validate("app.bsky.feed.defs#generatorViewerState", v);
+}
+function isSkeletonFeedPost(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.defs#skeletonFeedPost";
+}
+function validateSkeletonFeedPost(v) {
+  return lexicons.validate("app.bsky.feed.defs#skeletonFeedPost", v);
+}
+function isSkeletonReasonRepost(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.feed.defs#skeletonReasonRepost";
+}
+function validateSkeletonReasonRepost(v) {
+  return lexicons.validate("app.bsky.feed.defs#skeletonReasonRepost", v);
+}
 
-// src/client/types/app/bsky/feed/like.ts
-var like_exports = {};
-__export(like_exports, {
+// src/client/types/app/bsky/feed/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
   isRecord: () => isRecord3,
   validateRecord: () => validateRecord3
 });
 function isRecord3(v) {
-  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.like#main" || v.$type === "app.bsky.feed.like");
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.generator#main" || v.$type === "app.bsky.feed.generator");
 }
 function validateRecord3(v) {
+  return lexicons.validate("app.bsky.feed.generator#main", v);
+}
+
+// src/client/types/app/bsky/feed/like.ts
+var like_exports = {};
+__export(like_exports, {
+  isRecord: () => isRecord4,
+  validateRecord: () => validateRecord4
+});
+function isRecord4(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.like#main" || v.$type === "app.bsky.feed.like");
+}
+function validateRecord4(v) {
   return lexicons.validate("app.bsky.feed.like#main", v);
 }
 
@@ -24128,18 +24853,18 @@ function validateRecord3(v) {
 var post_exports = {};
 __export(post_exports, {
   isEntity: () => isEntity,
-  isRecord: () => isRecord4,
+  isRecord: () => isRecord5,
   isReplyRef: () => isReplyRef2,
   isTextSlice: () => isTextSlice,
   validateEntity: () => validateEntity,
-  validateRecord: () => validateRecord4,
+  validateRecord: () => validateRecord5,
   validateReplyRef: () => validateReplyRef2,
   validateTextSlice: () => validateTextSlice
 });
-function isRecord4(v) {
+function isRecord5(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.post#main" || v.$type === "app.bsky.feed.post");
 }
-function validateRecord4(v) {
+function validateRecord5(v) {
   return lexicons.validate("app.bsky.feed.post#main", v);
 }
 function isReplyRef2(v) {
@@ -24164,26 +24889,26 @@ function validateTextSlice(v) {
 // src/client/types/app/bsky/feed/repost.ts
 var repost_exports = {};
 __export(repost_exports, {
-  isRecord: () => isRecord5,
-  validateRecord: () => validateRecord5
+  isRecord: () => isRecord6,
+  validateRecord: () => validateRecord6
 });
-function isRecord5(v) {
+function isRecord6(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.feed.repost#main" || v.$type === "app.bsky.feed.repost");
 }
-function validateRecord5(v) {
+function validateRecord6(v) {
   return lexicons.validate("app.bsky.feed.repost#main", v);
 }
 
 // src/client/types/app/bsky/graph/block.ts
 var block_exports = {};
 __export(block_exports, {
-  isRecord: () => isRecord6,
-  validateRecord: () => validateRecord6
+  isRecord: () => isRecord7,
+  validateRecord: () => validateRecord7
 });
-function isRecord6(v) {
+function isRecord7(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.block#main" || v.$type === "app.bsky.graph.block");
 }
-function validateRecord6(v) {
+function validateRecord7(v) {
   return lexicons.validate("app.bsky.graph.block#main", v);
 }
 
@@ -24229,39 +24954,39 @@ function validateListViewerState(v) {
 // src/client/types/app/bsky/graph/follow.ts
 var follow_exports = {};
 __export(follow_exports, {
-  isRecord: () => isRecord7,
-  validateRecord: () => validateRecord7
+  isRecord: () => isRecord8,
+  validateRecord: () => validateRecord8
 });
-function isRecord7(v) {
+function isRecord8(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.follow#main" || v.$type === "app.bsky.graph.follow");
 }
-function validateRecord7(v) {
+function validateRecord8(v) {
   return lexicons.validate("app.bsky.graph.follow#main", v);
 }
 
 // src/client/types/app/bsky/graph/list.ts
 var list_exports = {};
 __export(list_exports, {
-  isRecord: () => isRecord8,
-  validateRecord: () => validateRecord8
+  isRecord: () => isRecord9,
+  validateRecord: () => validateRecord9
 });
-function isRecord8(v) {
+function isRecord9(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.list#main" || v.$type === "app.bsky.graph.list");
 }
-function validateRecord8(v) {
+function validateRecord9(v) {
   return lexicons.validate("app.bsky.graph.list#main", v);
 }
 
 // src/client/types/app/bsky/graph/listitem.ts
 var listitem_exports = {};
 __export(listitem_exports, {
-  isRecord: () => isRecord9,
-  validateRecord: () => validateRecord9
+  isRecord: () => isRecord10,
+  validateRecord: () => validateRecord10
 });
-function isRecord9(v) {
+function isRecord10(v) {
   return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.listitem#main" || v.$type === "app.bsky.graph.listitem");
 }
-function validateRecord9(v) {
+function validateRecord10(v) {
   return lexicons.validate("app.bsky.graph.listitem#main", v);
 }
 
@@ -24777,39 +25502,107 @@ var EmbedNS = class {
 var FeedNS = class {
   constructor(service) {
     this._service = service;
+    this.generator = new GeneratorRecord(service);
     this.like = new LikeRecord(service);
     this.post = new PostRecord(service);
     this.repost = new RepostRecord(service);
   }
+  describeFeedGenerator(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.describeFeedGenerator", params2, void 0, opts).catch((e) => {
+      throw toKnownErr64(e);
+    });
+  }
+  getActorFeeds(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.getActorFeeds", params2, void 0, opts).catch((e) => {
+      throw toKnownErr65(e);
+    });
+  }
   getAuthorFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getAuthorFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr64(e);
+      throw toKnownErr66(e);
+    });
+  }
+  getFeed(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.getFeed", params2, void 0, opts).catch((e) => {
+      throw toKnownErr67(e);
+    });
+  }
+  getFeedGenerator(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.getFeedGenerator", params2, void 0, opts).catch((e) => {
+      throw toKnownErr68(e);
+    });
+  }
+  getFeedGenerators(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.getFeedGenerators", params2, void 0, opts).catch((e) => {
+      throw toKnownErr69(e);
+    });
+  }
+  getFeedSkeleton(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.getFeedSkeleton", params2, void 0, opts).catch((e) => {
+      throw toKnownErr70(e);
     });
   }
   getLikes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getLikes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr65(e);
+      throw toKnownErr71(e);
     });
   }
   getPostThread(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPostThread", params2, void 0, opts).catch((e) => {
-      throw toKnownErr66(e);
+      throw toKnownErr72(e);
     });
   }
   getPosts(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPosts", params2, void 0, opts).catch((e) => {
-      throw toKnownErr67(e);
+      throw toKnownErr73(e);
     });
   }
   getRepostedBy(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getRepostedBy", params2, void 0, opts).catch((e) => {
-      throw toKnownErr68(e);
+      throw toKnownErr74(e);
     });
   }
   getTimeline(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getTimeline", params2, void 0, opts).catch((e) => {
-      throw toKnownErr69(e);
+      throw toKnownErr75(e);
+    });
+  }
+};
+var GeneratorRecord = class {
+  constructor(service) {
+    this._service = service;
+  }
+  async list(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.listRecords", {
+      collection: "app.bsky.feed.generator",
+      ...params2
+    });
+    return res.data;
+  }
+  async get(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.getRecord", {
+      collection: "app.bsky.feed.generator",
+      ...params2
     });
+    return res.data;
+  }
+  async create(params2, record, headers) {
+    record.$type = "app.bsky.feed.generator";
+    const res = await this._service.xrpc.call(
+      "com.atproto.repo.createRecord",
+      void 0,
+      { collection: "app.bsky.feed.generator", ...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.generator", ...params2 },
+      { headers }
+    );
   }
 };
 var LikeRecord = class {
@@ -24933,57 +25726,57 @@ var GraphNS = class {
   }
   getBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr70(e);
+      throw toKnownErr76(e);
     });
   }
   getFollowers(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollowers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr71(e);
+      throw toKnownErr77(e);
     });
   }
   getFollows(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollows", params2, void 0, opts).catch((e) => {
-      throw toKnownErr72(e);
+      throw toKnownErr78(e);
     });
   }
   getList(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getList", params2, void 0, opts).catch((e) => {
-      throw toKnownErr73(e);
+      throw toKnownErr79(e);
     });
   }
   getListMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr74(e);
+      throw toKnownErr80(e);
     });
   }
   getLists(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getLists", params2, void 0, opts).catch((e) => {
-      throw toKnownErr75(e);
+      throw toKnownErr81(e);
     });
   }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr76(e);
+      throw toKnownErr82(e);
     });
   }
   muteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr77(e);
+      throw toKnownErr83(e);
     });
   }
   muteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr78(e);
+      throw toKnownErr84(e);
     });
   }
   unmuteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr79(e);
+      throw toKnownErr85(e);
     });
   }
   unmuteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr80(e);
+      throw toKnownErr86(e);
     });
   }
 };
@@ -25141,17 +25934,17 @@ var NotificationNS = class {
   }
   getUnreadCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getUnreadCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr81(e);
+      throw toKnownErr87(e);
     });
   }
   listNotifications(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.listNotifications", params2, void 0, opts).catch((e) => {
-      throw toKnownErr82(e);
+      throw toKnownErr88(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr83(e);
+      throw toKnownErr89(e);
     });
   }
 };
@@ -25166,7 +25959,17 @@ var UnspeccedNS = class {
   }
   getPopular(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopular", params2, void 0, opts).catch((e) => {
-      throw toKnownErr84(e);
+      throw toKnownErr90(e);
+    });
+  }
+  getPopularFeedGenerators(params2, opts) {
+    return this._service.xrpc.call(
+      "app.bsky.unspecced.getPopularFeedGenerators",
+      params2,
+      void 0,
+      opts
+    ).catch((e) => {
+      throw toKnownErr91(e);
     });
   }
 };