@atiproto/lexicons 0.1.2 → 0.3.0

package/dist/index.js

@@ -35,6 +35,8 @@ __export(com_exports, {
 var atiproto_exports = {};
 __export(atiproto_exports, {
   account: () => account_exports,
+  authEnhanced: () => authEnhanced_exports,
+  authGeneral: () => authGeneral_exports,
   cart: () => cart_exports2,
   feed: () => feed_exports,
   profile: () => profile_exports2,
@@ -110,9 +112,9 @@ var main = import_lex.l.record(
   $nsid,
   import_lex.l.object({
     items: import_lex.l.array(import_lex.l.ref((() => cartItem))),
-    currency: import_lex.l.string(),
+    currency: import_lex.l.string({ maxLength: 3 }),
     total: import_lex.l.integer(),
-    status: import_lex.l.string(),
+    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" }))
@@ -166,7 +168,7 @@ var main2 = import_lex2.l.record(
     subject: 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(),
+    currency: import_lex2.l.string({ maxLength: 3 }),
     status: import_lex2.l.enum([
       "pending",
       "authorized",
@@ -218,9 +220,9 @@ var main3 = import_lex3.l.record(
   import_lex3.l.object({
     subject: import_lex3.l.string({ format: "did" }),
     amount: import_lex3.l.integer({ minimum: 0 }),
-    currency: import_lex3.l.string(),
-    interval: import_lex3.l.string(),
-    status: import_lex3.l.string(),
+    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" })),
@@ -294,7 +296,7 @@ var main5 = import_lex5.l.procedure(
   $nsid5,
   import_lex5.l.params(),
   import_lex5.l.jsonPayload({
-    currency: import_lex5.l.string(),
+    currency: import_lex5.l.string({ maxLength: 3 }),
     redirectUrl: import_lex5.l.optional(import_lex5.l.string({ format: "uri" }))
   }),
   import_lex5.l.jsonPayload({
@@ -379,7 +381,7 @@ var main7 = import_lex7.l.query(
   import_lex7.l.params(),
   import_lex7.l.jsonPayload({
     carts: import_lex7.l.array(import_lex7.l.ref((() => cartResponse))),
-    cursor: import_lex7.l.optional(import_lex7.l.string())
+    cursor: import_lex7.l.optional(import_lex7.l.string({ maxLength: 512 }))
   })
 );
 var $lxm4 = main7.nsid;
@@ -571,6 +573,125 @@ var $params7 = main11.parameters;
 var $input4 = main11.input;
 var $output7 = main11.output;
 
+// src/lexicons/com/atiproto/authEnhanced.ts
+var authEnhanced_exports = {};
+__export(authEnhanced_exports, {
+  $defs: () => authEnhanced_defs_exports,
+  $nsid: () => $nsid12,
+  main: () => main12
+});
+
+// src/lexicons/com/atiproto/authEnhanced.defs.ts
+var authEnhanced_defs_exports = {};
+__export(authEnhanced_defs_exports, {
+  $nsid: () => $nsid12,
+  main: () => main12
+});
+var import_lex12 = require("@atproto/lex");
+var $nsid12 = "com.atiproto.authEnhanced";
+var main12 = import_lex12.l.permissionSet(
+  $nsid12,
+  [
+    import_lex12.l.permission("repo", {
+      collection: [
+        "com.atiproto.cart",
+        "com.atiproto.subscription",
+        "com.atiproto.tip",
+        "com.atiproto.profile"
+      ]
+    }),
+    import_lex12.l.permission("rpc", {
+      inheritAud: true,
+      lxm: [
+        "com.atiproto.account.cart.clone",
+        "com.atiproto.account.cart.create",
+        "com.atiproto.account.cart.get",
+        "com.atiproto.account.cart.list",
+        "com.atiproto.account.cart.put",
+        "com.atiproto.account.profile.get",
+        "com.atiproto.account.profile.put",
+        "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.tip.create",
+        "com.atiproto.feed.tip.get",
+        "com.atiproto.feed.tip.list",
+        "com.atiproto.feed.tip.put",
+        "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"
+      ]
+    })
+  ],
+  {
+    title: "Enhanced Access",
+    detail: "Full atiproto access. Extends general access with write access to the profile record and RPC access to all profile endpoints."
+  }
+);
+
+// src/lexicons/com/atiproto/authGeneral.ts
+var authGeneral_exports = {};
+__export(authGeneral_exports, {
+  $defs: () => authGeneral_defs_exports,
+  $nsid: () => $nsid13,
+  main: () => main13
+});
+
+// src/lexicons/com/atiproto/authGeneral.defs.ts
+var authGeneral_defs_exports = {};
+__export(authGeneral_defs_exports, {
+  $nsid: () => $nsid13,
+  main: () => main13
+});
+var import_lex13 = require("@atproto/lex");
+var $nsid13 = "com.atiproto.authGeneral";
+var main13 = import_lex13.l.permissionSet(
+  $nsid13,
+  [
+    import_lex13.l.permission("repo", {
+      collection: [
+        "com.atiproto.cart",
+        "com.atiproto.subscription",
+        "com.atiproto.tip"
+      ]
+    }),
+    import_lex13.l.permission("rpc", {
+      inheritAud: true,
+      lxm: [
+        "com.atiproto.account.cart.clone",
+        "com.atiproto.account.cart.create",
+        "com.atiproto.account.cart.get",
+        "com.atiproto.account.cart.list",
+        "com.atiproto.account.cart.put",
+        "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.tip.create",
+        "com.atiproto.feed.tip.get",
+        "com.atiproto.feed.tip.list",
+        "com.atiproto.feed.tip.put",
+        "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"
+      ]
+    })
+  ],
+  {
+    title: "General Access",
+    detail: "Write access to cart, subscription, and tip records, plus RPC access to payment, feed, and public profile lookup endpoints."
+  }
+);
+
 // src/lexicons/com/atiproto/cart.ts
 var cart_exports2 = {};
 __export(cart_exports2, {
@@ -605,44 +726,44 @@ var list_exports2 = {};
 __export(list_exports2, {
   $defs: () => list_defs_exports2,
   $lxm: () => $lxm8,
-  $nsid: () => $nsid12,
+  $nsid: () => $nsid14,
   $output: () => $output8,
   $params: () => $params8,
-  main: () => main12
+  main: () => main14
 });
 
 // src/lexicons/com/atiproto/feed/list.defs.ts
 var list_defs_exports2 = {};
 __export(list_defs_exports2, {
   $lxm: () => $lxm8,
-  $nsid: () => $nsid12,
+  $nsid: () => $nsid14,
   $output: () => $output8,
   $params: () => $params8,
-  main: () => main12
+  main: () => main14
 });
-var import_lex12 = require("@atproto/lex");
-var $nsid12 = "com.atiproto.feed.list";
-var main12 = import_lex12.l.query(
-  $nsid12,
-  import_lex12.l.params(),
-  import_lex12.l.jsonPayload({
-    items: import_lex12.l.array(
-      import_lex12.l.typedUnion(
+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(
         [
-          import_lex12.l.typedRef((() => main2)),
-          import_lex12.l.typedRef(
+          import_lex14.l.typedRef((() => main2)),
+          import_lex14.l.typedRef(
             (() => main3)
           )
         ],
         false
       )
     ),
-    cursor: import_lex12.l.optional(import_lex12.l.string())
+    cursor: import_lex14.l.optional(import_lex14.l.string({ maxLength: 512 }))
   })
 );
-var $lxm8 = main12.nsid;
-var $params8 = main12.parameters;
-var $output8 = main12.output;
+var $lxm8 = main14.nsid;
+var $params8 = main14.parameters;
+var $output8 = main14.output;
 
 // src/lexicons/com/atiproto/feed/subscription.ts
 var subscription_exports = {};
@@ -660,10 +781,10 @@ __export(cancel_exports, {
   $defs: () => cancel_defs_exports,
   $input: () => $input5,
   $lxm: () => $lxm9,
-  $nsid: () => $nsid13,
+  $nsid: () => $nsid15,
   $output: () => $output9,
   $params: () => $params9,
-  main: () => main13
+  main: () => main15
 });
 
 // src/lexicons/com/atiproto/feed/subscription/cancel.defs.ts
@@ -671,29 +792,29 @@ var cancel_defs_exports = {};
 __export(cancel_defs_exports, {
   $input: () => $input5,
   $lxm: () => $lxm9,
-  $nsid: () => $nsid13,
+  $nsid: () => $nsid15,
   $output: () => $output9,
   $params: () => $params9,
-  main: () => main13
+  main: () => main15
 });
-var import_lex13 = require("@atproto/lex");
-var $nsid13 = "com.atiproto.feed.subscription.cancel";
-var main13 = import_lex13.l.procedure(
-  $nsid13,
-  import_lex13.l.params(),
-  import_lex13.l.jsonPayload({ subscriptionUri: import_lex13.l.string({ format: "at-uri" }) }),
-  import_lex13.l.jsonPayload({
-    subscriptionUri: import_lex13.l.string({ format: "at-uri" }),
-    subscription: import_lex13.l.ref(
+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)
     ),
-    accessUntil: import_lex13.l.string({ format: "datetime" })
+    accessUntil: import_lex15.l.string({ format: "datetime" })
   })
 );
-var $lxm9 = main13.nsid;
-var $params9 = main13.parameters;
-var $input5 = main13.input;
-var $output9 = main13.output;
+var $lxm9 = main15.nsid;
+var $params9 = main15.parameters;
+var $input5 = main15.input;
+var $output9 = main15.output;
 
 // src/lexicons/com/atiproto/feed/subscription/create.ts
 var create_exports2 = {};
@@ -701,10 +822,10 @@ __export(create_exports2, {
   $defs: () => create_defs_exports2,
   $input: () => $input6,
   $lxm: () => $lxm10,
-  $nsid: () => $nsid14,
+  $nsid: () => $nsid16,
   $output: () => $output10,
   $params: () => $params10,
-  main: () => main14
+  main: () => main16
 });
 
 // src/lexicons/com/atiproto/feed/subscription/create.defs.ts
@@ -712,83 +833,87 @@ var create_defs_exports2 = {};
 __export(create_defs_exports2, {
   $input: () => $input6,
   $lxm: () => $lxm10,
-  $nsid: () => $nsid14,
+  $nsid: () => $nsid16,
   $output: () => $output10,
   $params: () => $params10,
-  main: () => main14
+  main: () => main16
 });
-var import_lex14 = require("@atproto/lex");
-var $nsid14 = "com.atiproto.feed.subscription.create";
-var main14 = import_lex14.l.procedure(
-  $nsid14,
-  import_lex14.l.params(),
-  import_lex14.l.jsonPayload({
-    subject: import_lex14.l.string({ format: "did" }),
-    amount: import_lex14.l.optional(import_lex14.l.integer()),
-    currency: import_lex14.l.string(),
-    interval: import_lex14.l.string()
+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" }))
   }),
-  import_lex14.l.jsonPayload({
-    subscriptionUri: import_lex14.l.string({ format: "at-uri" }),
-    subscription: import_lex14.l.ref(
+  import_lex16.l.jsonPayload({
+    subscriptionUri: import_lex16.l.string({ format: "at-uri" }),
+    subscription: import_lex16.l.ref(
       (() => main3)
     ),
-    cartUri: import_lex14.l.string({ format: "at-uri" }),
-    cart: import_lex14.l.ref((() => main)),
-    checkoutUrl: import_lex14.l.string({ format: "uri" })
+    cartUri: import_lex16.l.optional(import_lex16.l.string({ format: "at-uri" })),
+    cart: import_lex16.l.optional(
+      import_lex16.l.ref((() => main))
+    ),
+    checkoutUrl: import_lex16.l.optional(import_lex16.l.string({ format: "uri" }))
   })
 );
-var $lxm10 = main14.nsid;
-var $params10 = main14.parameters;
-var $input6 = main14.input;
-var $output10 = main14.output;
+var $lxm10 = main16.nsid;
+var $params10 = main16.parameters;
+var $input6 = main16.input;
+var $output10 = main16.output;
 
 // src/lexicons/com/atiproto/feed/subscription/get.ts
 var get_exports3 = {};
 __export(get_exports3, {
   $defs: () => get_defs_exports3,
   $lxm: () => $lxm11,
-  $nsid: () => $nsid15,
+  $nsid: () => $nsid17,
   $output: () => $output11,
   $params: () => $params11,
-  main: () => main15
+  main: () => main17
 });
 
 // src/lexicons/com/atiproto/feed/subscription/get.defs.ts
 var get_defs_exports3 = {};
 __export(get_defs_exports3, {
   $lxm: () => $lxm11,
-  $nsid: () => $nsid15,
+  $nsid: () => $nsid17,
   $output: () => $output11,
   $params: () => $params11,
-  main: () => main15
+  main: () => main17
 });
-var import_lex15 = require("@atproto/lex");
-var $nsid15 = "com.atiproto.feed.subscription.get";
-var main15 = import_lex15.l.query(
-  $nsid15,
-  import_lex15.l.params({ uri: import_lex15.l.string({ format: "at-uri" }) }),
-  import_lex15.l.jsonPayload({
-    uri: import_lex15.l.string({ format: "at-uri" }),
-    cid: import_lex15.l.string({ format: "cid" }),
-    record: import_lex15.l.ref(
+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 $lxm11 = main15.nsid;
-var $params11 = main15.parameters;
-var $output11 = main15.output;
+var $lxm11 = main17.nsid;
+var $params11 = main17.parameters;
+var $output11 = main17.output;
 
 // src/lexicons/com/atiproto/feed/subscription/list.ts
 var list_exports3 = {};
 __export(list_exports3, {
   $defs: () => list_defs_exports3,
   $lxm: () => $lxm12,
-  $nsid: () => $nsid16,
+  $nsid: () => $nsid18,
   $output: () => $output12,
   $params: () => $params12,
-  main: () => main16,
+  main: () => main18,
   subscriptionResponse: () => subscriptionResponse
 });
 
@@ -796,33 +921,33 @@ __export(list_exports3, {
 var list_defs_exports3 = {};
 __export(list_defs_exports3, {
   $lxm: () => $lxm12,
-  $nsid: () => $nsid16,
+  $nsid: () => $nsid18,
   $output: () => $output12,
   $params: () => $params12,
-  main: () => main16,
+  main: () => main18,
   subscriptionResponse: () => subscriptionResponse
 });
-var import_lex16 = require("@atproto/lex");
-var $nsid16 = "com.atiproto.feed.subscription.list";
-var main16 = import_lex16.l.query(
-  $nsid16,
-  import_lex16.l.params(),
-  import_lex16.l.jsonPayload({
-    subscriptions: import_lex16.l.array(
-      import_lex16.l.ref((() => 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))
     ),
-    cursor: import_lex16.l.optional(import_lex16.l.string())
+    cursor: import_lex18.l.optional(import_lex18.l.string({ maxLength: 512 }))
   })
 );
-var $lxm12 = main16.nsid;
-var $params12 = main16.parameters;
-var $output12 = main16.output;
-var subscriptionResponse = import_lex16.l.typedObject(
-  $nsid16,
+var $lxm12 = main18.nsid;
+var $params12 = main18.parameters;
+var $output12 = main18.output;
+var subscriptionResponse = import_lex18.l.typedObject(
+  $nsid18,
   "subscriptionResponse",
-  import_lex16.l.object({
-    uri: import_lex16.l.string({ format: "at-uri" }),
-    record: import_lex16.l.ref(
+  import_lex18.l.object({
+    uri: import_lex18.l.string({ format: "at-uri" }),
+    record: import_lex18.l.ref(
       (() => main3)
     )
   })
@@ -834,10 +959,10 @@ __export(put_exports3, {
   $defs: () => put_defs_exports3,
   $input: () => $input7,
   $lxm: () => $lxm13,
-  $nsid: () => $nsid17,
+  $nsid: () => $nsid19,
   $output: () => $output13,
   $params: () => $params13,
-  main: () => main17
+  main: () => main19
 });
 
 // src/lexicons/com/atiproto/feed/subscription/put.defs.ts
@@ -845,31 +970,31 @@ var put_defs_exports3 = {};
 __export(put_defs_exports3, {
   $input: () => $input7,
   $lxm: () => $lxm13,
-  $nsid: () => $nsid17,
+  $nsid: () => $nsid19,
   $output: () => $output13,
   $params: () => $params13,
-  main: () => main17
+  main: () => main19
 });
-var import_lex17 = require("@atproto/lex");
-var $nsid17 = "com.atiproto.feed.subscription.put";
-var main17 = import_lex17.l.procedure(
-  $nsid17,
-  import_lex17.l.params(),
-  import_lex17.l.jsonPayload({
-    uri: import_lex17.l.string({ format: "at-uri" }),
-    record: import_lex17.l.ref(
+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(
       (() => main3)
     )
   }),
-  import_lex17.l.jsonPayload({
-    uri: import_lex17.l.string({ format: "at-uri" }),
-    cid: import_lex17.l.string({ format: "cid" })
+  import_lex19.l.jsonPayload({
+    uri: import_lex19.l.string({ format: "at-uri" }),
+    cid: import_lex19.l.string({ format: "cid" })
   })
 );
-var $lxm13 = main17.nsid;
-var $params13 = main17.parameters;
-var $input7 = main17.input;
-var $output13 = main17.output;
+var $lxm13 = main19.nsid;
+var $params13 = main19.parameters;
+var $input7 = main19.input;
+var $output13 = main19.output;
 
 // src/lexicons/com/atiproto/feed/tip.ts
 var tip_exports = {};
@@ -886,10 +1011,10 @@ __export(create_exports3, {
   $defs: () => create_defs_exports3,
   $input: () => $input8,
   $lxm: () => $lxm14,
-  $nsid: () => $nsid18,
+  $nsid: () => $nsid20,
   $output: () => $output14,
   $params: () => $params14,
-  main: () => main18
+  main: () => main20
 });
 
 // src/lexicons/com/atiproto/feed/tip/create.defs.ts
@@ -897,106 +1022,108 @@ var create_defs_exports3 = {};
 __export(create_defs_exports3, {
   $input: () => $input8,
   $lxm: () => $lxm14,
-  $nsid: () => $nsid18,
+  $nsid: () => $nsid20,
   $output: () => $output14,
   $params: () => $params14,
-  main: () => main18
+  main: () => main20
 });
-var import_lex18 = require("@atproto/lex");
-var $nsid18 = "com.atiproto.feed.tip.create";
-var main18 = import_lex18.l.procedure(
-  $nsid18,
-  import_lex18.l.params(),
-  import_lex18.l.jsonPayload({
-    subject: import_lex18.l.string({ format: "did" }),
-    recordUri: import_lex18.l.optional(import_lex18.l.string({ format: "at-uri" })),
-    amount: import_lex18.l.integer(),
-    currency: import_lex18.l.string(),
-    cartUri: import_lex18.l.optional(import_lex18.l.string({ format: "at-uri" })),
-    redirectUrl: import_lex18.l.optional(import_lex18.l.string({ format: "uri" })),
-    message: import_lex18.l.optional(import_lex18.l.string({ maxGraphemes: 500, maxLength: 5e3 }))
+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 }))
   }),
-  import_lex18.l.jsonPayload({
-    tipUri: import_lex18.l.string({ format: "at-uri" }),
-    tip: import_lex18.l.ref((() => main2)),
-    cartUri: import_lex18.l.string({ format: "at-uri" }),
-    cart: import_lex18.l.ref((() => main)),
-    checkoutUrl: import_lex18.l.string({ format: "uri" })
+  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))
+    ),
+    checkoutUrl: import_lex20.l.optional(import_lex20.l.string({ format: "uri" }))
   })
 );
-var $lxm14 = main18.nsid;
-var $params14 = main18.parameters;
-var $input8 = main18.input;
-var $output14 = main18.output;
+var $lxm14 = main20.nsid;
+var $params14 = main20.parameters;
+var $input8 = main20.input;
+var $output14 = main20.output;
 
 // src/lexicons/com/atiproto/feed/tip/get.ts
 var get_exports4 = {};
 __export(get_exports4, {
   $defs: () => get_defs_exports4,
   $lxm: () => $lxm15,
-  $nsid: () => $nsid19,
+  $nsid: () => $nsid21,
   $output: () => $output15,
   $params: () => $params15,
-  main: () => main19
+  main: () => main21
 });
 
 // src/lexicons/com/atiproto/feed/tip/get.defs.ts
 var get_defs_exports4 = {};
 __export(get_defs_exports4, {
   $lxm: () => $lxm15,
-  $nsid: () => $nsid19,
+  $nsid: () => $nsid21,
   $output: () => $output15,
   $params: () => $params15,
-  main: () => main19
+  main: () => main21
 });
-var import_lex19 = require("@atproto/lex");
-var $nsid19 = "com.atiproto.feed.tip.get";
-var main19 = import_lex19.l.query(
-  $nsid19,
-  import_lex19.l.params({ uri: import_lex19.l.string({ format: "at-uri" }) }),
-  import_lex19.l.jsonPayload({
-    uri: import_lex19.l.string({ format: "at-uri" }),
-    cid: import_lex19.l.string({ format: "cid" }),
-    value: import_lex19.l.ref((() => main2))
+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 $lxm15 = main19.nsid;
-var $params15 = main19.parameters;
-var $output15 = main19.output;
+var $lxm15 = main21.nsid;
+var $params15 = main21.parameters;
+var $output15 = main21.output;
 
 // src/lexicons/com/atiproto/feed/tip/list.ts
 var list_exports4 = {};
 __export(list_exports4, {
   $defs: () => list_defs_exports4,
   $lxm: () => $lxm16,
-  $nsid: () => $nsid20,
+  $nsid: () => $nsid22,
   $output: () => $output16,
   $params: () => $params16,
-  main: () => main20
+  main: () => main22
 });
 
 // src/lexicons/com/atiproto/feed/tip/list.defs.ts
 var list_defs_exports4 = {};
 __export(list_defs_exports4, {
   $lxm: () => $lxm16,
-  $nsid: () => $nsid20,
+  $nsid: () => $nsid22,
   $output: () => $output16,
   $params: () => $params16,
-  main: () => main20
+  main: () => main22
 });
-var import_lex20 = require("@atproto/lex");
-var $nsid20 = "com.atiproto.feed.tip.list";
-var main20 = import_lex20.l.query(
-  $nsid20,
-  import_lex20.l.params(),
-  import_lex20.l.jsonPayload({
-    records: import_lex20.l.array(import_lex20.l.ref((() => main2))),
-    cursor: import_lex20.l.optional(import_lex20.l.string())
+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 $lxm16 = main20.nsid;
-var $params16 = main20.parameters;
-var $output16 = main20.output;
+var $lxm16 = main22.nsid;
+var $params16 = main22.parameters;
+var $output16 = main22.output;
 
 // src/lexicons/com/atiproto/feed/tip/put.ts
 var put_exports4 = {};
@@ -1004,10 +1131,10 @@ __export(put_exports4, {
   $defs: () => put_defs_exports4,
   $input: () => $input9,
   $lxm: () => $lxm17,
-  $nsid: () => $nsid21,
+  $nsid: () => $nsid23,
   $output: () => $output17,
   $params: () => $params17,
-  main: () => main21
+  main: () => main23
 });
 
 // src/lexicons/com/atiproto/feed/tip/put.defs.ts
@@ -1015,29 +1142,29 @@ var put_defs_exports4 = {};
 __export(put_defs_exports4, {
   $input: () => $input9,
   $lxm: () => $lxm17,
-  $nsid: () => $nsid21,
+  $nsid: () => $nsid23,
   $output: () => $output17,
   $params: () => $params17,
-  main: () => main21
+  main: () => main23
 });
-var import_lex21 = require("@atproto/lex");
-var $nsid21 = "com.atiproto.feed.tip.put";
-var main21 = import_lex21.l.procedure(
-  $nsid21,
-  import_lex21.l.params(),
-  import_lex21.l.jsonPayload({
-    uri: import_lex21.l.string({ format: "at-uri" }),
-    record: import_lex21.l.ref((() => main2))
+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))
   }),
-  import_lex21.l.jsonPayload({
-    uri: import_lex21.l.string({ format: "at-uri" }),
-    cid: import_lex21.l.string({ format: "cid" })
+  import_lex23.l.jsonPayload({
+    uri: import_lex23.l.string({ format: "at-uri" }),
+    cid: import_lex23.l.string({ format: "cid" })
   })
 );
-var $lxm17 = main21.nsid;
-var $params17 = main21.parameters;
-var $input9 = main21.input;
-var $output17 = main21.output;
+var $lxm17 = main23.nsid;
+var $params17 = main23.parameters;
+var $input9 = main23.input;
+var $output17 = main23.output;
 
 // src/lexicons/com/atiproto/profile.ts
 var profile_exports2 = {};
@@ -1078,34 +1205,34 @@ var get_exports5 = {};
 __export(get_exports5, {
   $defs: () => get_defs_exports5,
   $lxm: () => $lxm18,
-  $nsid: () => $nsid22,
+  $nsid: () => $nsid24,
   $output: () => $output18,
   $params: () => $params18,
-  main: () => main22
+  main: () => main24
 });
 
 // src/lexicons/com/atiproto/repo/profile/get.defs.ts
 var get_defs_exports5 = {};
 __export(get_defs_exports5, {
   $lxm: () => $lxm18,
-  $nsid: () => $nsid22,
+  $nsid: () => $nsid24,
   $output: () => $output18,
   $params: () => $params18,
-  main: () => main22
+  main: () => main24
 });
-var import_lex22 = require("@atproto/lex");
-var $nsid22 = "com.atiproto.repo.profile.get";
-var main22 = import_lex22.l.query(
-  $nsid22,
-  import_lex22.l.params({ did: import_lex22.l.string({ format: "did" }) }),
-  import_lex22.l.jsonPayload({
-    did: import_lex22.l.string({ format: "did" }),
-    profile: import_lex22.l.ref((() => main9))
+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 $lxm18 = main22.nsid;
-var $params18 = main22.parameters;
-var $output18 = main22.output;
+var $lxm18 = main24.nsid;
+var $params18 = main24.parameters;
+var $output18 = main24.output;
 
 // src/lexicons/com/atiproto/repo/subscription.ts
 var subscription_exports2 = {};
@@ -1119,10 +1246,10 @@ var search_exports = {};
 __export(search_exports, {
   $defs: () => search_defs_exports,
   $lxm: () => $lxm19,
-  $nsid: () => $nsid23,
+  $nsid: () => $nsid25,
   $output: () => $output19,
   $params: () => $params19,
-  main: () => main23,
+  main: () => main25,
   subscriptionResponse: () => subscriptionResponse2
 });
 
@@ -1130,39 +1257,39 @@ __export(search_exports, {
 var search_defs_exports = {};
 __export(search_defs_exports, {
   $lxm: () => $lxm19,
-  $nsid: () => $nsid23,
+  $nsid: () => $nsid25,
   $output: () => $output19,
   $params: () => $params19,
-  main: () => main23,
+  main: () => main25,
   subscriptionResponse: () => subscriptionResponse2
 });
-var import_lex23 = require("@atproto/lex");
-var $nsid23 = "com.atiproto.repo.subscription.search";
-var main23 = import_lex23.l.query(
-  $nsid23,
-  import_lex23.l.params({
-    subject: import_lex23.l.string({ format: "did" }),
-    cursor: import_lex23.l.optional(import_lex23.l.string()),
-    limit: import_lex23.l.optional(
-      import_lex23.l.withDefault(import_lex23.l.integer({ minimum: 1, maximum: 100 }), 50)
+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)
     )
   }),
-  import_lex23.l.jsonPayload({
-    subscriptions: import_lex23.l.array(
-      import_lex23.l.ref((() => subscriptionResponse2))
+  import_lex25.l.jsonPayload({
+    subscriptions: import_lex25.l.array(
+      import_lex25.l.ref((() => subscriptionResponse2))
     ),
-    cursor: import_lex23.l.optional(import_lex23.l.string())
+    cursor: import_lex25.l.optional(import_lex25.l.string({ maxLength: 512 }))
   })
 );
-var $lxm19 = main23.nsid;
-var $params19 = main23.parameters;
-var $output19 = main23.output;
-var subscriptionResponse2 = import_lex23.l.typedObject(
-  $nsid23,
+var $lxm19 = main25.nsid;
+var $params19 = main25.parameters;
+var $output19 = main25.output;
+var subscriptionResponse2 = import_lex25.l.typedObject(
+  $nsid25,
   "subscriptionResponse",
-  import_lex23.l.object({
-    uri: import_lex23.l.string({ format: "at-uri" }),
-    record: import_lex23.l.ref(
+  import_lex25.l.object({
+    uri: import_lex25.l.string({ format: "at-uri" }),
+    record: import_lex25.l.ref(
       (() => main3)
     )
   })
@@ -1173,41 +1300,41 @@ var validate_exports = {};
 __export(validate_exports, {
   $defs: () => validate_defs_exports,
   $lxm: () => $lxm20,
-  $nsid: () => $nsid24,
+  $nsid: () => $nsid26,
   $output: () => $output20,
   $params: () => $params20,
-  main: () => main24
+  main: () => main26
 });
 
 // src/lexicons/com/atiproto/repo/subscription/validate.defs.ts
 var validate_defs_exports = {};
 __export(validate_defs_exports, {
   $lxm: () => $lxm20,
-  $nsid: () => $nsid24,
+  $nsid: () => $nsid26,
   $output: () => $output20,
   $params: () => $params20,
-  main: () => main24
+  main: () => main26
 });
-var import_lex24 = require("@atproto/lex");
-var $nsid24 = "com.atiproto.repo.subscription.validate";
-var main24 = import_lex24.l.query(
-  $nsid24,
-  import_lex24.l.params({
-    sender: import_lex24.l.string({ format: "did" }),
-    subscriptionUri: import_lex24.l.optional(import_lex24.l.string({ format: "at-uri" })),
-    subject: import_lex24.l.optional(import_lex24.l.string({ format: "did" })),
-    amount: import_lex24.l.optional(import_lex24.l.integer())
+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())
   }),
-  import_lex24.l.jsonPayload({
-    valid: import_lex24.l.boolean(),
-    amount: import_lex24.l.optional(import_lex24.l.integer()),
-    currency: import_lex24.l.optional(import_lex24.l.string()),
-    reason: import_lex24.l.optional(import_lex24.l.string())
+  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 $lxm20 = main24.nsid;
-var $params20 = main24.parameters;
-var $output20 = main24.output;
+var $lxm20 = main26.nsid;
+var $params20 = main26.parameters;
+var $output20 = main26.output;
 
 // src/lexicons/com/atiproto/repo/tip.ts
 var tip_exports2 = {};
@@ -1221,10 +1348,10 @@ var search_exports2 = {};
 __export(search_exports2, {
   $defs: () => search_defs_exports2,
   $lxm: () => $lxm21,
-  $nsid: () => $nsid25,
+  $nsid: () => $nsid27,
   $output: () => $output21,
   $params: () => $params21,
-  main: () => main25,
+  main: () => main27,
   tipResponse: () => tipResponse
 });
 
@@ -1232,37 +1359,37 @@ __export(search_exports2, {
 var search_defs_exports2 = {};
 __export(search_defs_exports2, {
   $lxm: () => $lxm21,
-  $nsid: () => $nsid25,
+  $nsid: () => $nsid27,
   $output: () => $output21,
   $params: () => $params21,
-  main: () => main25,
+  main: () => main27,
   tipResponse: () => tipResponse
 });
-var import_lex25 = require("@atproto/lex");
-var $nsid25 = "com.atiproto.repo.tip.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()),
-    limit: import_lex25.l.optional(
-      import_lex25.l.withDefault(import_lex25.l.integer({ minimum: 1, maximum: 100 }), 50)
+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_lex25.l.jsonPayload({
-    tips: import_lex25.l.array(import_lex25.l.ref((() => tipResponse))),
-    cursor: import_lex25.l.optional(import_lex25.l.string())
+  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 = main25.nsid;
-var $params21 = main25.parameters;
-var $output21 = main25.output;
-var tipResponse = import_lex25.l.typedObject(
-  $nsid25,
+var $lxm21 = main27.nsid;
+var $params21 = main27.parameters;
+var $output21 = main27.output;
+var tipResponse = import_lex27.l.typedObject(
+  $nsid27,
   "tipResponse",
-  import_lex25.l.object({
-    uri: import_lex25.l.string({ format: "at-uri" }),
-    record: import_lex25.l.ref((() => main2))
+  import_lex27.l.object({
+    uri: import_lex27.l.string({ format: "at-uri" }),
+    record: import_lex27.l.ref((() => main2))
   })
 );
 
@@ -1271,42 +1398,42 @@ var validate_exports2 = {};
 __export(validate_exports2, {
   $defs: () => validate_defs_exports2,
   $lxm: () => $lxm22,
-  $nsid: () => $nsid26,
+  $nsid: () => $nsid28,
   $output: () => $output22,
   $params: () => $params22,
-  main: () => main26
+  main: () => main28
 });
 
 // src/lexicons/com/atiproto/repo/tip/validate.defs.ts
 var validate_defs_exports2 = {};
 __export(validate_defs_exports2, {
   $lxm: () => $lxm22,
-  $nsid: () => $nsid26,
+  $nsid: () => $nsid28,
   $output: () => $output22,
   $params: () => $params22,
-  main: () => main26
-});
-var import_lex26 = require("@atproto/lex");
-var $nsid26 = "com.atiproto.repo.tip.validate";
-var main26 = import_lex26.l.query(
-  $nsid26,
-  import_lex26.l.params({
-    sender: import_lex26.l.string({ format: "did" }),
-    tipUri: import_lex26.l.optional(import_lex26.l.string({ format: "at-uri" })),
-    recordUri: 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())
+  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_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()),
-    reason: import_lex26.l.optional(import_lex26.l.string())
+  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 = main26.nsid;
-var $params22 = main26.parameters;
-var $output22 = main26.output;
+var $lxm22 = main28.nsid;
+var $params22 = main28.parameters;
+var $output22 = main28.output;
 
 // src/lexicons/com/atiproto/subscription.ts
 var subscription_exports3 = {};
@@ -1441,6 +1568,7 @@ var create_default = {
           properties: {
             currency: {
               type: "string",
+              maxLength: 3,
               description: "ISO 4217 currency code"
             },
             redirectUrl: {
@@ -1562,10 +1690,13 @@ var list_default = {
           properties: {
             status: {
               type: "string",
-              description: "Filter: open, completed, expired, abandoned"
+              maxLength: 64,
+              enum: ["open", "completed", "expired", "abandoned"],
+              description: "Filter by cart status"
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor"
             },
             limit: {
@@ -1592,6 +1723,7 @@ var list_default = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           },
@@ -1814,6 +1946,7 @@ var cart_default = {
           },
           currency: {
             type: "string",
+            maxLength: 3,
             description: "ISO 4217 currency code"
           },
           total: {
@@ -1822,7 +1955,9 @@ var cart_default = {
           },
           status: {
             type: "string",
-            description: "Cart status: open, completed, expired, abandoned"
+            maxLength: 64,
+            enum: ["open", "completed", "expired", "abandoned"],
+            description: "Cart status"
           },
           createdAt: {
             type: "string",
@@ -1848,6 +1983,7 @@ var cart_default = {
       properties: {
         type: {
           type: "string",
+          maxLength: 128,
           description: "Item type: tip or subscription",
           enum: ["com.atiproto.tip", "com.atiproto.subscription"]
         },
@@ -1876,6 +2012,7 @@ var list_default2 = {
           properties: {
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor"
             },
             limit: {
@@ -1903,6 +2040,7 @@ var list_default2 = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           }
@@ -1982,10 +2120,23 @@ var create_default2 = {
             },
             currency: {
               description: "ISO 4217 currency code",
+              maxLength: 3,
               type: "string"
             },
             interval: {
-              description: "Billing interval: monthly or yearly",
+              description: "Billing interval",
+              maxLength: 64,
+              enum: ["monthly", "yearly"],
+              type: "string"
+            },
+            cartUri: {
+              description: "AT-URI of an existing cart to add this subscription to. If omitted, a new cart is created.",
+              format: "at-uri",
+              type: "string"
+            },
+            redirectUrl: {
+              description: "URL to redirect to after checkout completes",
+              format: "uri",
               type: "string"
             }
           },
@@ -2023,13 +2174,7 @@ var create_default2 = {
               type: "string"
             }
           },
-          required: [
-            "subscriptionUri",
-            "subscription",
-            "cartUri",
-            "cart",
-            "checkoutUrl"
-          ],
+          required: ["subscriptionUri", "subscription"],
           type: "object"
         }
       },
@@ -2102,6 +2247,7 @@ var list_default3 = {
           properties: {
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor"
             },
             limit: {
@@ -2129,6 +2275,7 @@ var list_default3 = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           }
@@ -2232,6 +2379,7 @@ var create_default3 = {
             },
             currency: {
               type: "string",
+              maxLength: 3,
               description: "ISO 4217 currency code"
             },
             cartUri: {
@@ -2257,7 +2405,7 @@ var create_default3 = {
         encoding: "application/json",
         schema: {
           type: "object",
-          required: ["tipUri", "tip", "cartUri", "cart", "checkoutUrl"],
+          required: ["tipUri", "tip"],
           properties: {
             tipUri: {
               type: "string",
@@ -2353,6 +2501,7 @@ var list_default4 = {
           properties: {
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor"
             },
             limit: {
@@ -2380,6 +2529,7 @@ var list_default4 = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           }
@@ -2539,6 +2689,7 @@ var search_default = {
           },
           cursor: {
             type: "string",
+            maxLength: 512,
             description: "Pagination cursor"
           },
           limit: {
@@ -2566,6 +2717,7 @@ var search_default = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           }
@@ -2639,10 +2791,12 @@ var validate_default = {
             },
             currency: {
               type: "string",
+              maxLength: 3,
               description: "Currency of the subscription"
             },
             reason: {
               type: "string",
+              maxLength: 1024,
               description: "If invalid, reason for rejection"
             }
           }
@@ -2670,6 +2824,7 @@ var search_default2 = {
           },
           cursor: {
             type: "string",
+            maxLength: 512,
             description: "Pagination cursor"
           },
           limit: {
@@ -2697,6 +2852,7 @@ var search_default2 = {
             },
             cursor: {
               type: "string",
+              maxLength: 512,
               description: "Pagination cursor for next page"
             }
           }
@@ -2775,10 +2931,12 @@ var validate_default2 = {
             },
             currency: {
               type: "string",
+              maxLength: 3,
               description: "Currency of the tips"
             },
             reason: {
               type: "string",
+              maxLength: 1024,
               description: "If invalid, reason for rejection"
             }
           }
@@ -2788,6 +2946,111 @@ var validate_default2 = {
   }
 };
 
+// src/schemas/authEnhanced.json
+var authEnhanced_default = {
+  lexicon: 1,
+  id: "com.atiproto.authEnhanced",
+  defs: {
+    main: {
+      type: "permission-set",
+      title: "Enhanced Access",
+      detail: "Full atiproto access. Extends general access with write access to the profile record and RPC access to all profile endpoints.",
+      permissions: [
+        {
+          type: "permission",
+          resource: "repo",
+          collection: [
+            "com.atiproto.cart",
+            "com.atiproto.subscription",
+            "com.atiproto.tip",
+            "com.atiproto.profile"
+          ]
+        },
+        {
+          type: "permission",
+          resource: "rpc",
+          inheritAud: true,
+          lxm: [
+            "com.atiproto.account.cart.clone",
+            "com.atiproto.account.cart.create",
+            "com.atiproto.account.cart.get",
+            "com.atiproto.account.cart.list",
+            "com.atiproto.account.cart.put",
+            "com.atiproto.account.profile.get",
+            "com.atiproto.account.profile.put",
+            "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.tip.create",
+            "com.atiproto.feed.tip.get",
+            "com.atiproto.feed.tip.list",
+            "com.atiproto.feed.tip.put",
+            "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"
+          ]
+        }
+      ]
+    }
+  }
+};
+
+// src/schemas/authGeneral.json
+var authGeneral_default = {
+  lexicon: 1,
+  id: "com.atiproto.authGeneral",
+  defs: {
+    main: {
+      type: "permission-set",
+      title: "General Access",
+      detail: "Write access to cart, subscription, and tip records, plus RPC access to payment, feed, and public profile lookup endpoints.",
+      permissions: [
+        {
+          type: "permission",
+          resource: "repo",
+          collection: [
+            "com.atiproto.cart",
+            "com.atiproto.subscription",
+            "com.atiproto.tip"
+          ]
+        },
+        {
+          type: "permission",
+          resource: "rpc",
+          inheritAud: true,
+          lxm: [
+            "com.atiproto.account.cart.clone",
+            "com.atiproto.account.cart.create",
+            "com.atiproto.account.cart.get",
+            "com.atiproto.account.cart.list",
+            "com.atiproto.account.cart.put",
+            "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.tip.create",
+            "com.atiproto.feed.tip.get",
+            "com.atiproto.feed.tip.list",
+            "com.atiproto.feed.tip.put",
+            "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"
+          ]
+        }
+      ]
+    }
+  }
+};
+
 // src/schemas/subscription.json
 var subscription_default = {
   defs: {
@@ -2808,14 +3071,19 @@ var subscription_default = {
           },
           currency: {
             description: "ISO 4217 currency code",
+            maxLength: 3,
             type: "string"
           },
           interval: {
-            description: "Billing interval: monthly or yearly",
+            description: "Billing interval",
+            maxLength: 64,
+            enum: ["monthly", "yearly"],
             type: "string"
           },
           status: {
-            description: "Subscription status: pending, active, past_due, cancelled, expired",
+            description: "Subscription status",
+            maxLength: 64,
+            enum: ["pending", "active", "past_due", "cancelled", "expired"],
             type: "string"
           },
           billingStartDate: {
@@ -2882,10 +3150,12 @@ var tip_default = {
           },
           currency: {
             description: "ISO 4217 currency code",
+            maxLength: 3,
             type: "string"
           },
           status: {
-            description: "Tip status: pending, authorized (payment held), completed, failed, refunded",
+            description: "Tip status",
+            maxLength: 64,
             type: "string",
             enum: ["pending", "authorized", "completed", "failed", "refunded"]
           },
@@ -2942,6 +3212,8 @@ var schemas = [
   validate_default,
   search_default2,
   validate_default2,
+  authEnhanced_default,
+  authGeneral_default,
   subscription_default,
   tip_default
 ];