@atiproto/lexicons 0.3.0 → 0.5.0

package/dist/index.js

@@ -41,15 +41,17 @@ __export(atiproto_exports, {
   feed: () => feed_exports,
   profile: () => profile_exports2,
   repo: () => repo_exports,
-  subscription: () => subscription_exports3,
-  tip: () => tip_exports3
+  subscription: () => subscription_exports4,
+  tip: () => tip_exports4
 });
 
 // src/lexicons/com/atiproto/account.ts
 var account_exports = {};
 __export(account_exports, {
   cart: () => cart_exports,
-  profile: () => profile_exports
+  profile: () => profile_exports,
+  subscription: () => subscription_exports,
+  tip: () => tip_exports
 });
 
 // src/lexicons/com/atiproto/account/cart.ts
@@ -103,7 +105,8 @@ __export(cart_defs_exports, {
   $type: () => $type,
   $validate: () => $validate,
   cartItem: () => cartItem,
-  main: () => main
+  main: () => main,
+  view: () => view
 });
 var import_lex = require("@atproto/lex");
 var $nsid = "com.atiproto.cart";
@@ -132,6 +135,19 @@ var $parse = /* @__PURE__ */ main.parse.bind(main);
 var $safeParse = /* @__PURE__ */ main.safeParse.bind(main);
 var $validate = /* @__PURE__ */ main.validate.bind(main);
 var $safeValidate = /* @__PURE__ */ main.safeValidate.bind(main);
+var view = import_lex.l.typedObject(
+  $nsid,
+  "view",
+  import_lex.l.object({
+    items: import_lex.l.array(import_lex.l.ref((() => cartItem))),
+    currency: import_lex.l.string({ maxLength: 3 }),
+    total: import_lex.l.integer(),
+    status: import_lex.l.enum(["open", "completed", "expired", "abandoned"]),
+    createdAt: import_lex.l.string({ format: "datetime" }),
+    expiresAt: import_lex.l.string({ format: "datetime" }),
+    completedAt: import_lex.l.optional(import_lex.l.string({ format: "datetime" }))
+  })
+);
 var cartItem = import_lex.l.typedObject(
   $nsid,
   "cartItem",
@@ -157,7 +173,8 @@ __export(tip_defs_exports, {
   $safeValidate: () => $safeValidate2,
   $type: () => $type2,
   $validate: () => $validate2,
-  main: () => main2
+  main: () => main2,
+  view: () => view2
 });
 var import_lex2 = require("@atproto/lex");
 var $nsid2 = "com.atiproto.tip";
@@ -165,7 +182,7 @@ var main2 = import_lex2.l.record(
   "any",
   $nsid2,
   import_lex2.l.object({
-    subject: import_lex2.l.string({ format: "did" }),
+    subject: import_lex2.l.optional(import_lex2.l.string({ format: "did" })),
     recordUri: import_lex2.l.optional(import_lex2.l.string({ format: "at-uri" })),
     amount: import_lex2.l.integer({ minimum: 0 }),
     currency: import_lex2.l.string({ maxLength: 3 }),
@@ -193,6 +210,26 @@ var $parse2 = /* @__PURE__ */ main2.parse.bind(main2);
 var $safeParse2 = /* @__PURE__ */ main2.safeParse.bind(main2);
 var $validate2 = /* @__PURE__ */ main2.validate.bind(main2);
 var $safeValidate2 = /* @__PURE__ */ main2.safeValidate.bind(main2);
+var view2 = import_lex2.l.typedObject(
+  $nsid2,
+  "view",
+  import_lex2.l.object({
+    subject: import_lex2.l.optional(import_lex2.l.string({ format: "did" })),
+    recordUri: import_lex2.l.optional(import_lex2.l.string({ format: "at-uri" })),
+    amount: import_lex2.l.integer({ minimum: 0 }),
+    currency: import_lex2.l.string({ maxLength: 3 }),
+    status: import_lex2.l.enum([
+      "pending",
+      "authorized",
+      "completed",
+      "failed",
+      "refunded"
+    ]),
+    message: import_lex2.l.optional(import_lex2.l.string({ maxGraphemes: 500, maxLength: 5e3 })),
+    createdAt: import_lex2.l.string({ format: "datetime" }),
+    completedAt: import_lex2.l.optional(import_lex2.l.string({ format: "datetime" }))
+  })
+);
 
 // src/lexicons/com/atiproto/subscription.defs.ts
 var subscription_defs_exports = {};
@@ -210,7 +247,8 @@ __export(subscription_defs_exports, {
   $safeValidate: () => $safeValidate3,
   $type: () => $type3,
   $validate: () => $validate3,
-  main: () => main3
+  main: () => main3,
+  view: () => view3
 });
 var import_lex3 = require("@atproto/lex");
 var $nsid3 = "com.atiproto.subscription";
@@ -241,6 +279,21 @@ var $parse3 = /* @__PURE__ */ main3.parse.bind(main3);
 var $safeParse3 = /* @__PURE__ */ main3.safeParse.bind(main3);
 var $validate3 = /* @__PURE__ */ main3.validate.bind(main3);
 var $safeValidate3 = /* @__PURE__ */ main3.safeValidate.bind(main3);
+var view3 = import_lex3.l.typedObject(
+  $nsid3,
+  "view",
+  import_lex3.l.object({
+    subject: import_lex3.l.optional(import_lex3.l.string({ format: "did" })),
+    amount: import_lex3.l.integer({ minimum: 0 }),
+    currency: import_lex3.l.string({ maxLength: 3 }),
+    interval: import_lex3.l.enum(["monthly", "yearly"]),
+    status: import_lex3.l.enum(["pending", "active", "past_due", "cancelled", "expired"]),
+    billingStartDate: import_lex3.l.string({ format: "datetime" }),
+    cancelledAt: import_lex3.l.optional(import_lex3.l.string({ format: "datetime" })),
+    accessUntil: import_lex3.l.optional(import_lex3.l.string({ format: "datetime" })),
+    createdAt: import_lex3.l.string({ format: "datetime" })
+  })
+);
 
 // src/lexicons/com/atiproto/account/cart/clone.defs.ts
 var $nsid4 = "com.atiproto.account.cart.clone";
@@ -252,13 +305,13 @@ var main4 = import_lex4.l.procedure(
     redirectUrl: import_lex4.l.optional(import_lex4.l.string({ format: "uri" }))
   }),
   import_lex4.l.jsonPayload({
-    cart: import_lex4.l.ref((() => main)),
+    cart: import_lex4.l.ref((() => view)),
     cartUri: import_lex4.l.string({ format: "at-uri" }),
     checkoutUrl: import_lex4.l.string({ format: "uri" }),
-    tips: import_lex4.l.array(import_lex4.l.ref((() => main2))),
+    tips: import_lex4.l.array(import_lex4.l.ref((() => view2))),
     subscriptions: import_lex4.l.array(
       import_lex4.l.ref(
-        (() => main3)
+        (() => view3)
       )
     )
   })
@@ -300,7 +353,7 @@ var main5 = import_lex5.l.procedure(
     redirectUrl: import_lex5.l.optional(import_lex5.l.string({ format: "uri" }))
   }),
   import_lex5.l.jsonPayload({
-    cart: import_lex5.l.ref((() => main)),
+    cart: import_lex5.l.ref((() => view)),
     cartUri: import_lex5.l.string({ format: "at-uri" }),
     checkoutUrl: import_lex5.l.string({ format: "uri" })
   })
@@ -338,12 +391,12 @@ var main6 = import_lex6.l.query(
   import_lex6.l.jsonPayload({
     uri: import_lex6.l.string({ format: "at-uri" }),
     cid: import_lex6.l.optional(import_lex6.l.string({ format: "cid" })),
-    cart: import_lex6.l.ref((() => main)),
+    cart: import_lex6.l.ref((() => view)),
     checkoutUrl: import_lex6.l.optional(import_lex6.l.string({ format: "uri" })),
-    tips: import_lex6.l.array(import_lex6.l.ref((() => main2))),
+    tips: import_lex6.l.array(import_lex6.l.ref((() => view2))),
     subscriptions: import_lex6.l.array(
       import_lex6.l.ref(
-        (() => main3)
+        (() => view3)
       )
     )
   })
@@ -393,7 +446,7 @@ var cartResponse = import_lex7.l.typedObject(
   import_lex7.l.object({
     uri: import_lex7.l.string({ format: "at-uri" }),
     cid: import_lex7.l.string({ format: "cid" }),
-    record: import_lex7.l.ref((() => main))
+    record: import_lex7.l.ref((() => view))
   })
 );
 
@@ -483,7 +536,8 @@ __export(profile_defs_exports, {
   $safeValidate: () => $safeValidate4,
   $type: () => $type4,
   $validate: () => $validate4,
-  main: () => main9
+  main: () => main9,
+  view: () => view4
 });
 var import_lex9 = require("@atproto/lex");
 var $nsid9 = "com.atiproto.profile";
@@ -510,6 +564,17 @@ var $parse4 = /* @__PURE__ */ main9.parse.bind(main9);
 var $safeParse4 = /* @__PURE__ */ main9.safeParse.bind(main9);
 var $validate4 = /* @__PURE__ */ main9.validate.bind(main9);
 var $safeValidate4 = /* @__PURE__ */ main9.safeValidate.bind(main9);
+var view4 = import_lex9.l.typedObject(
+  $nsid9,
+  "view",
+  import_lex9.l.object({
+    acceptsTips: import_lex9.l.optional(import_lex9.l.boolean()),
+    acceptsSubscriptions: import_lex9.l.optional(import_lex9.l.boolean()),
+    disableReceiptNotifications: import_lex9.l.optional(import_lex9.l.boolean()),
+    createdAt: import_lex9.l.string({ format: "datetime" }),
+    updatedAt: import_lex9.l.optional(import_lex9.l.string({ format: "datetime" }))
+  })
+);
 
 // src/lexicons/com/atiproto/account/profile/get.defs.ts
 var $nsid10 = "com.atiproto.account.profile.get";
@@ -519,7 +584,7 @@ var main10 = import_lex10.l.query(
   import_lex10.l.jsonPayload({
     uri: import_lex10.l.optional(import_lex10.l.string({ format: "at-uri" })),
     cid: import_lex10.l.optional(import_lex10.l.string({ format: "cid" })),
-    profile: import_lex10.l.ref((() => main9)),
+    profile: import_lex10.l.ref((() => view4)),
     hasProfile: import_lex10.l.boolean(),
     readyForPayment: import_lex10.l.boolean()
   })
@@ -563,7 +628,7 @@ var main11 = import_lex11.l.procedure(
   import_lex11.l.jsonPayload({
     uri: import_lex11.l.string({ format: "at-uri" }),
     cid: import_lex11.l.string({ format: "cid" }),
-    profile: import_lex11.l.ref((() => main9)),
+    profile: import_lex11.l.ref((() => view4)),
     hasProfile: import_lex11.l.boolean(),
     readyForPayment: import_lex11.l.boolean()
   })
@@ -573,26 +638,282 @@ var $params7 = main11.parameters;
 var $input4 = main11.input;
 var $output7 = main11.output;
 
+// src/lexicons/com/atiproto/account/subscription.ts
+var subscription_exports = {};
+__export(subscription_exports, {
+  get: () => get_exports3,
+  list: () => list_exports2,
+  validate: () => validate_exports
+});
+
+// src/lexicons/com/atiproto/account/subscription/get.ts
+var get_exports3 = {};
+__export(get_exports3, {
+  $defs: () => get_defs_exports3,
+  $lxm: () => $lxm8,
+  $nsid: () => $nsid12,
+  $output: () => $output8,
+  $params: () => $params8,
+  main: () => main12
+});
+
+// src/lexicons/com/atiproto/account/subscription/get.defs.ts
+var get_defs_exports3 = {};
+__export(get_defs_exports3, {
+  $lxm: () => $lxm8,
+  $nsid: () => $nsid12,
+  $output: () => $output8,
+  $params: () => $params8,
+  main: () => main12
+});
+var import_lex12 = require("@atproto/lex");
+var $nsid12 = "com.atiproto.account.subscription.get";
+var main12 = import_lex12.l.query(
+  $nsid12,
+  import_lex12.l.params({
+    uri: import_lex12.l.optional(import_lex12.l.string({ format: "at-uri" })),
+    sender: import_lex12.l.optional(import_lex12.l.string({ format: "did" }))
+  }),
+  import_lex12.l.jsonPayload({
+    subscription: import_lex12.l.ref(
+      (() => view3)
+    )
+  })
+);
+var $lxm8 = main12.nsid;
+var $params8 = main12.parameters;
+var $output8 = main12.output;
+
+// src/lexicons/com/atiproto/account/subscription/list.ts
+var list_exports2 = {};
+__export(list_exports2, {
+  $defs: () => list_defs_exports2,
+  $lxm: () => $lxm9,
+  $nsid: () => $nsid13,
+  $output: () => $output9,
+  $params: () => $params9,
+  main: () => main13
+});
+
+// src/lexicons/com/atiproto/account/subscription/list.defs.ts
+var list_defs_exports2 = {};
+__export(list_defs_exports2, {
+  $lxm: () => $lxm9,
+  $nsid: () => $nsid13,
+  $output: () => $output9,
+  $params: () => $params9,
+  main: () => main13
+});
+var import_lex13 = require("@atproto/lex");
+var $nsid13 = "com.atiproto.account.subscription.list";
+var main13 = import_lex13.l.query(
+  $nsid13,
+  import_lex13.l.params({
+    cursor: import_lex13.l.optional(import_lex13.l.string({ maxLength: 512 })),
+    limit: import_lex13.l.optional(
+      import_lex13.l.withDefault(import_lex13.l.integer({ minimum: 1, maximum: 100 }), 50)
+    )
+  }),
+  import_lex13.l.jsonPayload({
+    subscriptions: import_lex13.l.array(
+      import_lex13.l.ref(
+        (() => view3)
+      )
+    ),
+    cursor: import_lex13.l.optional(import_lex13.l.string({ maxLength: 512 }))
+  })
+);
+var $lxm9 = main13.nsid;
+var $params9 = main13.parameters;
+var $output9 = main13.output;
+
+// src/lexicons/com/atiproto/account/subscription/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  $defs: () => validate_defs_exports,
+  $lxm: () => $lxm10,
+  $nsid: () => $nsid14,
+  $output: () => $output10,
+  $params: () => $params10,
+  main: () => main14
+});
+
+// src/lexicons/com/atiproto/account/subscription/validate.defs.ts
+var validate_defs_exports = {};
+__export(validate_defs_exports, {
+  $lxm: () => $lxm10,
+  $nsid: () => $nsid14,
+  $output: () => $output10,
+  $params: () => $params10,
+  main: () => main14
+});
+var import_lex14 = require("@atproto/lex");
+var $nsid14 = "com.atiproto.account.subscription.validate";
+var main14 = import_lex14.l.query(
+  $nsid14,
+  import_lex14.l.params({
+    subscriptionUri: import_lex14.l.optional(import_lex14.l.string({ format: "at-uri" })),
+    sender: import_lex14.l.optional(import_lex14.l.string({ format: "did" })),
+    amount: import_lex14.l.optional(import_lex14.l.integer())
+  }),
+  import_lex14.l.jsonPayload({
+    valid: import_lex14.l.boolean(),
+    amount: import_lex14.l.optional(import_lex14.l.integer()),
+    currency: import_lex14.l.optional(import_lex14.l.string({ maxLength: 3 })),
+    reason: import_lex14.l.optional(import_lex14.l.string({ maxLength: 1024 }))
+  })
+);
+var $lxm10 = main14.nsid;
+var $params10 = main14.parameters;
+var $output10 = main14.output;
+
+// src/lexicons/com/atiproto/account/tip.ts
+var tip_exports = {};
+__export(tip_exports, {
+  get: () => get_exports4,
+  list: () => list_exports3,
+  validate: () => validate_exports2
+});
+
+// src/lexicons/com/atiproto/account/tip/get.ts
+var get_exports4 = {};
+__export(get_exports4, {
+  $defs: () => get_defs_exports4,
+  $lxm: () => $lxm11,
+  $nsid: () => $nsid15,
+  $output: () => $output11,
+  $params: () => $params11,
+  main: () => main15
+});
+
+// src/lexicons/com/atiproto/account/tip/get.defs.ts
+var get_defs_exports4 = {};
+__export(get_defs_exports4, {
+  $lxm: () => $lxm11,
+  $nsid: () => $nsid15,
+  $output: () => $output11,
+  $params: () => $params11,
+  main: () => main15
+});
+var import_lex15 = require("@atproto/lex");
+var $nsid15 = "com.atiproto.account.tip.get";
+var main15 = import_lex15.l.query(
+  $nsid15,
+  import_lex15.l.params({
+    uri: import_lex15.l.optional(import_lex15.l.string({ format: "at-uri" })),
+    sender: import_lex15.l.optional(import_lex15.l.string({ format: "did" })),
+    recordUri: import_lex15.l.optional(import_lex15.l.string({ format: "at-uri" }))
+  }),
+  import_lex15.l.jsonPayload({
+    tip: import_lex15.l.ref((() => view2))
+  })
+);
+var $lxm11 = main15.nsid;
+var $params11 = main15.parameters;
+var $output11 = main15.output;
+
+// src/lexicons/com/atiproto/account/tip/list.ts
+var list_exports3 = {};
+__export(list_exports3, {
+  $defs: () => list_defs_exports3,
+  $lxm: () => $lxm12,
+  $nsid: () => $nsid16,
+  $output: () => $output12,
+  $params: () => $params12,
+  main: () => main16
+});
+
+// src/lexicons/com/atiproto/account/tip/list.defs.ts
+var list_defs_exports3 = {};
+__export(list_defs_exports3, {
+  $lxm: () => $lxm12,
+  $nsid: () => $nsid16,
+  $output: () => $output12,
+  $params: () => $params12,
+  main: () => main16
+});
+var import_lex16 = require("@atproto/lex");
+var $nsid16 = "com.atiproto.account.tip.list";
+var main16 = import_lex16.l.query(
+  $nsid16,
+  import_lex16.l.params({
+    sender: import_lex16.l.optional(import_lex16.l.string({ format: "did" })),
+    recordUri: import_lex16.l.optional(import_lex16.l.string({ format: "at-uri" })),
+    cursor: import_lex16.l.optional(import_lex16.l.string({ maxLength: 512 })),
+    limit: import_lex16.l.optional(
+      import_lex16.l.withDefault(import_lex16.l.integer({ minimum: 1, maximum: 100 }), 50)
+    )
+  }),
+  import_lex16.l.jsonPayload({
+    tips: import_lex16.l.array(import_lex16.l.ref((() => view2))),
+    cursor: import_lex16.l.optional(import_lex16.l.string({ maxLength: 512 }))
+  })
+);
+var $lxm12 = main16.nsid;
+var $params12 = main16.parameters;
+var $output12 = main16.output;
+
+// src/lexicons/com/atiproto/account/tip/validate.ts
+var validate_exports2 = {};
+__export(validate_exports2, {
+  $defs: () => validate_defs_exports2,
+  $lxm: () => $lxm13,
+  $nsid: () => $nsid17,
+  $output: () => $output13,
+  $params: () => $params13,
+  main: () => main17
+});
+
+// src/lexicons/com/atiproto/account/tip/validate.defs.ts
+var validate_defs_exports2 = {};
+__export(validate_defs_exports2, {
+  $lxm: () => $lxm13,
+  $nsid: () => $nsid17,
+  $output: () => $output13,
+  $params: () => $params13,
+  main: () => main17
+});
+var import_lex17 = require("@atproto/lex");
+var $nsid17 = "com.atiproto.account.tip.validate";
+var main17 = import_lex17.l.query(
+  $nsid17,
+  import_lex17.l.params({
+    tipUri: import_lex17.l.optional(import_lex17.l.string({ format: "at-uri" })),
+    recordUri: import_lex17.l.optional(import_lex17.l.string({ format: "at-uri" })),
+    sender: import_lex17.l.optional(import_lex17.l.string({ format: "did" })),
+    amount: import_lex17.l.optional(import_lex17.l.integer())
+  }),
+  import_lex17.l.jsonPayload({
+    valid: import_lex17.l.boolean(),
+    amount: import_lex17.l.optional(import_lex17.l.integer()),
+    currency: import_lex17.l.optional(import_lex17.l.string({ maxLength: 3 })),
+    reason: import_lex17.l.optional(import_lex17.l.string({ maxLength: 1024 }))
+  })
+);
+var $lxm13 = main17.nsid;
+var $params13 = main17.parameters;
+var $output13 = main17.output;
+
 // src/lexicons/com/atiproto/authEnhanced.ts
 var authEnhanced_exports = {};
 __export(authEnhanced_exports, {
   $defs: () => authEnhanced_defs_exports,
-  $nsid: () => $nsid12,
-  main: () => main12
+  $nsid: () => $nsid18,
+  main: () => main18
 });
 
 // src/lexicons/com/atiproto/authEnhanced.defs.ts
 var authEnhanced_defs_exports = {};
 __export(authEnhanced_defs_exports, {
-  $nsid: () => $nsid12,
-  main: () => main12
+  $nsid: () => $nsid18,
+  main: () => main18
 });
-var import_lex12 = require("@atproto/lex");
-var $nsid12 = "com.atiproto.authEnhanced";
-var main12 = import_lex12.l.permissionSet(
-  $nsid12,
+var import_lex18 = require("@atproto/lex");
+var $nsid18 = "com.atiproto.authEnhanced";
+var main18 = import_lex18.l.permissionSet(
+  $nsid18,
   [
-    import_lex12.l.permission("repo", {
+    import_lex18.l.permission("repo", {
       collection: [
         "com.atiproto.cart",
         "com.atiproto.subscription",
@@ -600,7 +921,7 @@ var main12 = import_lex12.l.permissionSet(
         "com.atiproto.profile"
       ]
     }),
-    import_lex12.l.permission("rpc", {
+    import_lex18.l.permission("rpc", {
       inheritAud: true,
       lxm: [
         "com.atiproto.account.cart.clone",
@@ -610,21 +931,27 @@ var main12 = import_lex12.l.permissionSet(
         "com.atiproto.account.cart.put",
         "com.atiproto.account.profile.get",
         "com.atiproto.account.profile.put",
+        "com.atiproto.account.subscription.get",
+        "com.atiproto.account.subscription.list",
+        "com.atiproto.account.subscription.validate",
+        "com.atiproto.account.tip.get",
+        "com.atiproto.account.tip.list",
+        "com.atiproto.account.tip.validate",
         "com.atiproto.feed.list",
         "com.atiproto.feed.subscription.cancel",
         "com.atiproto.feed.subscription.create",
         "com.atiproto.feed.subscription.get",
         "com.atiproto.feed.subscription.list",
         "com.atiproto.feed.subscription.put",
+        "com.atiproto.feed.subscription.validate",
         "com.atiproto.feed.tip.create",
         "com.atiproto.feed.tip.get",
         "com.atiproto.feed.tip.list",
         "com.atiproto.feed.tip.put",
+        "com.atiproto.feed.tip.validate",
         "com.atiproto.repo.profile.get",
-        "com.atiproto.repo.subscription.search",
-        "com.atiproto.repo.subscription.validate",
-        "com.atiproto.repo.tip.search",
-        "com.atiproto.repo.tip.validate"
+        "com.atiproto.repo.subscription.count",
+        "com.atiproto.repo.tip.count"
       ]
     })
   ],
@@ -638,29 +965,29 @@ var main12 = import_lex12.l.permissionSet(
 var authGeneral_exports = {};
 __export(authGeneral_exports, {
   $defs: () => authGeneral_defs_exports,
-  $nsid: () => $nsid13,
-  main: () => main13
+  $nsid: () => $nsid19,
+  main: () => main19
 });
 
 // src/lexicons/com/atiproto/authGeneral.defs.ts
 var authGeneral_defs_exports = {};
 __export(authGeneral_defs_exports, {
-  $nsid: () => $nsid13,
-  main: () => main13
+  $nsid: () => $nsid19,
+  main: () => main19
 });
-var import_lex13 = require("@atproto/lex");
-var $nsid13 = "com.atiproto.authGeneral";
-var main13 = import_lex13.l.permissionSet(
-  $nsid13,
+var import_lex19 = require("@atproto/lex");
+var $nsid19 = "com.atiproto.authGeneral";
+var main19 = import_lex19.l.permissionSet(
+  $nsid19,
   [
-    import_lex13.l.permission("repo", {
+    import_lex19.l.permission("repo", {
       collection: [
         "com.atiproto.cart",
         "com.atiproto.subscription",
         "com.atiproto.tip"
       ]
     }),
-    import_lex13.l.permission("rpc", {
+    import_lex19.l.permission("rpc", {
       inheritAud: true,
       lxm: [
         "com.atiproto.account.cart.clone",
@@ -668,21 +995,27 @@ var main13 = import_lex13.l.permissionSet(
         "com.atiproto.account.cart.get",
         "com.atiproto.account.cart.list",
         "com.atiproto.account.cart.put",
+        "com.atiproto.account.subscription.get",
+        "com.atiproto.account.subscription.list",
+        "com.atiproto.account.subscription.validate",
+        "com.atiproto.account.tip.get",
+        "com.atiproto.account.tip.list",
+        "com.atiproto.account.tip.validate",
         "com.atiproto.feed.list",
         "com.atiproto.feed.subscription.cancel",
         "com.atiproto.feed.subscription.create",
         "com.atiproto.feed.subscription.get",
         "com.atiproto.feed.subscription.list",
         "com.atiproto.feed.subscription.put",
+        "com.atiproto.feed.subscription.validate",
         "com.atiproto.feed.tip.create",
         "com.atiproto.feed.tip.get",
         "com.atiproto.feed.tip.list",
         "com.atiproto.feed.tip.put",
+        "com.atiproto.feed.tip.validate",
         "com.atiproto.repo.profile.get",
-        "com.atiproto.repo.subscription.search",
-        "com.atiproto.repo.subscription.validate",
-        "com.atiproto.repo.tip.search",
-        "com.atiproto.repo.tip.validate"
+        "com.atiproto.repo.subscription.count",
+        "com.atiproto.repo.tip.count"
       ]
     })
   ],
@@ -710,69 +1043,71 @@ __export(cart_exports2, {
   $type: () => $type,
   $validate: () => $validate,
   cartItem: () => cartItem,
-  main: () => main
+  main: () => main,
+  view: () => view
 });
 
 // src/lexicons/com/atiproto/feed.ts
 var feed_exports = {};
 __export(feed_exports, {
-  list: () => list_exports2,
-  subscription: () => subscription_exports,
-  tip: () => tip_exports
+  list: () => list_exports4,
+  subscription: () => subscription_exports2,
+  tip: () => tip_exports2
 });
 
 // src/lexicons/com/atiproto/feed/list.ts
-var list_exports2 = {};
-__export(list_exports2, {
-  $defs: () => list_defs_exports2,
-  $lxm: () => $lxm8,
-  $nsid: () => $nsid14,
-  $output: () => $output8,
-  $params: () => $params8,
-  main: () => main14
+var list_exports4 = {};
+__export(list_exports4, {
+  $defs: () => list_defs_exports4,
+  $lxm: () => $lxm14,
+  $nsid: () => $nsid20,
+  $output: () => $output14,
+  $params: () => $params14,
+  main: () => main20
 });
 
 // src/lexicons/com/atiproto/feed/list.defs.ts
-var list_defs_exports2 = {};
-__export(list_defs_exports2, {
-  $lxm: () => $lxm8,
-  $nsid: () => $nsid14,
-  $output: () => $output8,
-  $params: () => $params8,
-  main: () => main14
+var list_defs_exports4 = {};
+__export(list_defs_exports4, {
+  $lxm: () => $lxm14,
+  $nsid: () => $nsid20,
+  $output: () => $output14,
+  $params: () => $params14,
+  main: () => main20
 });
-var import_lex14 = require("@atproto/lex");
-var $nsid14 = "com.atiproto.feed.list";
-var main14 = import_lex14.l.query(
-  $nsid14,
-  import_lex14.l.params(),
-  import_lex14.l.jsonPayload({
-    items: import_lex14.l.array(
-      import_lex14.l.typedUnion(
+var import_lex20 = require("@atproto/lex");
+var $nsid20 = "com.atiproto.feed.list";
+var main20 = import_lex20.l.query(
+  $nsid20,
+  import_lex20.l.params(),
+  import_lex20.l.jsonPayload({
+    items: import_lex20.l.array(
+      import_lex20.l.typedUnion(
         [
-          import_lex14.l.typedRef((() => main2)),
-          import_lex14.l.typedRef(
+          import_lex20.l.typedRef((() => main2)),
+          import_lex20.l.typedRef(
             (() => main3)
           )
         ],
         false
       )
     ),
-    cursor: import_lex14.l.optional(import_lex14.l.string({ maxLength: 512 }))
+    cursor: import_lex20.l.optional(import_lex20.l.string({ maxLength: 512 }))
   })
 );
-var $lxm8 = main14.nsid;
-var $params8 = main14.parameters;
-var $output8 = main14.output;
+var $lxm14 = main20.nsid;
+var $params14 = main20.parameters;
+var $output14 = main20.output;
 
 // src/lexicons/com/atiproto/feed/subscription.ts
-var subscription_exports = {};
-__export(subscription_exports, {
+var subscription_exports2 = {};
+__export(subscription_exports2, {
   cancel: () => cancel_exports,
   create: () => create_exports2,
-  get: () => get_exports3,
-  list: () => list_exports3,
-  put: () => put_exports3
+  get: () => get_exports5,
+  list: () => list_exports5,
+  put: () => put_exports3,
+  validate: () => validate_exports3
 });
 
 // src/lexicons/com/atiproto/feed/subscription/cancel.ts
@@ -780,175 +1115,176 @@ var cancel_exports = {};
 __export(cancel_exports, {
   $defs: () => cancel_defs_exports,
   $input: () => $input5,
-  $lxm: () => $lxm9,
-  $nsid: () => $nsid15,
-  $output: () => $output9,
-  $params: () => $params9,
-  main: () => main15
+  $lxm: () => $lxm15,
+  $nsid: () => $nsid21,
+  $output: () => $output15,
+  $params: () => $params15,
+  main: () => main21
 });
 
 // src/lexicons/com/atiproto/feed/subscription/cancel.defs.ts
 var cancel_defs_exports = {};
 __export(cancel_defs_exports, {
   $input: () => $input5,
-  $lxm: () => $lxm9,
-  $nsid: () => $nsid15,
-  $output: () => $output9,
-  $params: () => $params9,
-  main: () => main15
+  $lxm: () => $lxm15,
+  $nsid: () => $nsid21,
+  $output: () => $output15,
+  $params: () => $params15,
+  main: () => main21
 });
-var import_lex15 = require("@atproto/lex");
-var $nsid15 = "com.atiproto.feed.subscription.cancel";
-var main15 = import_lex15.l.procedure(
-  $nsid15,
-  import_lex15.l.params(),
-  import_lex15.l.jsonPayload({ subscriptionUri: import_lex15.l.string({ format: "at-uri" }) }),
-  import_lex15.l.jsonPayload({
-    subscriptionUri: import_lex15.l.string({ format: "at-uri" }),
-    subscription: import_lex15.l.ref(
-      (() => main3)
+var import_lex21 = require("@atproto/lex");
+var $nsid21 = "com.atiproto.feed.subscription.cancel";
+var main21 = import_lex21.l.procedure(
+  $nsid21,
+  import_lex21.l.params(),
+  import_lex21.l.jsonPayload({ subscriptionUri: import_lex21.l.string({ format: "at-uri" }) }),
+  import_lex21.l.jsonPayload({
+    subscriptionUri: import_lex21.l.string({ format: "at-uri" }),
+    subscription: import_lex21.l.ref(
+      (() => view3)
     ),
-    accessUntil: import_lex15.l.string({ format: "datetime" })
+    accessUntil: import_lex21.l.string({ format: "datetime" })
   })
 );
-var $lxm9 = main15.nsid;
-var $params9 = main15.parameters;
-var $input5 = main15.input;
-var $output9 = main15.output;
+var $lxm15 = main21.nsid;
+var $params15 = main21.parameters;
+var $input5 = main21.input;
+var $output15 = main21.output;
 
 // src/lexicons/com/atiproto/feed/subscription/create.ts
 var create_exports2 = {};
 __export(create_exports2, {
   $defs: () => create_defs_exports2,
   $input: () => $input6,
-  $lxm: () => $lxm10,
-  $nsid: () => $nsid16,
-  $output: () => $output10,
-  $params: () => $params10,
-  main: () => main16
+  $lxm: () => $lxm16,
+  $nsid: () => $nsid22,
+  $output: () => $output16,
+  $params: () => $params16,
+  main: () => main22
 });
 
 // src/lexicons/com/atiproto/feed/subscription/create.defs.ts
 var create_defs_exports2 = {};
 __export(create_defs_exports2, {
   $input: () => $input6,
-  $lxm: () => $lxm10,
-  $nsid: () => $nsid16,
-  $output: () => $output10,
-  $params: () => $params10,
-  main: () => main16
+  $lxm: () => $lxm16,
+  $nsid: () => $nsid22,
+  $output: () => $output16,
+  $params: () => $params16,
+  main: () => main22
 });
-var import_lex16 = require("@atproto/lex");
-var $nsid16 = "com.atiproto.feed.subscription.create";
-var main16 = import_lex16.l.procedure(
-  $nsid16,
-  import_lex16.l.params(),
-  import_lex16.l.jsonPayload({
-    subject: import_lex16.l.string({ format: "did" }),
-    amount: import_lex16.l.optional(import_lex16.l.integer()),
-    currency: import_lex16.l.string({ maxLength: 3 }),
-    interval: import_lex16.l.enum(["monthly", "yearly"]),
-    cartUri: import_lex16.l.optional(import_lex16.l.string({ format: "at-uri" })),
-    redirectUrl: import_lex16.l.optional(import_lex16.l.string({ format: "uri" }))
+var import_lex22 = require("@atproto/lex");
+var $nsid22 = "com.atiproto.feed.subscription.create";
+var main22 = import_lex22.l.procedure(
+  $nsid22,
+  import_lex22.l.params(),
+  import_lex22.l.jsonPayload({
+    subject: import_lex22.l.string({ format: "did" }),
+    amount: import_lex22.l.optional(import_lex22.l.integer()),
+    currency: import_lex22.l.string({ maxLength: 3 }),
+    interval: import_lex22.l.enum(["monthly", "yearly"]),
+    cartUri: import_lex22.l.optional(import_lex22.l.string({ format: "at-uri" })),
+    redirectUrl: import_lex22.l.optional(import_lex22.l.string({ format: "uri" })),
+    isPrivate: import_lex22.l.optional(import_lex22.l.boolean())
   }),
-  import_lex16.l.jsonPayload({
-    subscriptionUri: import_lex16.l.string({ format: "at-uri" }),
-    subscription: import_lex16.l.ref(
-      (() => main3)
+  import_lex22.l.jsonPayload({
+    subscriptionUri: import_lex22.l.string({ format: "at-uri" }),
+    subscription: import_lex22.l.ref(
+      (() => view3)
     ),
-    cartUri: import_lex16.l.optional(import_lex16.l.string({ format: "at-uri" })),
-    cart: import_lex16.l.optional(
-      import_lex16.l.ref((() => main))
+    cartUri: import_lex22.l.optional(import_lex22.l.string({ format: "at-uri" })),
+    cart: import_lex22.l.optional(
+      import_lex22.l.ref((() => view))
     ),
-    checkoutUrl: import_lex16.l.optional(import_lex16.l.string({ format: "uri" }))
+    checkoutUrl: import_lex22.l.optional(import_lex22.l.string({ format: "uri" }))
   })
 );
-var $lxm10 = main16.nsid;
-var $params10 = main16.parameters;
-var $input6 = main16.input;
-var $output10 = main16.output;
+var $lxm16 = main22.nsid;
+var $params16 = main22.parameters;
+var $input6 = main22.input;
+var $output16 = main22.output;
 
 // src/lexicons/com/atiproto/feed/subscription/get.ts
-var get_exports3 = {};
-__export(get_exports3, {
-  $defs: () => get_defs_exports3,
-  $lxm: () => $lxm11,
-  $nsid: () => $nsid17,
-  $output: () => $output11,
-  $params: () => $params11,
-  main: () => main17
+var get_exports5 = {};
+__export(get_exports5, {
+  $defs: () => get_defs_exports5,
+  $lxm: () => $lxm17,
+  $nsid: () => $nsid23,
+  $output: () => $output17,
+  $params: () => $params17,
+  main: () => main23
 });
 
 // src/lexicons/com/atiproto/feed/subscription/get.defs.ts
-var get_defs_exports3 = {};
-__export(get_defs_exports3, {
-  $lxm: () => $lxm11,
-  $nsid: () => $nsid17,
-  $output: () => $output11,
-  $params: () => $params11,
-  main: () => main17
+var get_defs_exports5 = {};
+__export(get_defs_exports5, {
+  $lxm: () => $lxm17,
+  $nsid: () => $nsid23,
+  $output: () => $output17,
+  $params: () => $params17,
+  main: () => main23
 });
-var import_lex17 = require("@atproto/lex");
-var $nsid17 = "com.atiproto.feed.subscription.get";
-var main17 = import_lex17.l.query(
-  $nsid17,
-  import_lex17.l.params({ uri: import_lex17.l.string({ format: "at-uri" }) }),
-  import_lex17.l.jsonPayload({
-    uri: import_lex17.l.string({ format: "at-uri" }),
-    cid: import_lex17.l.string({ format: "cid" }),
-    record: import_lex17.l.ref(
-      (() => main3)
+var import_lex23 = require("@atproto/lex");
+var $nsid23 = "com.atiproto.feed.subscription.get";
+var main23 = import_lex23.l.query(
+  $nsid23,
+  import_lex23.l.params({ uri: import_lex23.l.string({ format: "at-uri" }) }),
+  import_lex23.l.jsonPayload({
+    uri: import_lex23.l.string({ format: "at-uri" }),
+    cid: import_lex23.l.string({ format: "cid" }),
+    record: import_lex23.l.ref(
+      (() => view3)
     )
   })
 );
-var $lxm11 = main17.nsid;
-var $params11 = main17.parameters;
-var $output11 = main17.output;
+var $lxm17 = main23.nsid;
+var $params17 = main23.parameters;
+var $output17 = main23.output;
 
 // src/lexicons/com/atiproto/feed/subscription/list.ts
-var list_exports3 = {};
-__export(list_exports3, {
-  $defs: () => list_defs_exports3,
-  $lxm: () => $lxm12,
-  $nsid: () => $nsid18,
-  $output: () => $output12,
-  $params: () => $params12,
-  main: () => main18,
+var list_exports5 = {};
+__export(list_exports5, {
+  $defs: () => list_defs_exports5,
+  $lxm: () => $lxm18,
+  $nsid: () => $nsid24,
+  $output: () => $output18,
+  $params: () => $params18,
+  main: () => main24,
   subscriptionResponse: () => subscriptionResponse
 });
 
 // src/lexicons/com/atiproto/feed/subscription/list.defs.ts
-var list_defs_exports3 = {};
-__export(list_defs_exports3, {
-  $lxm: () => $lxm12,
-  $nsid: () => $nsid18,
-  $output: () => $output12,
-  $params: () => $params12,
-  main: () => main18,
+var list_defs_exports5 = {};
+__export(list_defs_exports5, {
+  $lxm: () => $lxm18,
+  $nsid: () => $nsid24,
+  $output: () => $output18,
+  $params: () => $params18,
+  main: () => main24,
   subscriptionResponse: () => subscriptionResponse
 });
-var import_lex18 = require("@atproto/lex");
-var $nsid18 = "com.atiproto.feed.subscription.list";
-var main18 = import_lex18.l.query(
-  $nsid18,
-  import_lex18.l.params(),
-  import_lex18.l.jsonPayload({
-    subscriptions: import_lex18.l.array(
-      import_lex18.l.ref((() => subscriptionResponse))
+var import_lex24 = require("@atproto/lex");
+var $nsid24 = "com.atiproto.feed.subscription.list";
+var main24 = import_lex24.l.query(
+  $nsid24,
+  import_lex24.l.params(),
+  import_lex24.l.jsonPayload({
+    subscriptions: import_lex24.l.array(
+      import_lex24.l.ref((() => subscriptionResponse))
     ),
-    cursor: import_lex18.l.optional(import_lex18.l.string({ maxLength: 512 }))
+    cursor: import_lex24.l.optional(import_lex24.l.string({ maxLength: 512 }))
   })
 );
-var $lxm12 = main18.nsid;
-var $params12 = main18.parameters;
-var $output12 = main18.output;
-var subscriptionResponse = import_lex18.l.typedObject(
-  $nsid18,
+var $lxm18 = main24.nsid;
+var $params18 = main24.parameters;
+var $output18 = main24.output;
+var subscriptionResponse = import_lex24.l.typedObject(
+  $nsid24,
   "subscriptionResponse",
-  import_lex18.l.object({
-    uri: import_lex18.l.string({ format: "at-uri" }),
-    record: import_lex18.l.ref(
-      (() => main3)
+  import_lex24.l.object({
+    uri: import_lex24.l.string({ format: "at-uri" }),
+    record: import_lex24.l.ref(
+      (() => view3)
     )
   })
 );
@@ -958,51 +1294,92 @@ var put_exports3 = {};
 __export(put_exports3, {
   $defs: () => put_defs_exports3,
   $input: () => $input7,
-  $lxm: () => $lxm13,
-  $nsid: () => $nsid19,
-  $output: () => $output13,
-  $params: () => $params13,
-  main: () => main19
+  $lxm: () => $lxm19,
+  $nsid: () => $nsid25,
+  $output: () => $output19,
+  $params: () => $params19,
+  main: () => main25
 });
 
 // src/lexicons/com/atiproto/feed/subscription/put.defs.ts
 var put_defs_exports3 = {};
 __export(put_defs_exports3, {
   $input: () => $input7,
-  $lxm: () => $lxm13,
-  $nsid: () => $nsid19,
-  $output: () => $output13,
-  $params: () => $params13,
-  main: () => main19
+  $lxm: () => $lxm19,
+  $nsid: () => $nsid25,
+  $output: () => $output19,
+  $params: () => $params19,
+  main: () => main25
 });
-var import_lex19 = require("@atproto/lex");
-var $nsid19 = "com.atiproto.feed.subscription.put";
-var main19 = import_lex19.l.procedure(
-  $nsid19,
-  import_lex19.l.params(),
-  import_lex19.l.jsonPayload({
-    uri: import_lex19.l.string({ format: "at-uri" }),
-    record: import_lex19.l.ref(
+var import_lex25 = require("@atproto/lex");
+var $nsid25 = "com.atiproto.feed.subscription.put";
+var main25 = import_lex25.l.procedure(
+  $nsid25,
+  import_lex25.l.params(),
+  import_lex25.l.jsonPayload({
+    uri: import_lex25.l.string({ format: "at-uri" }),
+    record: import_lex25.l.ref(
       (() => main3)
     )
   }),
-  import_lex19.l.jsonPayload({
-    uri: import_lex19.l.string({ format: "at-uri" }),
-    cid: import_lex19.l.string({ format: "cid" })
+  import_lex25.l.jsonPayload({
+    uri: import_lex25.l.string({ format: "at-uri" }),
+    cid: import_lex25.l.string({ format: "cid" })
+  })
+);
+var $lxm19 = main25.nsid;
+var $params19 = main25.parameters;
+var $input7 = main25.input;
+var $output19 = main25.output;
+
+// src/lexicons/com/atiproto/feed/subscription/validate.ts
+var validate_exports3 = {};
+__export(validate_exports3, {
+  $defs: () => validate_defs_exports3,
+  $lxm: () => $lxm20,
+  $nsid: () => $nsid26,
+  $output: () => $output20,
+  $params: () => $params20,
+  main: () => main26
+});
+
+// src/lexicons/com/atiproto/feed/subscription/validate.defs.ts
+var validate_defs_exports3 = {};
+__export(validate_defs_exports3, {
+  $lxm: () => $lxm20,
+  $nsid: () => $nsid26,
+  $output: () => $output20,
+  $params: () => $params20,
+  main: () => main26
+});
+var import_lex26 = require("@atproto/lex");
+var $nsid26 = "com.atiproto.feed.subscription.validate";
+var main26 = import_lex26.l.query(
+  $nsid26,
+  import_lex26.l.params({
+    subscriptionUri: import_lex26.l.optional(import_lex26.l.string({ format: "at-uri" })),
+    subject: import_lex26.l.optional(import_lex26.l.string({ format: "did" })),
+    amount: import_lex26.l.optional(import_lex26.l.integer())
+  }),
+  import_lex26.l.jsonPayload({
+    valid: import_lex26.l.boolean(),
+    amount: import_lex26.l.optional(import_lex26.l.integer()),
+    currency: import_lex26.l.optional(import_lex26.l.string({ maxLength: 3 })),
+    reason: import_lex26.l.optional(import_lex26.l.string({ maxLength: 1024 }))
   })
 );
-var $lxm13 = main19.nsid;
-var $params13 = main19.parameters;
-var $input7 = main19.input;
-var $output13 = main19.output;
+var $lxm20 = main26.nsid;
+var $params20 = main26.parameters;
+var $output20 = main26.output;
 
 // src/lexicons/com/atiproto/feed/tip.ts
-var tip_exports = {};
-__export(tip_exports, {
+var tip_exports2 = {};
+__export(tip_exports2, {
   create: () => create_exports3,
-  get: () => get_exports4,
-  list: () => list_exports4,
-  put: () => put_exports4
+  get: () => get_exports6,
+  list: () => list_exports6,
+  put: () => put_exports4,
+  validate: () => validate_exports4
 });
 
 // src/lexicons/com/atiproto/feed/tip/create.ts
@@ -1010,161 +1387,203 @@ var create_exports3 = {};
 __export(create_exports3, {
   $defs: () => create_defs_exports3,
   $input: () => $input8,
-  $lxm: () => $lxm14,
-  $nsid: () => $nsid20,
-  $output: () => $output14,
-  $params: () => $params14,
-  main: () => main20
+  $lxm: () => $lxm21,
+  $nsid: () => $nsid27,
+  $output: () => $output21,
+  $params: () => $params21,
+  main: () => main27
 });
 
 // src/lexicons/com/atiproto/feed/tip/create.defs.ts
 var create_defs_exports3 = {};
 __export(create_defs_exports3, {
   $input: () => $input8,
-  $lxm: () => $lxm14,
-  $nsid: () => $nsid20,
-  $output: () => $output14,
-  $params: () => $params14,
-  main: () => main20
+  $lxm: () => $lxm21,
+  $nsid: () => $nsid27,
+  $output: () => $output21,
+  $params: () => $params21,
+  main: () => main27
 });
-var import_lex20 = require("@atproto/lex");
-var $nsid20 = "com.atiproto.feed.tip.create";
-var main20 = import_lex20.l.procedure(
-  $nsid20,
-  import_lex20.l.params(),
-  import_lex20.l.jsonPayload({
-    subject: import_lex20.l.string({ format: "did" }),
-    recordUri: import_lex20.l.optional(import_lex20.l.string({ format: "at-uri" })),
-    amount: import_lex20.l.integer(),
-    currency: import_lex20.l.string({ maxLength: 3 }),
-    cartUri: import_lex20.l.optional(import_lex20.l.string({ format: "at-uri" })),
-    redirectUrl: import_lex20.l.optional(import_lex20.l.string({ format: "uri" })),
-    message: import_lex20.l.optional(import_lex20.l.string({ maxGraphemes: 500, maxLength: 5e3 }))
+var import_lex27 = require("@atproto/lex");
+var $nsid27 = "com.atiproto.feed.tip.create";
+var main27 = import_lex27.l.procedure(
+  $nsid27,
+  import_lex27.l.params(),
+  import_lex27.l.jsonPayload({
+    subject: import_lex27.l.string({ format: "did" }),
+    recordUri: import_lex27.l.optional(import_lex27.l.string({ format: "at-uri" })),
+    amount: import_lex27.l.integer(),
+    currency: import_lex27.l.string({ maxLength: 3 }),
+    cartUri: import_lex27.l.optional(import_lex27.l.string({ format: "at-uri" })),
+    redirectUrl: import_lex27.l.optional(import_lex27.l.string({ format: "uri" })),
+    message: import_lex27.l.optional(import_lex27.l.string({ maxGraphemes: 500, maxLength: 5e3 })),
+    isPrivate: import_lex27.l.optional(import_lex27.l.boolean())
   }),
-  import_lex20.l.jsonPayload({
-    tipUri: import_lex20.l.string({ format: "at-uri" }),
-    tip: import_lex20.l.ref((() => main2)),
-    cartUri: import_lex20.l.optional(import_lex20.l.string({ format: "at-uri" })),
-    cart: import_lex20.l.optional(
-      import_lex20.l.ref((() => main))
+  import_lex27.l.jsonPayload({
+    tipUri: import_lex27.l.string({ format: "at-uri" }),
+    tip: import_lex27.l.ref((() => view2)),
+    cartUri: import_lex27.l.optional(import_lex27.l.string({ format: "at-uri" })),
+    cart: import_lex27.l.optional(
+      import_lex27.l.ref((() => view))
     ),
-    checkoutUrl: import_lex20.l.optional(import_lex20.l.string({ format: "uri" }))
+    checkoutUrl: import_lex27.l.optional(import_lex27.l.string({ format: "uri" }))
   })
 );
-var $lxm14 = main20.nsid;
-var $params14 = main20.parameters;
-var $input8 = main20.input;
-var $output14 = main20.output;
+var $lxm21 = main27.nsid;
+var $params21 = main27.parameters;
+var $input8 = main27.input;
+var $output21 = main27.output;
 
 // src/lexicons/com/atiproto/feed/tip/get.ts
-var get_exports4 = {};
-__export(get_exports4, {
-  $defs: () => get_defs_exports4,
-  $lxm: () => $lxm15,
-  $nsid: () => $nsid21,
-  $output: () => $output15,
-  $params: () => $params15,
-  main: () => main21
+var get_exports6 = {};
+__export(get_exports6, {
+  $defs: () => get_defs_exports6,
+  $lxm: () => $lxm22,
+  $nsid: () => $nsid28,
+  $output: () => $output22,
+  $params: () => $params22,
+  main: () => main28
 });
 
 // src/lexicons/com/atiproto/feed/tip/get.defs.ts
-var get_defs_exports4 = {};
-__export(get_defs_exports4, {
-  $lxm: () => $lxm15,
-  $nsid: () => $nsid21,
-  $output: () => $output15,
-  $params: () => $params15,
-  main: () => main21
+var get_defs_exports6 = {};
+__export(get_defs_exports6, {
+  $lxm: () => $lxm22,
+  $nsid: () => $nsid28,
+  $output: () => $output22,
+  $params: () => $params22,
+  main: () => main28
 });
-var import_lex21 = require("@atproto/lex");
-var $nsid21 = "com.atiproto.feed.tip.get";
-var main21 = import_lex21.l.query(
-  $nsid21,
-  import_lex21.l.params({ uri: import_lex21.l.string({ format: "at-uri" }) }),
-  import_lex21.l.jsonPayload({
-    uri: import_lex21.l.string({ format: "at-uri" }),
-    cid: import_lex21.l.string({ format: "cid" }),
-    value: import_lex21.l.ref((() => main2))
+var import_lex28 = require("@atproto/lex");
+var $nsid28 = "com.atiproto.feed.tip.get";
+var main28 = import_lex28.l.query(
+  $nsid28,
+  import_lex28.l.params({ uri: import_lex28.l.string({ format: "at-uri" }) }),
+  import_lex28.l.jsonPayload({
+    uri: import_lex28.l.string({ format: "at-uri" }),
+    cid: import_lex28.l.string({ format: "cid" }),
+    value: import_lex28.l.ref((() => view2))
   })
 );
-var $lxm15 = main21.nsid;
-var $params15 = main21.parameters;
-var $output15 = main21.output;
+var $lxm22 = main28.nsid;
+var $params22 = main28.parameters;
+var $output22 = main28.output;
 
 // src/lexicons/com/atiproto/feed/tip/list.ts
-var list_exports4 = {};
-__export(list_exports4, {
-  $defs: () => list_defs_exports4,
-  $lxm: () => $lxm16,
-  $nsid: () => $nsid22,
-  $output: () => $output16,
-  $params: () => $params16,
-  main: () => main22
+var list_exports6 = {};
+__export(list_exports6, {
+  $defs: () => list_defs_exports6,
+  $lxm: () => $lxm23,
+  $nsid: () => $nsid29,
+  $output: () => $output23,
+  $params: () => $params23,
+  main: () => main29
 });
 
 // src/lexicons/com/atiproto/feed/tip/list.defs.ts
-var list_defs_exports4 = {};
-__export(list_defs_exports4, {
-  $lxm: () => $lxm16,
-  $nsid: () => $nsid22,
-  $output: () => $output16,
-  $params: () => $params16,
-  main: () => main22
-});
-var import_lex22 = require("@atproto/lex");
-var $nsid22 = "com.atiproto.feed.tip.list";
-var main22 = import_lex22.l.query(
-  $nsid22,
-  import_lex22.l.params(),
-  import_lex22.l.jsonPayload({
-    records: import_lex22.l.array(import_lex22.l.ref((() => main2))),
-    cursor: import_lex22.l.optional(import_lex22.l.string({ maxLength: 512 }))
+var list_defs_exports6 = {};
+__export(list_defs_exports6, {
+  $lxm: () => $lxm23,
+  $nsid: () => $nsid29,
+  $output: () => $output23,
+  $params: () => $params23,
+  main: () => main29
+});
+var import_lex29 = require("@atproto/lex");
+var $nsid29 = "com.atiproto.feed.tip.list";
+var main29 = import_lex29.l.query(
+  $nsid29,
+  import_lex29.l.params(),
+  import_lex29.l.jsonPayload({
+    records: import_lex29.l.array(import_lex29.l.ref((() => view2))),
+    cursor: import_lex29.l.optional(import_lex29.l.string({ maxLength: 512 }))
   })
 );
-var $lxm16 = main22.nsid;
-var $params16 = main22.parameters;
-var $output16 = main22.output;
+var $lxm23 = main29.nsid;
+var $params23 = main29.parameters;
+var $output23 = main29.output;
 
 // src/lexicons/com/atiproto/feed/tip/put.ts
 var put_exports4 = {};
 __export(put_exports4, {
   $defs: () => put_defs_exports4,
   $input: () => $input9,
-  $lxm: () => $lxm17,
-  $nsid: () => $nsid23,
-  $output: () => $output17,
-  $params: () => $params17,
-  main: () => main23
+  $lxm: () => $lxm24,
+  $nsid: () => $nsid30,
+  $output: () => $output24,
+  $params: () => $params24,
+  main: () => main30
 });
 
 // src/lexicons/com/atiproto/feed/tip/put.defs.ts
 var put_defs_exports4 = {};
 __export(put_defs_exports4, {
   $input: () => $input9,
-  $lxm: () => $lxm17,
-  $nsid: () => $nsid23,
-  $output: () => $output17,
-  $params: () => $params17,
-  main: () => main23
-});
-var import_lex23 = require("@atproto/lex");
-var $nsid23 = "com.atiproto.feed.tip.put";
-var main23 = import_lex23.l.procedure(
-  $nsid23,
-  import_lex23.l.params(),
-  import_lex23.l.jsonPayload({
-    uri: import_lex23.l.string({ format: "at-uri" }),
-    record: import_lex23.l.ref((() => main2))
+  $lxm: () => $lxm24,
+  $nsid: () => $nsid30,
+  $output: () => $output24,
+  $params: () => $params24,
+  main: () => main30
+});
+var import_lex30 = require("@atproto/lex");
+var $nsid30 = "com.atiproto.feed.tip.put";
+var main30 = import_lex30.l.procedure(
+  $nsid30,
+  import_lex30.l.params(),
+  import_lex30.l.jsonPayload({
+    uri: import_lex30.l.string({ format: "at-uri" }),
+    record: import_lex30.l.ref((() => main2))
   }),
-  import_lex23.l.jsonPayload({
-    uri: import_lex23.l.string({ format: "at-uri" }),
-    cid: import_lex23.l.string({ format: "cid" })
+  import_lex30.l.jsonPayload({
+    uri: import_lex30.l.string({ format: "at-uri" }),
+    cid: import_lex30.l.string({ format: "cid" })
   })
 );
-var $lxm17 = main23.nsid;
-var $params17 = main23.parameters;
-var $input9 = main23.input;
-var $output17 = main23.output;
+var $lxm24 = main30.nsid;
+var $params24 = main30.parameters;
+var $input9 = main30.input;
+var $output24 = main30.output;
+
+// src/lexicons/com/atiproto/feed/tip/validate.ts
+var validate_exports4 = {};
+__export(validate_exports4, {
+  $defs: () => validate_defs_exports4,
+  $lxm: () => $lxm25,
+  $nsid: () => $nsid31,
+  $output: () => $output25,
+  $params: () => $params25,
+  main: () => main31
+});
+
+// src/lexicons/com/atiproto/feed/tip/validate.defs.ts
+var validate_defs_exports4 = {};
+__export(validate_defs_exports4, {
+  $lxm: () => $lxm25,
+  $nsid: () => $nsid31,
+  $output: () => $output25,
+  $params: () => $params25,
+  main: () => main31
+});
+var import_lex31 = require("@atproto/lex");
+var $nsid31 = "com.atiproto.feed.tip.validate";
+var main31 = import_lex31.l.query(
+  $nsid31,
+  import_lex31.l.params({
+    tipUri: import_lex31.l.optional(import_lex31.l.string({ format: "at-uri" })),
+    recordUri: import_lex31.l.optional(import_lex31.l.string({ format: "at-uri" })),
+    subject: import_lex31.l.optional(import_lex31.l.string({ format: "did" })),
+    amount: import_lex31.l.optional(import_lex31.l.integer())
+  }),
+  import_lex31.l.jsonPayload({
+    valid: import_lex31.l.boolean(),
+    amount: import_lex31.l.optional(import_lex31.l.integer()),
+    currency: import_lex31.l.optional(import_lex31.l.string({ maxLength: 3 })),
+    reason: import_lex31.l.optional(import_lex31.l.string({ maxLength: 1024 }))
+  })
+);
+var $lxm25 = main31.nsid;
+var $params25 = main31.parameters;
+var $output25 = main31.output;
 
 // src/lexicons/com/atiproto/profile.ts
 var profile_exports2 = {};
@@ -1183,296 +1602,189 @@ __export(profile_exports2, {
   $safeValidate: () => $safeValidate4,
   $type: () => $type4,
   $validate: () => $validate4,
-  main: () => main9
+  main: () => main9,
+  view: () => view4
 });
 
 // src/lexicons/com/atiproto/repo.ts
 var repo_exports = {};
 __export(repo_exports, {
   profile: () => profile_exports3,
-  subscription: () => subscription_exports2,
-  tip: () => tip_exports2
+  subscription: () => subscription_exports3,
+  tip: () => tip_exports3
 });
 
 // src/lexicons/com/atiproto/repo/profile.ts
 var profile_exports3 = {};
 __export(profile_exports3, {
-  get: () => get_exports5
+  get: () => get_exports7
 });
 
 // src/lexicons/com/atiproto/repo/profile/get.ts
-var get_exports5 = {};
-__export(get_exports5, {
-  $defs: () => get_defs_exports5,
-  $lxm: () => $lxm18,
-  $nsid: () => $nsid24,
-  $output: () => $output18,
-  $params: () => $params18,
-  main: () => main24
+var get_exports7 = {};
+__export(get_exports7, {
+  $defs: () => get_defs_exports7,
+  $lxm: () => $lxm26,
+  $nsid: () => $nsid32,
+  $output: () => $output26,
+  $params: () => $params26,
+  main: () => main32
 });
 
 // src/lexicons/com/atiproto/repo/profile/get.defs.ts
-var get_defs_exports5 = {};
-__export(get_defs_exports5, {
-  $lxm: () => $lxm18,
-  $nsid: () => $nsid24,
-  $output: () => $output18,
-  $params: () => $params18,
-  main: () => main24
-});
-var import_lex24 = require("@atproto/lex");
-var $nsid24 = "com.atiproto.repo.profile.get";
-var main24 = import_lex24.l.query(
-  $nsid24,
-  import_lex24.l.params({ did: import_lex24.l.string({ format: "did" }) }),
-  import_lex24.l.jsonPayload({
-    did: import_lex24.l.string({ format: "did" }),
-    profile: import_lex24.l.ref((() => main9))
+var get_defs_exports7 = {};
+__export(get_defs_exports7, {
+  $lxm: () => $lxm26,
+  $nsid: () => $nsid32,
+  $output: () => $output26,
+  $params: () => $params26,
+  main: () => main32
+});
+var import_lex32 = require("@atproto/lex");
+var $nsid32 = "com.atiproto.repo.profile.get";
+var main32 = import_lex32.l.query(
+  $nsid32,
+  import_lex32.l.params({ did: import_lex32.l.string({ format: "did" }) }),
+  import_lex32.l.jsonPayload({
+    did: import_lex32.l.string({ format: "did" }),
+    profile: import_lex32.l.ref((() => view4))
   })
 );
-var $lxm18 = main24.nsid;
-var $params18 = main24.parameters;
-var $output18 = main24.output;
+var $lxm26 = main32.nsid;
+var $params26 = main32.parameters;
+var $output26 = main32.output;
 
 // src/lexicons/com/atiproto/repo/subscription.ts
-var subscription_exports2 = {};
-__export(subscription_exports2, {
-  search: () => search_exports,
-  validate: () => validate_exports
-});
-
-// src/lexicons/com/atiproto/repo/subscription/search.ts
-var search_exports = {};
-__export(search_exports, {
-  $defs: () => search_defs_exports,
-  $lxm: () => $lxm19,
-  $nsid: () => $nsid25,
-  $output: () => $output19,
-  $params: () => $params19,
-  main: () => main25,
-  subscriptionResponse: () => subscriptionResponse2
-});
-
-// src/lexicons/com/atiproto/repo/subscription/search.defs.ts
-var search_defs_exports = {};
-__export(search_defs_exports, {
-  $lxm: () => $lxm19,
-  $nsid: () => $nsid25,
-  $output: () => $output19,
-  $params: () => $params19,
-  main: () => main25,
-  subscriptionResponse: () => subscriptionResponse2
-});
-var import_lex25 = require("@atproto/lex");
-var $nsid25 = "com.atiproto.repo.subscription.search";
-var main25 = import_lex25.l.query(
-  $nsid25,
-  import_lex25.l.params({
-    subject: import_lex25.l.string({ format: "did" }),
-    cursor: import_lex25.l.optional(import_lex25.l.string({ maxLength: 512 })),
-    limit: import_lex25.l.optional(
-      import_lex25.l.withDefault(import_lex25.l.integer({ minimum: 1, maximum: 100 }), 50)
-    )
+var subscription_exports3 = {};
+__export(subscription_exports3, {
+  count: () => count_exports
+});
+
+// src/lexicons/com/atiproto/repo/subscription/count.ts
+var count_exports = {};
+__export(count_exports, {
+  $defs: () => count_defs_exports,
+  $lxm: () => $lxm27,
+  $nsid: () => $nsid33,
+  $output: () => $output27,
+  $params: () => $params27,
+  main: () => main33
+});
+
+// src/lexicons/com/atiproto/repo/subscription/count.defs.ts
+var count_defs_exports = {};
+__export(count_defs_exports, {
+  $lxm: () => $lxm27,
+  $nsid: () => $nsid33,
+  $output: () => $output27,
+  $params: () => $params27,
+  main: () => main33
+});
+var import_lex33 = require("@atproto/lex");
+var $nsid33 = "com.atiproto.repo.subscription.count";
+var main33 = import_lex33.l.query(
+  $nsid33,
+  import_lex33.l.params({
+    subject: import_lex33.l.optional(import_lex33.l.string({ format: "did" })),
+    startDate: import_lex33.l.optional(import_lex33.l.string({ format: "datetime" })),
+    endDate: import_lex33.l.optional(import_lex33.l.string({ format: "datetime" }))
   }),
-  import_lex25.l.jsonPayload({
-    subscriptions: import_lex25.l.array(
-      import_lex25.l.ref((() => subscriptionResponse2))
-    ),
-    cursor: import_lex25.l.optional(import_lex25.l.string({ maxLength: 512 }))
-  })
-);
-var $lxm19 = main25.nsid;
-var $params19 = main25.parameters;
-var $output19 = main25.output;
-var subscriptionResponse2 = import_lex25.l.typedObject(
-  $nsid25,
-  "subscriptionResponse",
-  import_lex25.l.object({
-    uri: import_lex25.l.string({ format: "at-uri" }),
-    record: import_lex25.l.ref(
-      (() => main3)
-    )
+  import_lex33.l.jsonPayload({
+    count: import_lex33.l.integer(),
+    amount: import_lex33.l.optional(import_lex33.l.integer()),
+    currency: import_lex33.l.optional(import_lex33.l.string({ maxLength: 3 }))
   })
 );
+var $lxm27 = main33.nsid;
+var $params27 = main33.parameters;
+var $output27 = main33.output;
 
-// src/lexicons/com/atiproto/repo/subscription/validate.ts
-var validate_exports = {};
-__export(validate_exports, {
-  $defs: () => validate_defs_exports,
-  $lxm: () => $lxm20,
-  $nsid: () => $nsid26,
-  $output: () => $output20,
-  $params: () => $params20,
-  main: () => main26
-});
-
-// src/lexicons/com/atiproto/repo/subscription/validate.defs.ts
-var validate_defs_exports = {};
-__export(validate_defs_exports, {
-  $lxm: () => $lxm20,
-  $nsid: () => $nsid26,
-  $output: () => $output20,
-  $params: () => $params20,
-  main: () => main26
-});
-var import_lex26 = require("@atproto/lex");
-var $nsid26 = "com.atiproto.repo.subscription.validate";
-var main26 = import_lex26.l.query(
-  $nsid26,
-  import_lex26.l.params({
-    sender: import_lex26.l.string({ format: "did" }),
-    subscriptionUri: import_lex26.l.optional(import_lex26.l.string({ format: "at-uri" })),
-    subject: import_lex26.l.optional(import_lex26.l.string({ format: "did" })),
-    amount: import_lex26.l.optional(import_lex26.l.integer())
+// src/lexicons/com/atiproto/repo/tip.ts
+var tip_exports3 = {};
+__export(tip_exports3, {
+  count: () => count_exports2
+});
+
+// src/lexicons/com/atiproto/repo/tip/count.ts
+var count_exports2 = {};
+__export(count_exports2, {
+  $defs: () => count_defs_exports2,
+  $lxm: () => $lxm28,
+  $nsid: () => $nsid34,
+  $output: () => $output28,
+  $params: () => $params28,
+  main: () => main34
+});
+
+// src/lexicons/com/atiproto/repo/tip/count.defs.ts
+var count_defs_exports2 = {};
+__export(count_defs_exports2, {
+  $lxm: () => $lxm28,
+  $nsid: () => $nsid34,
+  $output: () => $output28,
+  $params: () => $params28,
+  main: () => main34
+});
+var import_lex34 = require("@atproto/lex");
+var $nsid34 = "com.atiproto.repo.tip.count";
+var main34 = import_lex34.l.query(
+  $nsid34,
+  import_lex34.l.params({
+    recordUri: import_lex34.l.optional(import_lex34.l.string({ format: "at-uri" })),
+    subject: import_lex34.l.optional(import_lex34.l.string({ format: "did" })),
+    startDate: import_lex34.l.optional(import_lex34.l.string({ format: "datetime" })),
+    endDate: import_lex34.l.optional(import_lex34.l.string({ format: "datetime" }))
   }),
-  import_lex26.l.jsonPayload({
-    valid: import_lex26.l.boolean(),
-    amount: import_lex26.l.optional(import_lex26.l.integer()),
-    currency: import_lex26.l.optional(import_lex26.l.string({ maxLength: 3 })),
-    reason: import_lex26.l.optional(import_lex26.l.string({ maxLength: 1024 }))
+  import_lex34.l.jsonPayload({
+    count: import_lex34.l.integer(),
+    amount: import_lex34.l.optional(import_lex34.l.integer()),
+    currency: import_lex34.l.optional(import_lex34.l.string({ maxLength: 3 }))
   })
 );
-var $lxm20 = main26.nsid;
-var $params20 = main26.parameters;
-var $output20 = main26.output;
+var $lxm28 = main34.nsid;
+var $params28 = main34.parameters;
+var $output28 = main34.output;
 
-// src/lexicons/com/atiproto/repo/tip.ts
-var tip_exports2 = {};
-__export(tip_exports2, {
-  search: () => search_exports2,
-  validate: () => validate_exports2
+// src/lexicons/com/atiproto/subscription.ts
+var subscription_exports4 = {};
+__export(subscription_exports4, {
+  $assert: () => $assert3,
+  $build: () => $build3,
+  $cast: () => $cast3,
+  $check: () => $check3,
+  $defs: () => subscription_defs_exports,
+  $ifMatches: () => $ifMatches3,
+  $isTypeOf: () => $isTypeOf3,
+  $matches: () => $matches3,
+  $nsid: () => $nsid3,
+  $parse: () => $parse3,
+  $safeParse: () => $safeParse3,
+  $safeValidate: () => $safeValidate3,
+  $type: () => $type3,
+  $validate: () => $validate3,
+  main: () => main3,
+  view: () => view3
 });
 
-// src/lexicons/com/atiproto/repo/tip/search.ts
-var search_exports2 = {};
-__export(search_exports2, {
-  $defs: () => search_defs_exports2,
-  $lxm: () => $lxm21,
-  $nsid: () => $nsid27,
-  $output: () => $output21,
-  $params: () => $params21,
-  main: () => main27,
-  tipResponse: () => tipResponse
-});
-
-// src/lexicons/com/atiproto/repo/tip/search.defs.ts
-var search_defs_exports2 = {};
-__export(search_defs_exports2, {
-  $lxm: () => $lxm21,
-  $nsid: () => $nsid27,
-  $output: () => $output21,
-  $params: () => $params21,
-  main: () => main27,
-  tipResponse: () => tipResponse
-});
-var import_lex27 = require("@atproto/lex");
-var $nsid27 = "com.atiproto.repo.tip.search";
-var main27 = import_lex27.l.query(
-  $nsid27,
-  import_lex27.l.params({
-    subject: import_lex27.l.string({ format: "did" }),
-    cursor: import_lex27.l.optional(import_lex27.l.string({ maxLength: 512 })),
-    limit: import_lex27.l.optional(
-      import_lex27.l.withDefault(import_lex27.l.integer({ minimum: 1, maximum: 100 }), 50)
-    )
-  }),
-  import_lex27.l.jsonPayload({
-    tips: import_lex27.l.array(import_lex27.l.ref((() => tipResponse))),
-    cursor: import_lex27.l.optional(import_lex27.l.string({ maxLength: 512 }))
-  })
-);
-var $lxm21 = main27.nsid;
-var $params21 = main27.parameters;
-var $output21 = main27.output;
-var tipResponse = import_lex27.l.typedObject(
-  $nsid27,
-  "tipResponse",
-  import_lex27.l.object({
-    uri: import_lex27.l.string({ format: "at-uri" }),
-    record: import_lex27.l.ref((() => main2))
-  })
-);
-
-// src/lexicons/com/atiproto/repo/tip/validate.ts
-var validate_exports2 = {};
-__export(validate_exports2, {
-  $defs: () => validate_defs_exports2,
-  $lxm: () => $lxm22,
-  $nsid: () => $nsid28,
-  $output: () => $output22,
-  $params: () => $params22,
-  main: () => main28
-});
-
-// src/lexicons/com/atiproto/repo/tip/validate.defs.ts
-var validate_defs_exports2 = {};
-__export(validate_defs_exports2, {
-  $lxm: () => $lxm22,
-  $nsid: () => $nsid28,
-  $output: () => $output22,
-  $params: () => $params22,
-  main: () => main28
-});
-var import_lex28 = require("@atproto/lex");
-var $nsid28 = "com.atiproto.repo.tip.validate";
-var main28 = import_lex28.l.query(
-  $nsid28,
-  import_lex28.l.params({
-    sender: import_lex28.l.string({ format: "did" }),
-    tipUri: import_lex28.l.optional(import_lex28.l.string({ format: "at-uri" })),
-    recordUri: import_lex28.l.optional(import_lex28.l.string({ format: "at-uri" })),
-    subject: import_lex28.l.optional(import_lex28.l.string({ format: "did" })),
-    amount: import_lex28.l.optional(import_lex28.l.integer())
-  }),
-  import_lex28.l.jsonPayload({
-    valid: import_lex28.l.boolean(),
-    amount: import_lex28.l.optional(import_lex28.l.integer()),
-    currency: import_lex28.l.optional(import_lex28.l.string({ maxLength: 3 })),
-    reason: import_lex28.l.optional(import_lex28.l.string({ maxLength: 1024 }))
-  })
-);
-var $lxm22 = main28.nsid;
-var $params22 = main28.parameters;
-var $output22 = main28.output;
-
-// src/lexicons/com/atiproto/subscription.ts
-var subscription_exports3 = {};
-__export(subscription_exports3, {
-  $assert: () => $assert3,
-  $build: () => $build3,
-  $cast: () => $cast3,
-  $check: () => $check3,
-  $defs: () => subscription_defs_exports,
-  $ifMatches: () => $ifMatches3,
-  $isTypeOf: () => $isTypeOf3,
-  $matches: () => $matches3,
-  $nsid: () => $nsid3,
-  $parse: () => $parse3,
-  $safeParse: () => $safeParse3,
-  $safeValidate: () => $safeValidate3,
-  $type: () => $type3,
-  $validate: () => $validate3,
-  main: () => main3
-});
-
-// src/lexicons/com/atiproto/tip.ts
-var tip_exports3 = {};
-__export(tip_exports3, {
-  $assert: () => $assert2,
-  $build: () => $build2,
-  $cast: () => $cast2,
-  $check: () => $check2,
-  $defs: () => tip_defs_exports,
-  $ifMatches: () => $ifMatches2,
-  $isTypeOf: () => $isTypeOf2,
-  $matches: () => $matches2,
-  $nsid: () => $nsid2,
-  $parse: () => $parse2,
-  $safeParse: () => $safeParse2,
-  $safeValidate: () => $safeValidate2,
-  $type: () => $type2,
-  $validate: () => $validate2,
-  main: () => main2
+// src/lexicons/com/atiproto/tip.ts
+var tip_exports4 = {};
+__export(tip_exports4, {
+  $assert: () => $assert2,
+  $build: () => $build2,
+  $cast: () => $cast2,
+  $check: () => $check2,
+  $defs: () => tip_defs_exports,
+  $ifMatches: () => $ifMatches2,
+  $isTypeOf: () => $isTypeOf2,
+  $matches: () => $matches2,
+  $nsid: () => $nsid2,
+  $parse: () => $parse2,
+  $safeParse: () => $safeParse2,
+  $safeValidate: () => $safeValidate2,
+  $type: () => $type2,
+  $validate: () => $validate2,
+  main: () => main2,
+  view: () => view2
 });
 
 // src/schemas/account/cart/clone.json
@@ -1516,7 +1828,7 @@ var clone_default = {
           properties: {
             cart: {
               type: "ref",
-              ref: "com.atiproto.cart",
+              ref: "com.atiproto.cart#view",
               description: "The new cart record"
             },
             cartUri: {
@@ -1533,7 +1845,7 @@ var clone_default = {
               type: "array",
               items: {
                 type: "ref",
-                ref: "com.atiproto.tip"
+                ref: "com.atiproto.tip#view"
               },
               description: "Newly created tip records"
             },
@@ -1541,7 +1853,7 @@ var clone_default = {
               type: "array",
               items: {
                 type: "ref",
-                ref: "com.atiproto.subscription"
+                ref: "com.atiproto.subscription#view"
               },
               description: "Newly created subscription records"
             }
@@ -1583,22 +1895,332 @@ var create_default = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["cart", "cartUri", "checkoutUrl"],
+          required: ["cart", "cartUri", "checkoutUrl"],
+          properties: {
+            cart: {
+              type: "ref",
+              ref: "com.atiproto.cart#view",
+              description: "The created cart record"
+            },
+            cartUri: {
+              type: "string",
+              format: "at-uri",
+              description: "URI of the cart record"
+            },
+            checkoutUrl: {
+              type: "string",
+              format: "uri",
+              description: "Checkout URL hosted by atiproto"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/cart/get.json
+var get_default = {
+  lexicon: 1,
+  id: "com.atiproto.account.cart.get",
+  defs: {
+    main: {
+      type: "query",
+      description: "Get a specific cart by URI, including resolved tip and subscription records",
+      parameters: {
+        type: "params",
+        required: ["uri"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the cart record"
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["uri", "cart", "tips", "subscriptions"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Cart record URI"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "Cart record CID"
+            },
+            cart: {
+              type: "ref",
+              ref: "com.atiproto.cart#view",
+              description: "The cart record data"
+            },
+            checkoutUrl: {
+              type: "string",
+              format: "uri",
+              description: "Checkout URL, only present when cart status is open"
+            },
+            tips: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.tip#view"
+              },
+              description: "Resolved tip records referenced by this cart"
+            },
+            subscriptions: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.subscription#view"
+              },
+              description: "Resolved subscription records referenced by this cart"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/cart/list.json
+var list_default = {
+  lexicon: 1,
+  id: "com.atiproto.account.cart.list",
+  defs: {
+    main: {
+      type: "query",
+      description: "List carts for the authenticated user",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              maxLength: 64,
+              enum: ["open", "completed", "expired", "abandoned"],
+              description: "Filter by cart status"
+            },
+            cursor: {
+              type: "string",
+              maxLength: 512,
+              description: "Pagination cursor"
+            },
+            limit: {
+              type: "integer",
+              default: 20,
+              minimum: 1,
+              maximum: 100,
+              description: "Results per page (1-100, default: 20)"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            carts: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "#cartResponse"
+              }
+            },
+            cursor: {
+              type: "string",
+              maxLength: 512,
+              description: "Pagination cursor for next page"
+            }
+          },
+          required: ["carts"]
+        }
+      }
+    },
+    cartResponse: {
+      type: "object",
+      required: ["uri", "cid", "record"],
+      properties: {
+        uri: {
+          type: "string",
+          format: "at-uri",
+          description: "AT-URI of the cart record"
+        },
+        cid: {
+          type: "string",
+          format: "cid",
+          description: "CID of the cart record"
+        },
+        record: {
+          type: "ref",
+          ref: "com.atiproto.cart#view"
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/cart/put.json
+var put_default = {
+  lexicon: 1,
+  id: "com.atiproto.account.cart.put",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Update a cart. Only open carts can be updated.",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["uri", "record"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "AT-URI of the cart to update"
+            },
+            record: {
+              type: "ref",
+              ref: "com.atiproto.cart"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["uri", "cid"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Updated cart record URI"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "New CID of the updated record"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/profile/get.json
+var get_default2 = {
+  lexicon: 1,
+  id: "com.atiproto.account.profile.get",
+  defs: {
+    main: {
+      type: "query",
+      description: "Get the authenticated user's profile settings. Returns defaults if no profile exists.",
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["profile", "hasProfile", "readyForPayment"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Profile record URI (absent if no profile configured)"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "Profile record CID (absent if no profile configured)"
+            },
+            profile: {
+              type: "ref",
+              ref: "com.atiproto.profile#view",
+              description: "The profile record data (defaults if not configured)"
+            },
+            hasProfile: {
+              type: "boolean",
+              description: "Whether the user has saved a profile record"
+            },
+            readyForPayment: {
+              type: "boolean",
+              description: "Whether the user's payment account is set up and enabled"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/profile/put.json
+var put_default2 = {
+  lexicon: 1,
+  id: "com.atiproto.account.profile.put",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Create or update the authenticated user's profile settings",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            acceptsTips: {
+              type: "boolean",
+              description: "Enable accepting tips"
+            },
+            acceptsSubscriptions: {
+              type: "boolean",
+              description: "Enable accepting subscriptions"
+            },
+            disableReceiptNotifications: {
+              type: "boolean",
+              description: "Opt out of payment receipt DMs"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: [
+            "uri",
+            "cid",
+            "profile",
+            "hasProfile",
+            "readyForPayment"
+          ],
           properties: {
-            cart: {
-              type: "ref",
-              ref: "com.atiproto.cart",
-              description: "The created cart record"
-            },
-            cartUri: {
+            uri: {
               type: "string",
               format: "at-uri",
-              description: "URI of the cart record"
+              description: "Profile record URI"
             },
-            checkoutUrl: {
+            cid: {
               type: "string",
-              format: "uri",
-              description: "Checkout URL hosted by atiproto"
+              format: "cid",
+              description: "Profile record CID"
+            },
+            profile: {
+              type: "ref",
+              ref: "com.atiproto.profile#view",
+              description: "The profile record data"
+            },
+            hasProfile: {
+              type: "boolean",
+              description: "Whether the user has saved a profile record"
+            },
+            readyForPayment: {
+              type: "boolean",
+              description: "Whether the user's payment account is set up and enabled"
             }
           }
         }
@@ -1607,22 +2229,26 @@ var create_default = {
   }
 };
 
-// src/schemas/account/cart/get.json
-var get_default = {
+// src/schemas/account/subscription/get.json
+var get_default3 = {
   lexicon: 1,
-  id: "com.atiproto.account.cart.get",
+  id: "com.atiproto.account.subscription.get",
   defs: {
     main: {
       type: "query",
-      description: "Get a specific cart by URI, including resolved tip and subscription records",
+      description: "Get a specific subscription received by the authenticated user (as the recipient/subject). Looks up by subscription record uri or sender DID. These are mutually exclusive; uri takes precedence.",
       parameters: {
         type: "params",
-        required: ["uri"],
         properties: {
           uri: {
             type: "string",
             format: "at-uri",
-            description: "AT-URI of the cart record"
+            description: "AT-URI of the subscription record. Takes precedence over sender."
+          },
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the subscriber. Ignored if uri is provided."
           }
         }
       },
@@ -1630,43 +2256,12 @@ var get_default = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["uri", "cart", "tips", "subscriptions"],
+          required: ["subscription"],
           properties: {
-            uri: {
-              type: "string",
-              format: "at-uri",
-              description: "Cart record URI"
-            },
-            cid: {
-              type: "string",
-              format: "cid",
-              description: "Cart record CID"
-            },
-            cart: {
+            subscription: {
               type: "ref",
-              ref: "com.atiproto.cart",
-              description: "The cart record data"
-            },
-            checkoutUrl: {
-              type: "string",
-              format: "uri",
-              description: "Checkout URL, only present when cart status is open"
-            },
-            tips: {
-              type: "array",
-              items: {
-                type: "ref",
-                ref: "com.atiproto.tip"
-              },
-              description: "Resolved tip records referenced by this cart"
-            },
-            subscriptions: {
-              type: "array",
-              items: {
-                type: "ref",
-                ref: "com.atiproto.subscription"
-              },
-              description: "Resolved subscription records referenced by this cart"
+              ref: "com.atiproto.subscription#view",
+              description: "The subscription record data"
             }
           }
         }
@@ -1675,37 +2270,28 @@ var get_default = {
   }
 };
 
-// src/schemas/account/cart/list.json
-var list_default = {
+// src/schemas/account/subscription/list.json
+var list_default2 = {
   lexicon: 1,
-  id: "com.atiproto.account.cart.list",
+  id: "com.atiproto.account.subscription.list",
   defs: {
     main: {
       type: "query",
-      description: "List carts for the authenticated user",
-      input: {
-        encoding: "application/json",
-        schema: {
-          type: "object",
-          properties: {
-            status: {
-              type: "string",
-              maxLength: 64,
-              enum: ["open", "completed", "expired", "abandoned"],
-              description: "Filter by cart status"
-            },
-            cursor: {
-              type: "string",
-              maxLength: 512,
-              description: "Pagination cursor"
-            },
-            limit: {
-              type: "integer",
-              default: 20,
-              minimum: 1,
-              maximum: 100,
-              description: "Results per page (1-100, default: 20)"
-            }
+      description: "List subscriptions received by the authenticated user (subscriptions where the authed user is the recipient/subject). Includes subscriptions marked private, which are only stored in atiproto's database.",
+      parameters: {
+        type: "params",
+        properties: {
+          cursor: {
+            type: "string",
+            maxLength: 512,
+            description: "Pagination cursor"
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: 100,
+            default: 50,
+            description: "Results per page (1-100, default: 50)"
           }
         }
       },
@@ -1713,12 +2299,13 @@ var list_default = {
         encoding: "application/json",
         schema: {
           type: "object",
+          required: ["subscriptions"],
           properties: {
-            carts: {
+            subscriptions: {
               type: "array",
               items: {
                 type: "ref",
-                ref: "#cartResponse"
+                ref: "com.atiproto.subscription#view"
               }
             },
             cursor: {
@@ -1726,75 +2313,109 @@ var list_default = {
               maxLength: 512,
               description: "Pagination cursor for next page"
             }
-          },
-          required: ["carts"]
-        }
-      }
-    },
-    cartResponse: {
-      type: "object",
-      required: ["uri", "cid", "record"],
-      properties: {
-        uri: {
-          type: "string",
-          format: "at-uri",
-          description: "AT-URI of the cart record"
-        },
-        cid: {
-          type: "string",
-          format: "cid",
-          description: "CID of the cart record"
-        },
-        record: {
-          type: "ref",
-          ref: "com.atiproto.cart"
+          }
         }
       }
     }
   }
 };
 
-// src/schemas/account/cart/put.json
-var put_default = {
+// src/schemas/account/subscription/validate.json
+var validate_default = {
   lexicon: 1,
-  id: "com.atiproto.account.cart.put",
+  id: "com.atiproto.account.subscription.validate",
   defs: {
     main: {
-      type: "procedure",
-      description: "Update a cart. Only open carts can be updated.",
-      input: {
+      type: "query",
+      description: "Validate that a sender has an active, Stripe-verified subscription to the authenticated user (as the recipient/subject). Looks up by subscriptionUri (a specific subscription record) or sender (subscriber DID). These are mutually exclusive; subscriptionUri takes precedence.",
+      parameters: {
+        type: "params",
+        properties: {
+          subscriptionUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific subscription record. Takes precedence over sender."
+          },
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the subscriber. Ignored if subscriptionUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected subscription amount in cents. If omitted, only checks that a subscription exists."
+          }
+        }
+      },
+      output: {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["uri", "record"],
+          required: ["valid"],
           properties: {
-            uri: {
+            valid: {
+              type: "boolean",
+              description: "Whether a sender has an active, verified subscription to the authed recipient"
+            },
+            amount: {
+              type: "integer",
+              description: "Subscription amount in cents"
+            },
+            currency: {
               type: "string",
-              format: "at-uri",
-              description: "AT-URI of the cart to update"
+              maxLength: 3,
+              description: "Currency of the subscription"
             },
-            record: {
-              type: "ref",
-              ref: "com.atiproto.cart"
+            reason: {
+              type: "string",
+              maxLength: 1024,
+              description: "If invalid, reason for rejection"
             }
           }
         }
+      }
+    }
+  }
+};
+
+// src/schemas/account/tip/get.json
+var get_default4 = {
+  lexicon: 1,
+  id: "com.atiproto.account.tip.get",
+  defs: {
+    main: {
+      type: "query",
+      description: "Get a specific tip received by the authenticated user (as the recipient/subject). Looks up by tip record uri, sender DID, or record uri. These are mutually exclusive and resolved in that order.",
+      parameters: {
+        type: "params",
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the tip record. Takes precedence over sender and recordUri."
+          },
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip sender. Takes precedence over recordUri."
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the record being tipped. Ignored if uri or sender is provided."
+          }
+        }
       },
       output: {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["uri", "cid"],
+          required: ["tip"],
           properties: {
-            uri: {
-              type: "string",
-              format: "at-uri",
-              description: "Updated cart record URI"
-            },
-            cid: {
-              type: "string",
-              format: "cid",
-              description: "New CID of the updated record"
+            tip: {
+              type: "ref",
+              ref: "com.atiproto.tip#view",
+              description: "The tip record data"
             }
           }
         }
@@ -1803,42 +2424,58 @@ var put_default = {
   }
 };
 
-// src/schemas/account/profile/get.json
-var get_default2 = {
+// src/schemas/account/tip/list.json
+var list_default3 = {
   lexicon: 1,
-  id: "com.atiproto.account.profile.get",
+  id: "com.atiproto.account.tip.list",
   defs: {
     main: {
       type: "query",
-      description: "Get the authenticated user's profile settings. Returns defaults if no profile exists.",
+      description: "List tips received by the authenticated user (tips where the authed user is the recipient/subject). Includes tips marked private, which are only stored in atiproto's database.",
+      parameters: {
+        type: "params",
+        properties: {
+          sender: {
+            type: "string",
+            format: "did",
+            description: "Optional: only return tips sent by this DID"
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "Optional: only return tips received for this specific record"
+          },
+          cursor: {
+            type: "string",
+            maxLength: 512,
+            description: "Pagination cursor"
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: 100,
+            default: 50,
+            description: "Results per page (1-100, default: 50)"
+          }
+        }
+      },
       output: {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["profile", "hasProfile", "readyForPayment"],
+          required: ["tips"],
           properties: {
-            uri: {
-              type: "string",
-              format: "at-uri",
-              description: "Profile record URI (absent if no profile configured)"
+            tips: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.tip#view"
+              }
             },
-            cid: {
+            cursor: {
               type: "string",
-              format: "cid",
-              description: "Profile record CID (absent if no profile configured)"
-            },
-            profile: {
-              type: "ref",
-              ref: "com.atiproto.profile",
-              description: "The profile record data (defaults if not configured)"
-            },
-            hasProfile: {
-              type: "boolean",
-              description: "Whether the user has saved a profile record"
-            },
-            readyForPayment: {
-              type: "boolean",
-              description: "Whether the user's payment account is set up and enabled"
+              maxLength: 512,
+              description: "Pagination cursor for next page"
             }
           }
         }
@@ -1847,31 +2484,35 @@ var get_default2 = {
   }
 };
 
-// src/schemas/account/profile/put.json
-var put_default2 = {
+// src/schemas/account/tip/validate.json
+var validate_default2 = {
   lexicon: 1,
-  id: "com.atiproto.account.profile.put",
+  id: "com.atiproto.account.tip.validate",
   defs: {
     main: {
-      type: "procedure",
-      description: "Create or update the authenticated user's profile settings",
-      input: {
-        encoding: "application/json",
-        schema: {
-          type: "object",
-          properties: {
-            acceptsTips: {
-              type: "boolean",
-              description: "Enable accepting tips"
-            },
-            acceptsSubscriptions: {
-              type: "boolean",
-              description: "Enable accepting subscriptions"
-            },
-            disableReceiptNotifications: {
-              type: "boolean",
-              description: "Opt out of payment receipt DMs"
-            }
+      type: "query",
+      description: "Validate that a sender has completed tip payment(s) to the authenticated user (as the recipient/subject). Looks up by tipUri (a specific tip record), recordUri (sums all tips for that record), or sender (sender DID). These are mutually exclusive and resolved in that order.",
+      parameters: {
+        type: "params",
+        properties: {
+          tipUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific tip record. Takes precedence over recordUri and sender."
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the record being tipped. Takes precedence over sender."
+          },
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip sender. Ignored if tipUri or recordUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected tip amount in cents. If omitted, only checks that a tip exists."
           }
         }
       },
@@ -1879,36 +2520,25 @@ var put_default2 = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: [
-            "uri",
-            "cid",
-            "profile",
-            "hasProfile",
-            "readyForPayment"
-          ],
+          required: ["valid"],
           properties: {
-            uri: {
-              type: "string",
-              format: "at-uri",
-              description: "Profile record URI"
-            },
-            cid: {
-              type: "string",
-              format: "cid",
-              description: "Profile record CID"
+            valid: {
+              type: "boolean",
+              description: "Whether a sender has completed and verified tip(s) to the authed recipient"
             },
-            profile: {
-              type: "ref",
-              ref: "com.atiproto.profile",
-              description: "The profile record data"
+            amount: {
+              type: "integer",
+              description: "Sum of all verified completed tip amounts in cents"
             },
-            hasProfile: {
-              type: "boolean",
-              description: "Whether the user has saved a profile record"
+            currency: {
+              type: "string",
+              maxLength: 3,
+              description: "Currency of the tips"
             },
-            readyForPayment: {
-              type: "boolean",
-              description: "Whether the user's payment account is set up and enabled"
+            reason: {
+              type: "string",
+              maxLength: 1024,
+              description: "If invalid, reason for rejection"
             }
           }
         }
@@ -1977,6 +2607,57 @@ var cart_default = {
         }
       }
     },
+    view: {
+      type: "object",
+      description: "View of a cart record for use in API responses",
+      required: [
+        "items",
+        "currency",
+        "total",
+        "status",
+        "createdAt",
+        "expiresAt"
+      ],
+      properties: {
+        items: {
+          type: "array",
+          items: {
+            type: "ref",
+            ref: "#cartItem"
+          }
+        },
+        currency: {
+          type: "string",
+          maxLength: 3,
+          description: "ISO 4217 currency code"
+        },
+        total: {
+          type: "integer",
+          description: "Total amount in cents"
+        },
+        status: {
+          type: "string",
+          maxLength: 64,
+          enum: ["open", "completed", "expired", "abandoned"],
+          description: "Cart status"
+        },
+        createdAt: {
+          type: "string",
+          format: "datetime",
+          description: "Creation timestamp"
+        },
+        expiresAt: {
+          type: "string",
+          format: "datetime",
+          description: "Expiration timestamp"
+        },
+        completedAt: {
+          type: "string",
+          format: "datetime",
+          description: "Completion timestamp"
+        }
+      }
+    },
     cartItem: {
       type: "object",
       required: ["type", "recordUri"],
@@ -1998,7 +2679,7 @@ var cart_default = {
 };
 
 // src/schemas/feed/list.json
-var list_default2 = {
+var list_default4 = {
   lexicon: 1,
   id: "com.atiproto.feed.list",
   defs: {
@@ -2085,7 +2766,7 @@ var cancel_default = {
             },
             subscription: {
               type: "ref",
-              ref: "com.atiproto.subscription",
+              ref: "com.atiproto.subscription#view",
               description: "Updated subscription record"
             },
             accessUntil: {
@@ -2138,6 +2819,10 @@ var create_default2 = {
               description: "URL to redirect to after checkout completes",
               format: "uri",
               type: "string"
+            },
+            isPrivate: {
+              description: "If true, the recipient (subject) is stored only in atiproto's private database and is omitted from the PDS subscription record.",
+              type: "boolean"
             }
           },
           required: ["subject", "currency", "interval"],
@@ -2156,7 +2841,7 @@ var create_default2 = {
             subscription: {
               description: "The created subscription record (status: pending)",
               type: "ref",
-              ref: "com.atiproto.subscription"
+              ref: "com.atiproto.subscription#view"
             },
             cartUri: {
               description: "URI of the cart record in PDS",
@@ -2166,7 +2851,7 @@ var create_default2 = {
             cart: {
               description: "The created cart record (status: open)",
               type: "ref",
-              ref: "com.atiproto.cart"
+              ref: "com.atiproto.cart#view"
             },
             checkoutUrl: {
               description: "Checkout URL hosted by atiproto",
@@ -2186,7 +2871,7 @@ var create_default2 = {
 };
 
 // src/schemas/feed/subscription/get.json
-var get_default3 = {
+var get_default5 = {
   defs: {
     main: {
       description: "Get a specific subscription by URI",
@@ -2218,7 +2903,7 @@ var get_default3 = {
             record: {
               description: "The subscription record data",
               type: "ref",
-              ref: "com.atiproto.subscription"
+              ref: "com.atiproto.subscription#view"
             }
           },
           required: ["uri", "cid", "record"],
@@ -2233,7 +2918,7 @@ var get_default3 = {
 };
 
 // src/schemas/feed/subscription/list.json
-var list_default3 = {
+var list_default5 = {
   lexicon: 1,
   id: "com.atiproto.feed.subscription.list",
   defs: {
@@ -2293,7 +2978,7 @@ var list_default3 = {
         },
         record: {
           type: "ref",
-          ref: "com.atiproto.subscription"
+          ref: "com.atiproto.subscription#view"
         }
       }
     }
@@ -2349,6 +3034,64 @@ var put_default3 = {
   }
 };
 
+// src/schemas/feed/subscription/validate.json
+var validate_default3 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.subscription.validate",
+  defs: {
+    main: {
+      type: "query",
+      description: "Validate that the authenticated user (as the sender/subscriber) has an active, Stripe-verified subscription. Looks up by subscriptionUri (a specific subscription record) or subject (recipient DID). These are mutually exclusive; subscriptionUri takes precedence.",
+      parameters: {
+        type: "params",
+        properties: {
+          subscriptionUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific subscription record. Takes precedence over subject."
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the creator being subscribed to. Ignored if subscriptionUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected subscription amount in cents. If omitted, only checks that a subscription exists."
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["valid"],
+          properties: {
+            valid: {
+              type: "boolean",
+              description: "Whether the authed sender has an active, verified subscription"
+            },
+            amount: {
+              type: "integer",
+              description: "Subscription amount in cents"
+            },
+            currency: {
+              type: "string",
+              maxLength: 3,
+              description: "Currency of the subscription"
+            },
+            reason: {
+              type: "string",
+              maxLength: 1024,
+              description: "If invalid, reason for rejection"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
 // src/schemas/feed/tip/create.json
 var create_default3 = {
   lexicon: 1,
@@ -2397,6 +3140,10 @@ var create_default3 = {
               description: "Optional message (max 500 chars)",
               maxGraphemes: 500,
               maxLength: 5e3
+            },
+            isPrivate: {
+              type: "boolean",
+              description: "If true, the recipient (subject) and recordUri are stored only in atiproto's private database and are omitted from the PDS tip record."
             }
           }
         }
@@ -2414,7 +3161,7 @@ var create_default3 = {
             },
             tip: {
               type: "ref",
-              ref: "com.atiproto.tip",
+              ref: "com.atiproto.tip#view",
               description: "The created tip record (status: pending)"
             },
             cartUri: {
@@ -2424,7 +3171,7 @@ var create_default3 = {
             },
             cart: {
               type: "ref",
-              ref: "com.atiproto.cart",
+              ref: "com.atiproto.cart#view",
               description: "The cart record (new or updated)"
             },
             checkoutUrl: {
@@ -2440,7 +3187,7 @@ var create_default3 = {
 };
 
 // src/schemas/feed/tip/get.json
-var get_default4 = {
+var get_default6 = {
   defs: {
     main: {
       description: "Get a specific tip by URI",
@@ -2472,7 +3219,7 @@ var get_default4 = {
             value: {
               description: "The tip record data",
               type: "ref",
-              ref: "com.atiproto.tip"
+              ref: "com.atiproto.tip#view"
             }
           },
           required: ["uri", "cid", "value"],
@@ -2487,7 +3234,7 @@ var get_default4 = {
 };
 
 // src/schemas/feed/tip/list.json
-var list_default4 = {
+var list_default6 = {
   lexicon: 1,
   id: "com.atiproto.feed.tip.list",
   defs: {
@@ -2524,7 +3271,7 @@ var list_default4 = {
               type: "array",
               items: {
                 type: "ref",
-                ref: "com.atiproto.tip"
+                ref: "com.atiproto.tip#view"
               }
             },
             cursor: {
@@ -2569,17 +3316,80 @@ var put_default4 = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["uri", "cid"],
+          required: ["uri", "cid"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Updated tip record URI"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "New CID of the updated record"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/tip/validate.json
+var validate_default4 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.tip.validate",
+  defs: {
+    main: {
+      type: "query",
+      description: "Validate that the authenticated user (as the sender) has completed tip payment(s). Looks up by tipUri (a specific tip record), recordUri (sums all tips for that record), or subject (recipient DID). These are mutually exclusive and resolved in that order.",
+      parameters: {
+        type: "params",
+        properties: {
+          tipUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific tip record. Takes precedence over recordUri and subject."
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the record being tipped. Takes precedence over subject."
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip recipient. Ignored if tipUri or recordUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected tip amount in cents. If omitted, only checks that a tip exists."
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["valid"],
           properties: {
-            uri: {
+            valid: {
+              type: "boolean",
+              description: "Whether the authed sender has completed and verified tip(s)"
+            },
+            amount: {
+              type: "integer",
+              description: "Sum of all verified completed tip amounts in cents"
+            },
+            currency: {
               type: "string",
-              format: "at-uri",
-              description: "Updated tip record URI"
+              maxLength: 3,
+              description: "Currency of the tips"
             },
-            cid: {
+            reason: {
               type: "string",
-              format: "cid",
-              description: "New CID of the updated record"
+              maxLength: 1024,
+              description: "If invalid, reason for rejection"
             }
           }
         }
@@ -2625,12 +3435,41 @@ var profile_default = {
           }
         }
       }
+    },
+    view: {
+      type: "object",
+      description: "View of a user's profile settings for use in API responses",
+      required: ["createdAt"],
+      properties: {
+        acceptsTips: {
+          type: "boolean",
+          description: "Whether user accepts tips (default: true)"
+        },
+        acceptsSubscriptions: {
+          type: "boolean",
+          description: "Whether user accepts subscriptions (default: true)"
+        },
+        disableReceiptNotifications: {
+          type: "boolean",
+          description: "Opt out of payment receipt DMs (default: false)"
+        },
+        createdAt: {
+          type: "string",
+          format: "datetime",
+          description: "Creation timestamp"
+        },
+        updatedAt: {
+          type: "string",
+          format: "datetime",
+          description: "Last update timestamp"
+        }
+      }
     }
   }
 };
 
 // src/schemas/repo/profile/get.json
-var get_default5 = {
+var get_default7 = {
   lexicon: 1,
   id: "com.atiproto.repo.profile.get",
   defs: {
@@ -2661,7 +3500,7 @@ var get_default5 = {
             },
             profile: {
               type: "ref",
-              ref: "com.atiproto.profile",
+              ref: "com.atiproto.profile#view",
               description: "Public profile data"
             }
           }
@@ -2671,107 +3510,31 @@ var get_default5 = {
   }
 };
 
-// src/schemas/repo/subscription/search.json
-var search_default = {
+// src/schemas/repo/subscription/count.json
+var count_default = {
   lexicon: 1,
-  id: "com.atiproto.repo.subscription.search",
+  id: "com.atiproto.repo.subscription.count",
   defs: {
     main: {
       type: "query",
-      description: "Search for subscriptions to a user (subscriptions where subject matches the given DID)",
+      description: "Count active subscriptions. If subject is provided, counts subscriptions received by that DID. If omitted, counts subscriptions the authenticated user has active (as the subscriber). Optionally filtered by a start/end datetime window (matching billingStartDate). When the authenticated user is the subject/owner of the target, the response also includes the sum of amounts.",
       parameters: {
         type: "params",
         properties: {
           subject: {
             type: "string",
             format: "did",
-            description: "DID of the user being subscribed to"
-          },
-          cursor: {
-            type: "string",
-            maxLength: 512,
-            description: "Pagination cursor"
-          },
-          limit: {
-            type: "integer",
-            minimum: 1,
-            maximum: 100,
-            default: 50,
-            description: "Results per page (1-100, default: 50)"
-          }
-        },
-        required: ["subject"]
-      },
-      output: {
-        encoding: "application/json",
-        schema: {
-          type: "object",
-          required: ["subscriptions"],
-          properties: {
-            subscriptions: {
-              type: "array",
-              items: {
-                type: "ref",
-                ref: "#subscriptionResponse"
-              }
-            },
-            cursor: {
-              type: "string",
-              maxLength: 512,
-              description: "Pagination cursor for next page"
-            }
-          }
-        }
-      }
-    },
-    subscriptionResponse: {
-      type: "object",
-      required: ["uri", "record"],
-      properties: {
-        uri: {
-          type: "string",
-          format: "at-uri",
-          description: "AT-URI of the subscription record"
-        },
-        record: {
-          type: "ref",
-          ref: "com.atiproto.subscription"
-        }
-      }
-    }
-  }
-};
-
-// src/schemas/repo/subscription/validate.json
-var validate_default = {
-  lexicon: 1,
-  id: "com.atiproto.repo.subscription.validate",
-  defs: {
-    main: {
-      type: "query",
-      description: "Validate that a sender has an active, Stripe-verified subscription. Looks up by subscriptionUri (a specific subscription record) or subject (recipient DID). These are mutually exclusive; subscriptionUri takes precedence.",
-      parameters: {
-        type: "params",
-        required: ["sender"],
-        properties: {
-          sender: {
-            type: "string",
-            format: "did",
-            description: "DID of the subscriber"
+            description: "DID of the user being subscribed to. If omitted, the query counts subscriptions the authenticated user has active as the subscriber."
           },
-          subscriptionUri: {
+          startDate: {
             type: "string",
-            format: "at-uri",
-            description: "AT-URI of a specific subscription record. Takes precedence over subject."
+            format: "datetime",
+            description: "Only count subscriptions whose billingStartDate is at or after this timestamp"
           },
-          subject: {
+          endDate: {
             type: "string",
-            format: "did",
-            description: "DID of the creator being subscribed to. Ignored if subscriptionUri is provided."
-          },
-          amount: {
-            type: "integer",
-            description: "Expected subscription amount in cents. If omitted, only checks that a subscription exists."
+            format: "datetime",
+            description: "Only count subscriptions whose billingStartDate is at or before this timestamp"
           }
         }
       },
@@ -2779,126 +3542,39 @@ var validate_default = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["valid"],
+          required: ["count"],
           properties: {
-            valid: {
-              type: "boolean",
-              description: "Whether the sender has an active, verified subscription"
+            count: {
+              type: "integer",
+              description: "Number of active subscriptions matching the filter"
             },
             amount: {
               type: "integer",
-              description: "Subscription amount in cents"
+              description: "Sum of all subscription amounts in cents. Only returned when the authenticated user is the subject/owner of the target (or when counting their own active subscriptions)."
             },
             currency: {
               type: "string",
               maxLength: 3,
-              description: "Currency of the subscription"
-            },
-            reason: {
-              type: "string",
-              maxLength: 1024,
-              description: "If invalid, reason for rejection"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-// src/schemas/repo/tip/search.json
-var search_default2 = {
-  lexicon: 1,
-  id: "com.atiproto.repo.tip.search",
-  defs: {
-    main: {
-      type: "query",
-      description: "Search for tips sent to a user (tips where subject matches the given DID)",
-      parameters: {
-        type: "params",
-        properties: {
-          subject: {
-            type: "string",
-            format: "did",
-            description: "DID of the user receiving tips"
-          },
-          cursor: {
-            type: "string",
-            maxLength: 512,
-            description: "Pagination cursor"
-          },
-          limit: {
-            type: "integer",
-            minimum: 1,
-            maximum: 100,
-            default: 50,
-            description: "Results per page (1-100, default: 50)"
-          }
-        },
-        required: ["subject"]
-      },
-      output: {
-        encoding: "application/json",
-        schema: {
-          type: "object",
-          required: ["tips"],
-          properties: {
-            tips: {
-              type: "array",
-              items: {
-                type: "ref",
-                ref: "#tipResponse"
-              }
-            },
-            cursor: {
-              type: "string",
-              maxLength: 512,
-              description: "Pagination cursor for next page"
+              description: "Currency of the summed amount. Only returned when the authenticated user is the subject/owner of the target (or when counting their own active subscriptions)."
             }
           }
         }
       }
-    },
-    tipResponse: {
-      type: "object",
-      required: ["uri", "record"],
-      properties: {
-        uri: {
-          type: "string",
-          format: "at-uri",
-          description: "AT-URI of the tip record"
-        },
-        record: {
-          type: "ref",
-          ref: "com.atiproto.tip"
-        }
-      }
     }
   }
 };
 
-// src/schemas/repo/tip/validate.json
-var validate_default2 = {
+// src/schemas/repo/tip/count.json
+var count_default2 = {
   lexicon: 1,
-  id: "com.atiproto.repo.tip.validate",
+  id: "com.atiproto.repo.tip.count",
   defs: {
     main: {
       type: "query",
-      description: "Validate that a sender has completed tip payment(s). Looks up by tipUri (a specific tip record), recordUri (sums all tips for that record), or subject (recipient DID). These are mutually exclusive and resolved in that order.",
+      description: "Count active (completed) tips. If recordUri is provided, counts tips for that record. If subject is provided, counts tips received by that DID. If neither is provided, counts tips sent by the authenticated user. Optionally filtered by a start/end datetime window. When the authenticated user is the subject/owner of the target, the response also includes the sum of amounts.",
       parameters: {
         type: "params",
-        required: ["sender"],
         properties: {
-          sender: {
-            type: "string",
-            format: "did",
-            description: "DID of the tip sender"
-          },
-          tipUri: {
-            type: "string",
-            format: "at-uri",
-            description: "AT-URI of a specific tip record. Takes precedence over recordUri and subject."
-          },
           recordUri: {
             type: "string",
             format: "at-uri",
@@ -2907,11 +3583,17 @@ var validate_default2 = {
           subject: {
             type: "string",
             format: "did",
-            description: "DID of the tip recipient. Ignored if tipUri or recordUri is provided."
+            description: "DID of the tip recipient. Ignored if recordUri is provided. If omitted (and recordUri is omitted), the query counts tips sent by the authenticated user."
           },
-          amount: {
-            type: "integer",
-            description: "Expected tip amount in cents. If omitted, only checks that a tip exists."
+          startDate: {
+            type: "string",
+            format: "datetime",
+            description: "Only count tips completed at or after this timestamp"
+          },
+          endDate: {
+            type: "string",
+            format: "datetime",
+            description: "Only count tips completed at or before this timestamp"
           }
         }
       },
@@ -2919,25 +3601,20 @@ var validate_default2 = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["valid"],
+          required: ["count"],
           properties: {
-            valid: {
-              type: "boolean",
-              description: "Whether the sender has completed and verified tip(s)"
+            count: {
+              type: "integer",
+              description: "Number of active (completed) tips matching the filter"
             },
             amount: {
               type: "integer",
-              description: "Sum of all verified completed tip amounts in cents"
+              description: "Sum of all tip amounts in cents. Only returned when the authenticated user is the subject/owner of the target (or when counting their own sent tips)."
             },
             currency: {
               type: "string",
               maxLength: 3,
-              description: "Currency of the tips"
-            },
-            reason: {
-              type: "string",
-              maxLength: 1024,
-              description: "If invalid, reason for rejection"
+              description: "Currency of the summed amount. Only returned when the authenticated user is the subject/owner of the target (or when counting their own sent tips)."
             }
           }
         }
@@ -2978,21 +3655,27 @@ var authEnhanced_default = {
             "com.atiproto.account.cart.put",
             "com.atiproto.account.profile.get",
             "com.atiproto.account.profile.put",
+            "com.atiproto.account.subscription.get",
+            "com.atiproto.account.subscription.list",
+            "com.atiproto.account.subscription.validate",
+            "com.atiproto.account.tip.get",
+            "com.atiproto.account.tip.list",
+            "com.atiproto.account.tip.validate",
             "com.atiproto.feed.list",
             "com.atiproto.feed.subscription.cancel",
             "com.atiproto.feed.subscription.create",
             "com.atiproto.feed.subscription.get",
             "com.atiproto.feed.subscription.list",
             "com.atiproto.feed.subscription.put",
+            "com.atiproto.feed.subscription.validate",
             "com.atiproto.feed.tip.create",
             "com.atiproto.feed.tip.get",
             "com.atiproto.feed.tip.list",
             "com.atiproto.feed.tip.put",
+            "com.atiproto.feed.tip.validate",
             "com.atiproto.repo.profile.get",
-            "com.atiproto.repo.subscription.search",
-            "com.atiproto.repo.subscription.validate",
-            "com.atiproto.repo.tip.search",
-            "com.atiproto.repo.tip.validate"
+            "com.atiproto.repo.subscription.count",
+            "com.atiproto.repo.tip.count"
           ]
         }
       ]
@@ -3029,21 +3712,27 @@ var authGeneral_default = {
             "com.atiproto.account.cart.get",
             "com.atiproto.account.cart.list",
             "com.atiproto.account.cart.put",
+            "com.atiproto.account.subscription.get",
+            "com.atiproto.account.subscription.list",
+            "com.atiproto.account.subscription.validate",
+            "com.atiproto.account.tip.get",
+            "com.atiproto.account.tip.list",
+            "com.atiproto.account.tip.validate",
             "com.atiproto.feed.list",
             "com.atiproto.feed.subscription.cancel",
             "com.atiproto.feed.subscription.create",
             "com.atiproto.feed.subscription.get",
             "com.atiproto.feed.subscription.list",
             "com.atiproto.feed.subscription.put",
+            "com.atiproto.feed.subscription.validate",
             "com.atiproto.feed.tip.create",
             "com.atiproto.feed.tip.get",
             "com.atiproto.feed.tip.list",
             "com.atiproto.feed.tip.put",
+            "com.atiproto.feed.tip.validate",
             "com.atiproto.repo.profile.get",
-            "com.atiproto.repo.subscription.search",
-            "com.atiproto.repo.subscription.validate",
-            "com.atiproto.repo.tip.search",
-            "com.atiproto.repo.tip.validate"
+            "com.atiproto.repo.subscription.count",
+            "com.atiproto.repo.tip.count"
           ]
         }
       ]
@@ -3119,6 +3808,67 @@ var subscription_default = {
         type: "object"
       },
       type: "record"
+    },
+    view: {
+      type: "object",
+      description: "View of a subscription record for use in API responses",
+      required: [
+        "amount",
+        "currency",
+        "interval",
+        "status",
+        "billingStartDate",
+        "createdAt"
+      ],
+      properties: {
+        subject: {
+          description: "DID of the user being subscribed to",
+          format: "did",
+          type: "string"
+        },
+        amount: {
+          description: "Subscription amount in cents (0 for free subscriptions)",
+          minimum: 0,
+          type: "integer"
+        },
+        currency: {
+          description: "ISO 4217 currency code",
+          maxLength: 3,
+          type: "string"
+        },
+        interval: {
+          description: "Billing interval",
+          maxLength: 64,
+          enum: ["monthly", "yearly"],
+          type: "string"
+        },
+        status: {
+          description: "Subscription status",
+          maxLength: 64,
+          enum: ["pending", "active", "past_due", "cancelled", "expired"],
+          type: "string"
+        },
+        billingStartDate: {
+          description: "First billing period, can be used to determine recurrence",
+          format: "datetime",
+          type: "string"
+        },
+        cancelledAt: {
+          description: "Cancellation timestamp",
+          format: "datetime",
+          type: "string"
+        },
+        accessUntil: {
+          description: "Date until which the subscriber retains access after cancellation",
+          format: "datetime",
+          type: "string"
+        },
+        createdAt: {
+          description: "Creation timestamp",
+          format: "datetime",
+          type: "string"
+        }
+      }
     }
   },
   id: "com.atiproto.subscription",
@@ -3176,10 +3926,59 @@ var tip_default = {
             type: "string"
           }
         },
-        required: ["subject", "amount", "currency", "status", "createdAt"],
+        required: ["amount", "currency", "status", "createdAt"],
         type: "object"
       },
       type: "record"
+    },
+    view: {
+      type: "object",
+      description: "View of a tip record for use in API responses",
+      required: ["amount", "currency", "status", "createdAt"],
+      properties: {
+        subject: {
+          description: "DID of the user receiving the tip",
+          format: "did",
+          type: "string"
+        },
+        recordUri: {
+          description: "AT-URI of specific record being tipped",
+          format: "at-uri",
+          type: "string"
+        },
+        amount: {
+          description: "Tip amount in cents (0 when recipient allows zero tips)",
+          minimum: 0,
+          type: "integer"
+        },
+        currency: {
+          description: "ISO 4217 currency code",
+          maxLength: 3,
+          type: "string"
+        },
+        status: {
+          description: "Tip status",
+          maxLength: 64,
+          type: "string",
+          enum: ["pending", "authorized", "completed", "failed", "refunded"]
+        },
+        message: {
+          description: "Optional message (max 500 chars)",
+          maxGraphemes: 500,
+          maxLength: 5e3,
+          type: "string"
+        },
+        createdAt: {
+          description: "Creation timestamp",
+          format: "datetime",
+          type: "string"
+        },
+        completedAt: {
+          description: "Completion timestamp",
+          format: "datetime",
+          type: "string"
+        }
+      }
     }
   },
   id: "com.atiproto.tip",
@@ -3195,23 +3994,29 @@ var schemas = [
   put_default,
   get_default2,
   put_default2,
-  cart_default,
+  get_default3,
   list_default2,
+  validate_default,
+  get_default4,
+  list_default3,
+  validate_default2,
+  cart_default,
+  list_default4,
   cancel_default,
   create_default2,
-  get_default3,
-  list_default3,
+  get_default5,
+  list_default5,
   put_default3,
+  validate_default3,
   create_default3,
-  get_default4,
-  list_default4,
+  get_default6,
+  list_default6,
   put_default4,
+  validate_default4,
   profile_default,
-  get_default5,
-  search_default,
-  validate_default,
-  search_default2,
-  validate_default2,
+  get_default7,
+  count_default,
+  count_default2,
   authEnhanced_default,
   authGeneral_default,
   subscription_default,