@atproto/api 0.3.7 → 0.3.8

package/dist/index.js

@@ -8926,6 +8926,7 @@ __export(src_exports4, {
   AppBskyNotificationUpdateSeen: () => updateSeen_exports,
   AppBskyRichtextFacet: () => facet_exports,
   AppBskyUnspeccedGetPopular: () => getPopular_exports,
+  AppBskyUnspeccedGetPopularFeedGenerators: () => getPopularFeedGenerators_exports,
   AppNS: () => AppNS,
   AtUri: () => AtUri,
   AtpAgent: () => AtpAgent,
@@ -15214,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) {
@@ -16016,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) {
@@ -16435,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") {
@@ -16450,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;
@@ -16592,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);
@@ -18211,7 +18292,7 @@ var schemaDict = {
       create: {
         type: "object",
         description: "Create a new record.",
-        required: ["action", "collection", "value"],
+        required: ["collection", "value"],
         properties: {
           collection: {
             type: "string",
@@ -18229,7 +18310,7 @@ var schemaDict = {
       update: {
         type: "object",
         description: "Update an existing record.",
-        required: ["action", "collection", "rkey", "value"],
+        required: ["collection", "rkey", "value"],
         properties: {
           collection: {
             type: "string",
@@ -18246,7 +18327,7 @@ var schemaDict = {
       delete: {
         type: "object",
         description: "Delete an existing record.",
-        required: ["action", "collection", "rkey"],
+        required: ["collection", "rkey"],
         properties: {
           collection: {
             type: "string",
@@ -21009,7 +21090,7 @@ var schemaDict = {
         properties: {
           repost: {
             type: "string",
-            ref: "at-uri"
+            format: "at-uri"
           }
         }
       }
@@ -21850,7 +21931,7 @@ var schemaDict = {
     defs: {
       listViewBasic: {
         type: "object",
-        required: ["uri", "creator", "name", "purpose"],
+        required: ["uri", "name", "purpose"],
         properties: {
           uri: {
             type: "string",
@@ -22745,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);
@@ -24095,6 +24202,17 @@ function toKnownErr90(e) {
   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;
+}
+
 // src/client/types/com/atproto/admin/defs.ts
 var defs_exports = {};
 __export(defs_exports, {
@@ -25844,6 +25962,16 @@ var UnspeccedNS = class {
       throw toKnownErr90(e);
     });
   }
+  getPopularFeedGenerators(params2, opts) {
+    return this._service.xrpc.call(
+      "app.bsky.unspecced.getPopularFeedGenerators",
+      params2,
+      void 0,
+      opts
+    ).catch((e) => {
+      throw toKnownErr91(e);
+    });
+  }
 };
 
 // src/agent.ts