@atiproto/lexicons 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2919 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lexicons/com.ts
+var com_exports = {};
+__export(com_exports, {
+  atiproto: () => atiproto_exports
+});
+
+// src/lexicons/com/atiproto.ts
+var atiproto_exports = {};
+__export(atiproto_exports, {
+  account: () => account_exports,
+  cart: () => cart_exports2,
+  feed: () => feed_exports,
+  profile: () => profile_exports2,
+  repo: () => repo_exports,
+  subscription: () => subscription_exports3,
+  tip: () => tip_exports3
+});
+
+// src/lexicons/com/atiproto/account.ts
+var account_exports = {};
+__export(account_exports, {
+  cart: () => cart_exports,
+  profile: () => profile_exports
+});
+
+// src/lexicons/com/atiproto/account/cart.ts
+var cart_exports = {};
+__export(cart_exports, {
+  clone: () => clone_exports,
+  create: () => create_exports,
+  get: () => get_exports,
+  list: () => list_exports,
+  put: () => put_exports
+});
+
+// src/lexicons/com/atiproto/account/cart/clone.ts
+var clone_exports = {};
+__export(clone_exports, {
+  $defs: () => clone_defs_exports,
+  $input: () => $input,
+  $lxm: () => $lxm,
+  $nsid: () => $nsid4,
+  $output: () => $output,
+  $params: () => $params,
+  main: () => main4
+});
+
+// src/lexicons/com/atiproto/account/cart/clone.defs.ts
+var clone_defs_exports = {};
+__export(clone_defs_exports, {
+  $input: () => $input,
+  $lxm: () => $lxm,
+  $nsid: () => $nsid4,
+  $output: () => $output,
+  $params: () => $params,
+  main: () => main4
+});
+import { l as l4 } from "@atproto/lex";
+
+// src/lexicons/com/atiproto/cart.defs.ts
+var cart_defs_exports = {};
+__export(cart_defs_exports, {
+  $assert: () => $assert,
+  $build: () => $build,
+  $cast: () => $cast,
+  $check: () => $check,
+  $ifMatches: () => $ifMatches,
+  $isTypeOf: () => $isTypeOf,
+  $matches: () => $matches,
+  $nsid: () => $nsid,
+  $parse: () => $parse,
+  $safeParse: () => $safeParse,
+  $safeValidate: () => $safeValidate,
+  $type: () => $type,
+  $validate: () => $validate,
+  cartItem: () => cartItem,
+  main: () => main
+});
+import { l } from "@atproto/lex";
+var $nsid = "com.atiproto.cart";
+var main = l.record(
+  "any",
+  $nsid,
+  l.object({
+    items: l.array(l.ref((() => cartItem))),
+    currency: l.string(),
+    total: l.integer(),
+    status: l.string(),
+    createdAt: l.string({ format: "datetime" }),
+    expiresAt: l.string({ format: "datetime" }),
+    completedAt: l.optional(l.string({ format: "datetime" }))
+  })
+);
+var $isTypeOf = /* @__PURE__ */ main.isTypeOf.bind(main);
+var $build = /* @__PURE__ */ main.build.bind(main);
+var $type = main.$type;
+var $assert = /* @__PURE__ */ main.assert.bind(main);
+var $check = /* @__PURE__ */ main.check.bind(main);
+var $cast = /* @__PURE__ */ main.cast.bind(main);
+var $ifMatches = /* @__PURE__ */ main.ifMatches.bind(main);
+var $matches = /* @__PURE__ */ main.matches.bind(main);
+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 cartItem = l.typedObject(
+  $nsid,
+  "cartItem",
+  l.object({
+    type: l.enum(["com.atiproto.tip", "com.atiproto.subscription"]),
+    recordUri: l.string({ format: "at-uri" })
+  })
+);
+
+// src/lexicons/com/atiproto/tip.defs.ts
+var tip_defs_exports = {};
+__export(tip_defs_exports, {
+  $assert: () => $assert2,
+  $build: () => $build2,
+  $cast: () => $cast2,
+  $check: () => $check2,
+  $ifMatches: () => $ifMatches2,
+  $isTypeOf: () => $isTypeOf2,
+  $matches: () => $matches2,
+  $nsid: () => $nsid2,
+  $parse: () => $parse2,
+  $safeParse: () => $safeParse2,
+  $safeValidate: () => $safeValidate2,
+  $type: () => $type2,
+  $validate: () => $validate2,
+  main: () => main2
+});
+import { l as l2 } from "@atproto/lex";
+var $nsid2 = "com.atiproto.tip";
+var main2 = l2.record(
+  "any",
+  $nsid2,
+  l2.object({
+    subject: l2.string({ format: "did" }),
+    recordUri: l2.optional(l2.string({ format: "at-uri" })),
+    amount: l2.integer({ minimum: 0 }),
+    currency: l2.string(),
+    status: l2.enum([
+      "pending",
+      "authorized",
+      "completed",
+      "failed",
+      "refunded"
+    ]),
+    message: l2.optional(l2.string({ maxGraphemes: 500, maxLength: 5e3 })),
+    createdAt: l2.string({ format: "datetime" }),
+    completedAt: l2.optional(l2.string({ format: "datetime" }))
+  })
+);
+var $isTypeOf2 = /* @__PURE__ */ main2.isTypeOf.bind(main2);
+var $build2 = /* @__PURE__ */ main2.build.bind(main2);
+var $type2 = main2.$type;
+var $assert2 = /* @__PURE__ */ main2.assert.bind(main2);
+var $check2 = /* @__PURE__ */ main2.check.bind(main2);
+var $cast2 = /* @__PURE__ */ main2.cast.bind(main2);
+var $ifMatches2 = /* @__PURE__ */ main2.ifMatches.bind(main2);
+var $matches2 = /* @__PURE__ */ main2.matches.bind(main2);
+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);
+
+// src/lexicons/com/atiproto/subscription.defs.ts
+var subscription_defs_exports = {};
+__export(subscription_defs_exports, {
+  $assert: () => $assert3,
+  $build: () => $build3,
+  $cast: () => $cast3,
+  $check: () => $check3,
+  $ifMatches: () => $ifMatches3,
+  $isTypeOf: () => $isTypeOf3,
+  $matches: () => $matches3,
+  $nsid: () => $nsid3,
+  $parse: () => $parse3,
+  $safeParse: () => $safeParse3,
+  $safeValidate: () => $safeValidate3,
+  $type: () => $type3,
+  $validate: () => $validate3,
+  main: () => main3
+});
+import { l as l3 } from "@atproto/lex";
+var $nsid3 = "com.atiproto.subscription";
+var main3 = l3.record(
+  "any",
+  $nsid3,
+  l3.object({
+    subject: l3.string({ format: "did" }),
+    amount: l3.integer({ minimum: 0 }),
+    currency: l3.string(),
+    interval: l3.string(),
+    status: l3.string(),
+    billingStartDate: l3.string({ format: "datetime" }),
+    cancelledAt: l3.optional(l3.string({ format: "datetime" })),
+    accessUntil: l3.optional(l3.string({ format: "datetime" })),
+    createdAt: l3.string({ format: "datetime" })
+  })
+);
+var $isTypeOf3 = /* @__PURE__ */ main3.isTypeOf.bind(main3);
+var $build3 = /* @__PURE__ */ main3.build.bind(main3);
+var $type3 = main3.$type;
+var $assert3 = /* @__PURE__ */ main3.assert.bind(main3);
+var $check3 = /* @__PURE__ */ main3.check.bind(main3);
+var $cast3 = /* @__PURE__ */ main3.cast.bind(main3);
+var $ifMatches3 = /* @__PURE__ */ main3.ifMatches.bind(main3);
+var $matches3 = /* @__PURE__ */ main3.matches.bind(main3);
+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);
+
+// src/lexicons/com/atiproto/account/cart/clone.defs.ts
+var $nsid4 = "com.atiproto.account.cart.clone";
+var main4 = l4.procedure(
+  $nsid4,
+  l4.params(),
+  l4.jsonPayload({
+    uri: l4.string({ format: "at-uri" }),
+    redirectUrl: l4.optional(l4.string({ format: "uri" }))
+  }),
+  l4.jsonPayload({
+    cart: l4.ref((() => main)),
+    cartUri: l4.string({ format: "at-uri" }),
+    checkoutUrl: l4.string({ format: "uri" }),
+    tips: l4.array(l4.ref((() => main2))),
+    subscriptions: l4.array(
+      l4.ref(
+        (() => main3)
+      )
+    )
+  })
+);
+var $lxm = main4.nsid;
+var $params = main4.parameters;
+var $input = main4.input;
+var $output = main4.output;
+
+// src/lexicons/com/atiproto/account/cart/create.ts
+var create_exports = {};
+__export(create_exports, {
+  $defs: () => create_defs_exports,
+  $input: () => $input2,
+  $lxm: () => $lxm2,
+  $nsid: () => $nsid5,
+  $output: () => $output2,
+  $params: () => $params2,
+  main: () => main5
+});
+
+// src/lexicons/com/atiproto/account/cart/create.defs.ts
+var create_defs_exports = {};
+__export(create_defs_exports, {
+  $input: () => $input2,
+  $lxm: () => $lxm2,
+  $nsid: () => $nsid5,
+  $output: () => $output2,
+  $params: () => $params2,
+  main: () => main5
+});
+import { l as l5 } from "@atproto/lex";
+var $nsid5 = "com.atiproto.account.cart.create";
+var main5 = l5.procedure(
+  $nsid5,
+  l5.params(),
+  l5.jsonPayload({
+    currency: l5.string(),
+    redirectUrl: l5.optional(l5.string({ format: "uri" }))
+  }),
+  l5.jsonPayload({
+    cart: l5.ref((() => main)),
+    cartUri: l5.string({ format: "at-uri" }),
+    checkoutUrl: l5.string({ format: "uri" })
+  })
+);
+var $lxm2 = main5.nsid;
+var $params2 = main5.parameters;
+var $input2 = main5.input;
+var $output2 = main5.output;
+
+// src/lexicons/com/atiproto/account/cart/get.ts
+var get_exports = {};
+__export(get_exports, {
+  $defs: () => get_defs_exports,
+  $lxm: () => $lxm3,
+  $nsid: () => $nsid6,
+  $output: () => $output3,
+  $params: () => $params3,
+  main: () => main6
+});
+
+// src/lexicons/com/atiproto/account/cart/get.defs.ts
+var get_defs_exports = {};
+__export(get_defs_exports, {
+  $lxm: () => $lxm3,
+  $nsid: () => $nsid6,
+  $output: () => $output3,
+  $params: () => $params3,
+  main: () => main6
+});
+import { l as l6 } from "@atproto/lex";
+var $nsid6 = "com.atiproto.account.cart.get";
+var main6 = l6.query(
+  $nsid6,
+  l6.params({ uri: l6.string({ format: "at-uri" }) }),
+  l6.jsonPayload({
+    uri: l6.string({ format: "at-uri" }),
+    cid: l6.optional(l6.string({ format: "cid" })),
+    cart: l6.ref((() => main)),
+    checkoutUrl: l6.optional(l6.string({ format: "uri" })),
+    tips: l6.array(l6.ref((() => main2))),
+    subscriptions: l6.array(
+      l6.ref(
+        (() => main3)
+      )
+    )
+  })
+);
+var $lxm3 = main6.nsid;
+var $params3 = main6.parameters;
+var $output3 = main6.output;
+
+// src/lexicons/com/atiproto/account/cart/list.ts
+var list_exports = {};
+__export(list_exports, {
+  $defs: () => list_defs_exports,
+  $lxm: () => $lxm4,
+  $nsid: () => $nsid7,
+  $output: () => $output4,
+  $params: () => $params4,
+  cartResponse: () => cartResponse,
+  main: () => main7
+});
+
+// src/lexicons/com/atiproto/account/cart/list.defs.ts
+var list_defs_exports = {};
+__export(list_defs_exports, {
+  $lxm: () => $lxm4,
+  $nsid: () => $nsid7,
+  $output: () => $output4,
+  $params: () => $params4,
+  cartResponse: () => cartResponse,
+  main: () => main7
+});
+import { l as l7 } from "@atproto/lex";
+var $nsid7 = "com.atiproto.account.cart.list";
+var main7 = l7.query(
+  $nsid7,
+  l7.params(),
+  l7.jsonPayload({
+    carts: l7.array(l7.ref((() => cartResponse))),
+    cursor: l7.optional(l7.string())
+  })
+);
+var $lxm4 = main7.nsid;
+var $params4 = main7.parameters;
+var $output4 = main7.output;
+var cartResponse = l7.typedObject(
+  $nsid7,
+  "cartResponse",
+  l7.object({
+    uri: l7.string({ format: "at-uri" }),
+    cid: l7.string({ format: "cid" }),
+    record: l7.ref((() => main))
+  })
+);
+
+// src/lexicons/com/atiproto/account/cart/put.ts
+var put_exports = {};
+__export(put_exports, {
+  $defs: () => put_defs_exports,
+  $input: () => $input3,
+  $lxm: () => $lxm5,
+  $nsid: () => $nsid8,
+  $output: () => $output5,
+  $params: () => $params5,
+  main: () => main8
+});
+
+// src/lexicons/com/atiproto/account/cart/put.defs.ts
+var put_defs_exports = {};
+__export(put_defs_exports, {
+  $input: () => $input3,
+  $lxm: () => $lxm5,
+  $nsid: () => $nsid8,
+  $output: () => $output5,
+  $params: () => $params5,
+  main: () => main8
+});
+import { l as l8 } from "@atproto/lex";
+var $nsid8 = "com.atiproto.account.cart.put";
+var main8 = l8.procedure(
+  $nsid8,
+  l8.params(),
+  l8.jsonPayload({
+    uri: l8.string({ format: "at-uri" }),
+    record: l8.ref((() => main))
+  }),
+  l8.jsonPayload({
+    uri: l8.string({ format: "at-uri" }),
+    cid: l8.string({ format: "cid" })
+  })
+);
+var $lxm5 = main8.nsid;
+var $params5 = main8.parameters;
+var $input3 = main8.input;
+var $output5 = main8.output;
+
+// src/lexicons/com/atiproto/account/profile.ts
+var profile_exports = {};
+__export(profile_exports, {
+  get: () => get_exports2,
+  put: () => put_exports2
+});
+
+// src/lexicons/com/atiproto/account/profile/get.ts
+var get_exports2 = {};
+__export(get_exports2, {
+  $defs: () => get_defs_exports2,
+  $lxm: () => $lxm6,
+  $nsid: () => $nsid10,
+  $output: () => $output6,
+  $params: () => $params6,
+  main: () => main10
+});
+
+// src/lexicons/com/atiproto/account/profile/get.defs.ts
+var get_defs_exports2 = {};
+__export(get_defs_exports2, {
+  $lxm: () => $lxm6,
+  $nsid: () => $nsid10,
+  $output: () => $output6,
+  $params: () => $params6,
+  main: () => main10
+});
+import { l as l10 } from "@atproto/lex";
+
+// src/lexicons/com/atiproto/profile.defs.ts
+var profile_defs_exports = {};
+__export(profile_defs_exports, {
+  $assert: () => $assert4,
+  $build: () => $build4,
+  $cast: () => $cast4,
+  $check: () => $check4,
+  $ifMatches: () => $ifMatches4,
+  $isTypeOf: () => $isTypeOf4,
+  $matches: () => $matches4,
+  $nsid: () => $nsid9,
+  $parse: () => $parse4,
+  $safeParse: () => $safeParse4,
+  $safeValidate: () => $safeValidate4,
+  $type: () => $type4,
+  $validate: () => $validate4,
+  main: () => main9
+});
+import { l as l9 } from "@atproto/lex";
+var $nsid9 = "com.atiproto.profile";
+var main9 = l9.record(
+  "literal:self",
+  $nsid9,
+  l9.object({
+    acceptsTips: l9.optional(l9.boolean()),
+    acceptsSubscriptions: l9.optional(l9.boolean()),
+    disableReceiptNotifications: l9.optional(l9.boolean()),
+    createdAt: l9.string({ format: "datetime" }),
+    updatedAt: l9.optional(l9.string({ format: "datetime" }))
+  })
+);
+var $isTypeOf4 = /* @__PURE__ */ main9.isTypeOf.bind(main9);
+var $build4 = /* @__PURE__ */ main9.build.bind(main9);
+var $type4 = main9.$type;
+var $assert4 = /* @__PURE__ */ main9.assert.bind(main9);
+var $check4 = /* @__PURE__ */ main9.check.bind(main9);
+var $cast4 = /* @__PURE__ */ main9.cast.bind(main9);
+var $ifMatches4 = /* @__PURE__ */ main9.ifMatches.bind(main9);
+var $matches4 = /* @__PURE__ */ main9.matches.bind(main9);
+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);
+
+// src/lexicons/com/atiproto/account/profile/get.defs.ts
+var $nsid10 = "com.atiproto.account.profile.get";
+var main10 = l10.query(
+  $nsid10,
+  l10.params(),
+  l10.jsonPayload({
+    uri: l10.optional(l10.string({ format: "at-uri" })),
+    cid: l10.optional(l10.string({ format: "cid" })),
+    profile: l10.ref((() => main9)),
+    hasProfile: l10.boolean(),
+    readyForPayment: l10.boolean()
+  })
+);
+var $lxm6 = main10.nsid;
+var $params6 = main10.parameters;
+var $output6 = main10.output;
+
+// src/lexicons/com/atiproto/account/profile/put.ts
+var put_exports2 = {};
+__export(put_exports2, {
+  $defs: () => put_defs_exports2,
+  $input: () => $input4,
+  $lxm: () => $lxm7,
+  $nsid: () => $nsid11,
+  $output: () => $output7,
+  $params: () => $params7,
+  main: () => main11
+});
+
+// src/lexicons/com/atiproto/account/profile/put.defs.ts
+var put_defs_exports2 = {};
+__export(put_defs_exports2, {
+  $input: () => $input4,
+  $lxm: () => $lxm7,
+  $nsid: () => $nsid11,
+  $output: () => $output7,
+  $params: () => $params7,
+  main: () => main11
+});
+import { l as l11 } from "@atproto/lex";
+var $nsid11 = "com.atiproto.account.profile.put";
+var main11 = l11.procedure(
+  $nsid11,
+  l11.params(),
+  l11.jsonPayload({
+    acceptsTips: l11.optional(l11.boolean()),
+    acceptsSubscriptions: l11.optional(l11.boolean()),
+    disableReceiptNotifications: l11.optional(l11.boolean())
+  }),
+  l11.jsonPayload({
+    uri: l11.string({ format: "at-uri" }),
+    cid: l11.string({ format: "cid" }),
+    profile: l11.ref((() => main9)),
+    hasProfile: l11.boolean(),
+    readyForPayment: l11.boolean()
+  })
+);
+var $lxm7 = main11.nsid;
+var $params7 = main11.parameters;
+var $input4 = main11.input;
+var $output7 = main11.output;
+
+// src/lexicons/com/atiproto/cart.ts
+var cart_exports2 = {};
+__export(cart_exports2, {
+  $assert: () => $assert,
+  $build: () => $build,
+  $cast: () => $cast,
+  $check: () => $check,
+  $defs: () => cart_defs_exports,
+  $ifMatches: () => $ifMatches,
+  $isTypeOf: () => $isTypeOf,
+  $matches: () => $matches,
+  $nsid: () => $nsid,
+  $parse: () => $parse,
+  $safeParse: () => $safeParse,
+  $safeValidate: () => $safeValidate,
+  $type: () => $type,
+  $validate: () => $validate,
+  cartItem: () => cartItem,
+  main: () => main
+});
+
+// src/lexicons/com/atiproto/feed.ts
+var feed_exports = {};
+__export(feed_exports, {
+  list: () => list_exports2,
+  subscription: () => subscription_exports,
+  tip: () => tip_exports
+});
+
+// src/lexicons/com/atiproto/feed/list.ts
+var list_exports2 = {};
+__export(list_exports2, {
+  $defs: () => list_defs_exports2,
+  $lxm: () => $lxm8,
+  $nsid: () => $nsid12,
+  $output: () => $output8,
+  $params: () => $params8,
+  main: () => main12
+});
+
+// src/lexicons/com/atiproto/feed/list.defs.ts
+var list_defs_exports2 = {};
+__export(list_defs_exports2, {
+  $lxm: () => $lxm8,
+  $nsid: () => $nsid12,
+  $output: () => $output8,
+  $params: () => $params8,
+  main: () => main12
+});
+import { l as l12 } from "@atproto/lex";
+var $nsid12 = "com.atiproto.feed.list";
+var main12 = l12.query(
+  $nsid12,
+  l12.params(),
+  l12.jsonPayload({
+    items: l12.array(
+      l12.typedUnion(
+        [
+          l12.typedRef((() => main2)),
+          l12.typedRef(
+            (() => main3)
+          )
+        ],
+        false
+      )
+    ),
+    cursor: l12.optional(l12.string())
+  })
+);
+var $lxm8 = main12.nsid;
+var $params8 = main12.parameters;
+var $output8 = main12.output;
+
+// src/lexicons/com/atiproto/feed/subscription.ts
+var subscription_exports = {};
+__export(subscription_exports, {
+  cancel: () => cancel_exports,
+  create: () => create_exports2,
+  get: () => get_exports3,
+  list: () => list_exports3,
+  put: () => put_exports3
+});
+
+// src/lexicons/com/atiproto/feed/subscription/cancel.ts
+var cancel_exports = {};
+__export(cancel_exports, {
+  $defs: () => cancel_defs_exports,
+  $input: () => $input5,
+  $lxm: () => $lxm9,
+  $nsid: () => $nsid13,
+  $output: () => $output9,
+  $params: () => $params9,
+  main: () => main13
+});
+
+// src/lexicons/com/atiproto/feed/subscription/cancel.defs.ts
+var cancel_defs_exports = {};
+__export(cancel_defs_exports, {
+  $input: () => $input5,
+  $lxm: () => $lxm9,
+  $nsid: () => $nsid13,
+  $output: () => $output9,
+  $params: () => $params9,
+  main: () => main13
+});
+import { l as l13 } from "@atproto/lex";
+var $nsid13 = "com.atiproto.feed.subscription.cancel";
+var main13 = l13.procedure(
+  $nsid13,
+  l13.params(),
+  l13.jsonPayload({ subscriptionUri: l13.string({ format: "at-uri" }) }),
+  l13.jsonPayload({
+    subscriptionUri: l13.string({ format: "at-uri" }),
+    subscription: l13.ref(
+      (() => main3)
+    ),
+    accessUntil: l13.string({ format: "datetime" })
+  })
+);
+var $lxm9 = main13.nsid;
+var $params9 = main13.parameters;
+var $input5 = main13.input;
+var $output9 = main13.output;
+
+// src/lexicons/com/atiproto/feed/subscription/create.ts
+var create_exports2 = {};
+__export(create_exports2, {
+  $defs: () => create_defs_exports2,
+  $input: () => $input6,
+  $lxm: () => $lxm10,
+  $nsid: () => $nsid14,
+  $output: () => $output10,
+  $params: () => $params10,
+  main: () => main14
+});
+
+// src/lexicons/com/atiproto/feed/subscription/create.defs.ts
+var create_defs_exports2 = {};
+__export(create_defs_exports2, {
+  $input: () => $input6,
+  $lxm: () => $lxm10,
+  $nsid: () => $nsid14,
+  $output: () => $output10,
+  $params: () => $params10,
+  main: () => main14
+});
+import { l as l14 } from "@atproto/lex";
+var $nsid14 = "com.atiproto.feed.subscription.create";
+var main14 = l14.procedure(
+  $nsid14,
+  l14.params(),
+  l14.jsonPayload({
+    subject: l14.string({ format: "did" }),
+    amount: l14.optional(l14.integer()),
+    currency: l14.string(),
+    interval: l14.string()
+  }),
+  l14.jsonPayload({
+    subscriptionUri: l14.string({ format: "at-uri" }),
+    subscription: l14.ref(
+      (() => main3)
+    ),
+    cartUri: l14.string({ format: "at-uri" }),
+    cart: l14.ref((() => main)),
+    checkoutUrl: l14.string({ format: "uri" })
+  })
+);
+var $lxm10 = main14.nsid;
+var $params10 = main14.parameters;
+var $input6 = main14.input;
+var $output10 = main14.output;
+
+// src/lexicons/com/atiproto/feed/subscription/get.ts
+var get_exports3 = {};
+__export(get_exports3, {
+  $defs: () => get_defs_exports3,
+  $lxm: () => $lxm11,
+  $nsid: () => $nsid15,
+  $output: () => $output11,
+  $params: () => $params11,
+  main: () => main15
+});
+
+// src/lexicons/com/atiproto/feed/subscription/get.defs.ts
+var get_defs_exports3 = {};
+__export(get_defs_exports3, {
+  $lxm: () => $lxm11,
+  $nsid: () => $nsid15,
+  $output: () => $output11,
+  $params: () => $params11,
+  main: () => main15
+});
+import { l as l15 } from "@atproto/lex";
+var $nsid15 = "com.atiproto.feed.subscription.get";
+var main15 = l15.query(
+  $nsid15,
+  l15.params({ uri: l15.string({ format: "at-uri" }) }),
+  l15.jsonPayload({
+    uri: l15.string({ format: "at-uri" }),
+    cid: l15.string({ format: "cid" }),
+    record: l15.ref(
+      (() => main3)
+    )
+  })
+);
+var $lxm11 = main15.nsid;
+var $params11 = main15.parameters;
+var $output11 = main15.output;
+
+// src/lexicons/com/atiproto/feed/subscription/list.ts
+var list_exports3 = {};
+__export(list_exports3, {
+  $defs: () => list_defs_exports3,
+  $lxm: () => $lxm12,
+  $nsid: () => $nsid16,
+  $output: () => $output12,
+  $params: () => $params12,
+  main: () => main16,
+  subscriptionResponse: () => subscriptionResponse
+});
+
+// src/lexicons/com/atiproto/feed/subscription/list.defs.ts
+var list_defs_exports3 = {};
+__export(list_defs_exports3, {
+  $lxm: () => $lxm12,
+  $nsid: () => $nsid16,
+  $output: () => $output12,
+  $params: () => $params12,
+  main: () => main16,
+  subscriptionResponse: () => subscriptionResponse
+});
+import { l as l16 } from "@atproto/lex";
+var $nsid16 = "com.atiproto.feed.subscription.list";
+var main16 = l16.query(
+  $nsid16,
+  l16.params(),
+  l16.jsonPayload({
+    subscriptions: l16.array(
+      l16.ref((() => subscriptionResponse))
+    ),
+    cursor: l16.optional(l16.string())
+  })
+);
+var $lxm12 = main16.nsid;
+var $params12 = main16.parameters;
+var $output12 = main16.output;
+var subscriptionResponse = l16.typedObject(
+  $nsid16,
+  "subscriptionResponse",
+  l16.object({
+    uri: l16.string({ format: "at-uri" }),
+    record: l16.ref(
+      (() => main3)
+    )
+  })
+);
+
+// src/lexicons/com/atiproto/feed/subscription/put.ts
+var put_exports3 = {};
+__export(put_exports3, {
+  $defs: () => put_defs_exports3,
+  $input: () => $input7,
+  $lxm: () => $lxm13,
+  $nsid: () => $nsid17,
+  $output: () => $output13,
+  $params: () => $params13,
+  main: () => main17
+});
+
+// src/lexicons/com/atiproto/feed/subscription/put.defs.ts
+var put_defs_exports3 = {};
+__export(put_defs_exports3, {
+  $input: () => $input7,
+  $lxm: () => $lxm13,
+  $nsid: () => $nsid17,
+  $output: () => $output13,
+  $params: () => $params13,
+  main: () => main17
+});
+import { l as l17 } from "@atproto/lex";
+var $nsid17 = "com.atiproto.feed.subscription.put";
+var main17 = l17.procedure(
+  $nsid17,
+  l17.params(),
+  l17.jsonPayload({
+    uri: l17.string({ format: "at-uri" }),
+    record: l17.ref(
+      (() => main3)
+    )
+  }),
+  l17.jsonPayload({
+    uri: l17.string({ format: "at-uri" }),
+    cid: l17.string({ format: "cid" })
+  })
+);
+var $lxm13 = main17.nsid;
+var $params13 = main17.parameters;
+var $input7 = main17.input;
+var $output13 = main17.output;
+
+// src/lexicons/com/atiproto/feed/tip.ts
+var tip_exports = {};
+__export(tip_exports, {
+  create: () => create_exports3,
+  get: () => get_exports4,
+  list: () => list_exports4,
+  put: () => put_exports4
+});
+
+// src/lexicons/com/atiproto/feed/tip/create.ts
+var create_exports3 = {};
+__export(create_exports3, {
+  $defs: () => create_defs_exports3,
+  $input: () => $input8,
+  $lxm: () => $lxm14,
+  $nsid: () => $nsid18,
+  $output: () => $output14,
+  $params: () => $params14,
+  main: () => main18
+});
+
+// src/lexicons/com/atiproto/feed/tip/create.defs.ts
+var create_defs_exports3 = {};
+__export(create_defs_exports3, {
+  $input: () => $input8,
+  $lxm: () => $lxm14,
+  $nsid: () => $nsid18,
+  $output: () => $output14,
+  $params: () => $params14,
+  main: () => main18
+});
+import { l as l18 } from "@atproto/lex";
+var $nsid18 = "com.atiproto.feed.tip.create";
+var main18 = l18.procedure(
+  $nsid18,
+  l18.params(),
+  l18.jsonPayload({
+    subject: l18.string({ format: "did" }),
+    recordUri: l18.optional(l18.string({ format: "at-uri" })),
+    amount: l18.integer(),
+    currency: l18.string(),
+    cartUri: l18.optional(l18.string({ format: "at-uri" })),
+    redirectUrl: l18.optional(l18.string({ format: "uri" })),
+    message: l18.optional(l18.string({ maxGraphemes: 500, maxLength: 5e3 }))
+  }),
+  l18.jsonPayload({
+    tipUri: l18.string({ format: "at-uri" }),
+    tip: l18.ref((() => main2)),
+    cartUri: l18.string({ format: "at-uri" }),
+    cart: l18.ref((() => main)),
+    checkoutUrl: l18.string({ format: "uri" })
+  })
+);
+var $lxm14 = main18.nsid;
+var $params14 = main18.parameters;
+var $input8 = main18.input;
+var $output14 = main18.output;
+
+// src/lexicons/com/atiproto/feed/tip/get.ts
+var get_exports4 = {};
+__export(get_exports4, {
+  $defs: () => get_defs_exports4,
+  $lxm: () => $lxm15,
+  $nsid: () => $nsid19,
+  $output: () => $output15,
+  $params: () => $params15,
+  main: () => main19
+});
+
+// src/lexicons/com/atiproto/feed/tip/get.defs.ts
+var get_defs_exports4 = {};
+__export(get_defs_exports4, {
+  $lxm: () => $lxm15,
+  $nsid: () => $nsid19,
+  $output: () => $output15,
+  $params: () => $params15,
+  main: () => main19
+});
+import { l as l19 } from "@atproto/lex";
+var $nsid19 = "com.atiproto.feed.tip.get";
+var main19 = l19.query(
+  $nsid19,
+  l19.params({ uri: l19.string({ format: "at-uri" }) }),
+  l19.jsonPayload({
+    uri: l19.string({ format: "at-uri" }),
+    cid: l19.string({ format: "cid" }),
+    value: l19.ref((() => main2))
+  })
+);
+var $lxm15 = main19.nsid;
+var $params15 = main19.parameters;
+var $output15 = main19.output;
+
+// src/lexicons/com/atiproto/feed/tip/list.ts
+var list_exports4 = {};
+__export(list_exports4, {
+  $defs: () => list_defs_exports4,
+  $lxm: () => $lxm16,
+  $nsid: () => $nsid20,
+  $output: () => $output16,
+  $params: () => $params16,
+  main: () => main20
+});
+
+// src/lexicons/com/atiproto/feed/tip/list.defs.ts
+var list_defs_exports4 = {};
+__export(list_defs_exports4, {
+  $lxm: () => $lxm16,
+  $nsid: () => $nsid20,
+  $output: () => $output16,
+  $params: () => $params16,
+  main: () => main20
+});
+import { l as l20 } from "@atproto/lex";
+var $nsid20 = "com.atiproto.feed.tip.list";
+var main20 = l20.query(
+  $nsid20,
+  l20.params(),
+  l20.jsonPayload({
+    records: l20.array(l20.ref((() => main2))),
+    cursor: l20.optional(l20.string())
+  })
+);
+var $lxm16 = main20.nsid;
+var $params16 = main20.parameters;
+var $output16 = main20.output;
+
+// src/lexicons/com/atiproto/feed/tip/put.ts
+var put_exports4 = {};
+__export(put_exports4, {
+  $defs: () => put_defs_exports4,
+  $input: () => $input9,
+  $lxm: () => $lxm17,
+  $nsid: () => $nsid21,
+  $output: () => $output17,
+  $params: () => $params17,
+  main: () => main21
+});
+
+// src/lexicons/com/atiproto/feed/tip/put.defs.ts
+var put_defs_exports4 = {};
+__export(put_defs_exports4, {
+  $input: () => $input9,
+  $lxm: () => $lxm17,
+  $nsid: () => $nsid21,
+  $output: () => $output17,
+  $params: () => $params17,
+  main: () => main21
+});
+import { l as l21 } from "@atproto/lex";
+var $nsid21 = "com.atiproto.feed.tip.put";
+var main21 = l21.procedure(
+  $nsid21,
+  l21.params(),
+  l21.jsonPayload({
+    uri: l21.string({ format: "at-uri" }),
+    record: l21.ref((() => main2))
+  }),
+  l21.jsonPayload({
+    uri: l21.string({ format: "at-uri" }),
+    cid: l21.string({ format: "cid" })
+  })
+);
+var $lxm17 = main21.nsid;
+var $params17 = main21.parameters;
+var $input9 = main21.input;
+var $output17 = main21.output;
+
+// src/lexicons/com/atiproto/profile.ts
+var profile_exports2 = {};
+__export(profile_exports2, {
+  $assert: () => $assert4,
+  $build: () => $build4,
+  $cast: () => $cast4,
+  $check: () => $check4,
+  $defs: () => profile_defs_exports,
+  $ifMatches: () => $ifMatches4,
+  $isTypeOf: () => $isTypeOf4,
+  $matches: () => $matches4,
+  $nsid: () => $nsid9,
+  $parse: () => $parse4,
+  $safeParse: () => $safeParse4,
+  $safeValidate: () => $safeValidate4,
+  $type: () => $type4,
+  $validate: () => $validate4,
+  main: () => main9
+});
+
+// src/lexicons/com/atiproto/repo.ts
+var repo_exports = {};
+__export(repo_exports, {
+  profile: () => profile_exports3,
+  subscription: () => subscription_exports2,
+  tip: () => tip_exports2
+});
+
+// src/lexicons/com/atiproto/repo/profile.ts
+var profile_exports3 = {};
+__export(profile_exports3, {
+  get: () => get_exports5
+});
+
+// src/lexicons/com/atiproto/repo/profile/get.ts
+var get_exports5 = {};
+__export(get_exports5, {
+  $defs: () => get_defs_exports5,
+  $lxm: () => $lxm18,
+  $nsid: () => $nsid22,
+  $output: () => $output18,
+  $params: () => $params18,
+  main: () => main22
+});
+
+// src/lexicons/com/atiproto/repo/profile/get.defs.ts
+var get_defs_exports5 = {};
+__export(get_defs_exports5, {
+  $lxm: () => $lxm18,
+  $nsid: () => $nsid22,
+  $output: () => $output18,
+  $params: () => $params18,
+  main: () => main22
+});
+import { l as l22 } from "@atproto/lex";
+var $nsid22 = "com.atiproto.repo.profile.get";
+var main22 = l22.query(
+  $nsid22,
+  l22.params({ did: l22.string({ format: "did" }) }),
+  l22.jsonPayload({
+    did: l22.string({ format: "did" }),
+    profile: l22.ref((() => main9))
+  })
+);
+var $lxm18 = main22.nsid;
+var $params18 = main22.parameters;
+var $output18 = main22.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: () => $nsid23,
+  $output: () => $output19,
+  $params: () => $params19,
+  main: () => main23,
+  subscriptionResponse: () => subscriptionResponse2
+});
+
+// src/lexicons/com/atiproto/repo/subscription/search.defs.ts
+var search_defs_exports = {};
+__export(search_defs_exports, {
+  $lxm: () => $lxm19,
+  $nsid: () => $nsid23,
+  $output: () => $output19,
+  $params: () => $params19,
+  main: () => main23,
+  subscriptionResponse: () => subscriptionResponse2
+});
+import { l as l23 } from "@atproto/lex";
+var $nsid23 = "com.atiproto.repo.subscription.search";
+var main23 = l23.query(
+  $nsid23,
+  l23.params({
+    subject: l23.string({ format: "did" }),
+    cursor: l23.optional(l23.string()),
+    limit: l23.optional(
+      l23.withDefault(l23.integer({ minimum: 1, maximum: 100 }), 50)
+    )
+  }),
+  l23.jsonPayload({
+    subscriptions: l23.array(
+      l23.ref((() => subscriptionResponse2))
+    ),
+    cursor: l23.optional(l23.string())
+  })
+);
+var $lxm19 = main23.nsid;
+var $params19 = main23.parameters;
+var $output19 = main23.output;
+var subscriptionResponse2 = l23.typedObject(
+  $nsid23,
+  "subscriptionResponse",
+  l23.object({
+    uri: l23.string({ format: "at-uri" }),
+    record: l23.ref(
+      (() => main3)
+    )
+  })
+);
+
+// src/lexicons/com/atiproto/repo/subscription/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  $defs: () => validate_defs_exports,
+  $lxm: () => $lxm20,
+  $nsid: () => $nsid24,
+  $output: () => $output20,
+  $params: () => $params20,
+  main: () => main24
+});
+
+// src/lexicons/com/atiproto/repo/subscription/validate.defs.ts
+var validate_defs_exports = {};
+__export(validate_defs_exports, {
+  $lxm: () => $lxm20,
+  $nsid: () => $nsid24,
+  $output: () => $output20,
+  $params: () => $params20,
+  main: () => main24
+});
+import { l as l24 } from "@atproto/lex";
+var $nsid24 = "com.atiproto.repo.subscription.validate";
+var main24 = l24.query(
+  $nsid24,
+  l24.params({
+    sender: l24.string({ format: "did" }),
+    subject: l24.string({ format: "did" }),
+    amount: l24.optional(l24.integer())
+  }),
+  l24.jsonPayload({
+    valid: l24.boolean(),
+    amount: l24.optional(l24.integer()),
+    currency: l24.optional(l24.string()),
+    reason: l24.optional(l24.string())
+  })
+);
+var $lxm20 = main24.nsid;
+var $params20 = main24.parameters;
+var $output20 = main24.output;
+
+// src/lexicons/com/atiproto/repo/tip.ts
+var tip_exports2 = {};
+__export(tip_exports2, {
+  search: () => search_exports2,
+  validate: () => validate_exports2
+});
+
+// src/lexicons/com/atiproto/repo/tip/search.ts
+var search_exports2 = {};
+__export(search_exports2, {
+  $defs: () => search_defs_exports2,
+  $lxm: () => $lxm21,
+  $nsid: () => $nsid25,
+  $output: () => $output21,
+  $params: () => $params21,
+  main: () => main25,
+  tipResponse: () => tipResponse
+});
+
+// src/lexicons/com/atiproto/repo/tip/search.defs.ts
+var search_defs_exports2 = {};
+__export(search_defs_exports2, {
+  $lxm: () => $lxm21,
+  $nsid: () => $nsid25,
+  $output: () => $output21,
+  $params: () => $params21,
+  main: () => main25,
+  tipResponse: () => tipResponse
+});
+import { l as l25 } from "@atproto/lex";
+var $nsid25 = "com.atiproto.repo.tip.search";
+var main25 = l25.query(
+  $nsid25,
+  l25.params({
+    subject: l25.string({ format: "did" }),
+    cursor: l25.optional(l25.string()),
+    limit: l25.optional(
+      l25.withDefault(l25.integer({ minimum: 1, maximum: 100 }), 50)
+    )
+  }),
+  l25.jsonPayload({
+    tips: l25.array(l25.ref((() => tipResponse))),
+    cursor: l25.optional(l25.string())
+  })
+);
+var $lxm21 = main25.nsid;
+var $params21 = main25.parameters;
+var $output21 = main25.output;
+var tipResponse = l25.typedObject(
+  $nsid25,
+  "tipResponse",
+  l25.object({
+    uri: l25.string({ format: "at-uri" }),
+    record: l25.ref((() => main2))
+  })
+);
+
+// src/lexicons/com/atiproto/repo/tip/validate.ts
+var validate_exports2 = {};
+__export(validate_exports2, {
+  $defs: () => validate_defs_exports2,
+  $lxm: () => $lxm22,
+  $nsid: () => $nsid26,
+  $output: () => $output22,
+  $params: () => $params22,
+  main: () => main26
+});
+
+// src/lexicons/com/atiproto/repo/tip/validate.defs.ts
+var validate_defs_exports2 = {};
+__export(validate_defs_exports2, {
+  $lxm: () => $lxm22,
+  $nsid: () => $nsid26,
+  $output: () => $output22,
+  $params: () => $params22,
+  main: () => main26
+});
+import { l as l26 } from "@atproto/lex";
+var $nsid26 = "com.atiproto.repo.tip.validate";
+var main26 = l26.query(
+  $nsid26,
+  l26.params({
+    sender: l26.string({ format: "did" }),
+    subject: l26.optional(l26.string({ format: "did" })),
+    recordUri: l26.optional(l26.string({ format: "at-uri" })),
+    amount: l26.optional(l26.integer())
+  }),
+  l26.jsonPayload({
+    valid: l26.boolean(),
+    amount: l26.optional(l26.integer()),
+    currency: l26.optional(l26.string()),
+    reason: l26.optional(l26.string())
+  })
+);
+var $lxm22 = main26.nsid;
+var $params22 = main26.parameters;
+var $output22 = main26.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/schemas/account/cart/clone.json
+var clone_default = {
+  lexicon: 1,
+  id: "com.atiproto.account.cart.clone",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Clone an existing cart, creating new tip and subscription records. Useful for reopening expired carts or repeating tips.",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["uri"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "AT-URI of the cart to clone"
+            },
+            redirectUrl: {
+              type: "string",
+              format: "uri",
+              description: "URI to redirect to after checkout is complete/cancelled"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: [
+            "cart",
+            "cartUri",
+            "checkoutUrl",
+            "tips",
+            "subscriptions"
+          ],
+          properties: {
+            cart: {
+              type: "ref",
+              ref: "com.atiproto.cart",
+              description: "The new cart record"
+            },
+            cartUri: {
+              type: "string",
+              format: "at-uri",
+              description: "URI of the new cart record"
+            },
+            checkoutUrl: {
+              type: "string",
+              format: "uri",
+              description: "Checkout URL for the new cart"
+            },
+            tips: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.tip"
+              },
+              description: "Newly created tip records"
+            },
+            subscriptions: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.subscription"
+              },
+              description: "Newly created subscription records"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/account/cart/create.json
+var create_default = {
+  lexicon: 1,
+  id: "com.atiproto.account.cart.create",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Create a new empty cart",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["currency"],
+          properties: {
+            currency: {
+              type: "string",
+              description: "ISO 4217 currency code"
+            },
+            redirectUrl: {
+              type: "string",
+              format: "uri",
+              description: "URI to redirect to after checkout is complete/cancelled"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["cart", "cartUri", "checkoutUrl"],
+          properties: {
+            cart: {
+              type: "ref",
+              ref: "com.atiproto.cart",
+              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",
+              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"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// 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",
+              description: "Filter: open, completed, expired, abandoned"
+            },
+            cursor: {
+              type: "string",
+              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",
+              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 = {
+  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",
+              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: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Profile record URI"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "Profile record CID"
+            },
+            profile: {
+              type: "ref",
+              ref: "com.atiproto.profile",
+              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"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/cart.json
+var cart_default = {
+  lexicon: 1,
+  id: "com.atiproto.cart",
+  defs: {
+    main: {
+      type: "record",
+      description: "A record representing a shopping cart for tips/subscriptions",
+      key: "any",
+      record: {
+        type: "object",
+        required: [
+          "items",
+          "currency",
+          "total",
+          "status",
+          "createdAt",
+          "expiresAt"
+        ],
+        properties: {
+          items: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "#cartItem"
+            }
+          },
+          currency: {
+            type: "string",
+            description: "ISO 4217 currency code"
+          },
+          total: {
+            type: "integer",
+            description: "Total amount in cents"
+          },
+          status: {
+            type: "string",
+            description: "Cart status: open, completed, expired, abandoned"
+          },
+          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"],
+      properties: {
+        type: {
+          type: "string",
+          description: "Item type: tip or subscription",
+          enum: ["com.atiproto.tip", "com.atiproto.subscription"]
+        },
+        recordUri: {
+          type: "string",
+          format: "at-uri",
+          description: "AT-URI for tip on record"
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/list.json
+var list_default2 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.list",
+  defs: {
+    main: {
+      type: "query",
+      description: "List tips and subscriptions for the authenticated user. Always returns tips given by the user and subscriptions the user has created.",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            cursor: {
+              type: "string",
+              description: "Pagination cursor"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+              description: "Results per page (1-100)"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["items"],
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "union",
+                refs: ["com.atiproto.tip", "com.atiproto.subscription"]
+              }
+            },
+            cursor: {
+              type: "string",
+              description: "Pagination cursor for next page"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/subscription/cancel.json
+var cancel_default = {
+  lexicon: 1,
+  id: "com.atiproto.feed.subscription.cancel",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Cancel an active subscription",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["subscriptionUri"],
+          properties: {
+            subscriptionUri: {
+              type: "string",
+              format: "at-uri",
+              description: "AT-URI of the subscription to cancel"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["subscriptionUri", "subscription", "accessUntil"],
+          properties: {
+            subscriptionUri: {
+              type: "string",
+              format: "at-uri",
+              description: "URI of the updated subscription record"
+            },
+            subscription: {
+              type: "ref",
+              ref: "com.atiproto.subscription",
+              description: "Updated subscription record"
+            },
+            accessUntil: {
+              type: "string",
+              format: "datetime",
+              description: "Timestamp when access expires"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/subscription/create.json
+var create_default2 = {
+  defs: {
+    main: {
+      description: "Create a subscription to a user. Returns a one-off cart with checkout URL.",
+      input: {
+        encoding: "application/json",
+        schema: {
+          properties: {
+            subject: {
+              description: "DID of the user to subscribe to",
+              format: "did",
+              type: "string"
+            },
+            amount: {
+              description: "Custom amount in cents (if pay-as-you-want enabled)",
+              type: "integer"
+            },
+            currency: {
+              description: "ISO 4217 currency code",
+              type: "string"
+            },
+            interval: {
+              description: "Billing interval: monthly or yearly",
+              type: "string"
+            }
+          },
+          required: ["subject", "currency", "interval"],
+          type: "object"
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          properties: {
+            subscriptionUri: {
+              description: "URI of the subscription record in PDS",
+              format: "at-uri",
+              type: "string"
+            },
+            subscription: {
+              description: "The created subscription record (status: pending)",
+              type: "ref",
+              ref: "com.atiproto.subscription"
+            },
+            cartUri: {
+              description: "URI of the cart record in PDS",
+              format: "at-uri",
+              type: "string"
+            },
+            cart: {
+              description: "The created cart record (status: open)",
+              type: "ref",
+              ref: "com.atiproto.cart"
+            },
+            checkoutUrl: {
+              description: "Checkout URL hosted by atiproto",
+              format: "uri",
+              type: "string"
+            }
+          },
+          required: [
+            "subscriptionUri",
+            "subscription",
+            "cartUri",
+            "cart",
+            "checkoutUrl"
+          ],
+          type: "object"
+        }
+      },
+      type: "procedure"
+    }
+  },
+  id: "com.atiproto.feed.subscription.create",
+  lexicon: 1
+};
+
+// src/schemas/feed/subscription/get.json
+var get_default3 = {
+  defs: {
+    main: {
+      description: "Get a specific subscription by URI",
+      parameters: {
+        properties: {
+          uri: {
+            description: "AT-URI of the subscription record",
+            format: "at-uri",
+            type: "string"
+          }
+        },
+        required: ["uri"],
+        type: "params"
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          properties: {
+            uri: {
+              description: "Subscription record URI",
+              format: "at-uri",
+              type: "string"
+            },
+            cid: {
+              description: "Subscription record CID",
+              format: "cid",
+              type: "string"
+            },
+            record: {
+              description: "The subscription record data",
+              type: "ref",
+              ref: "com.atiproto.subscription"
+            }
+          },
+          required: ["uri", "cid", "record"],
+          type: "object"
+        }
+      },
+      type: "query"
+    }
+  },
+  id: "com.atiproto.feed.subscription.get",
+  lexicon: 1
+};
+
+// src/schemas/feed/subscription/list.json
+var list_default3 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.subscription.list",
+  defs: {
+    main: {
+      type: "query",
+      description: "List subscriptions for the authenticated user",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            cursor: {
+              type: "string",
+              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: ["subscriptions"],
+          properties: {
+            subscriptions: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "#subscriptionResponse"
+              }
+            },
+            cursor: {
+              type: "string",
+              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/feed/subscription/put.json
+var put_default3 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.subscription.put",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Update a pending subscription. Only pending subscriptions 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 subscription record to update"
+            },
+            record: {
+              type: "ref",
+              ref: "com.atiproto.subscription"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["uri", "cid"],
+          properties: {
+            uri: {
+              type: "string",
+              format: "at-uri",
+              description: "Updated subscription record URI"
+            },
+            cid: {
+              type: "string",
+              format: "cid",
+              description: "New CID of the updated record"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/tip/create.json
+var create_default3 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.tip.create",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Create a tip on a DID or specific record. Creates or adds to a cart and returns a checkout URL.",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["subject", "amount", "currency"],
+          properties: {
+            subject: {
+              type: "string",
+              format: "did",
+              description: "DID of the user being tipped"
+            },
+            recordUri: {
+              type: "string",
+              format: "at-uri",
+              description: "AT-URI of specific record being tipped"
+            },
+            amount: {
+              type: "integer",
+              description: "Tip amount in cents"
+            },
+            currency: {
+              type: "string",
+              description: "ISO 4217 currency code"
+            },
+            cartUri: {
+              type: "string",
+              format: "at-uri",
+              description: "AT-URI of an existing cart to add this tip to. If omitted, a new cart is created."
+            },
+            redirectUrl: {
+              type: "string",
+              format: "uri",
+              description: "URL to redirect to after checkout completes"
+            },
+            message: {
+              type: "string",
+              description: "Optional message (max 500 chars)",
+              maxGraphemes: 500,
+              maxLength: 5e3
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["tipUri", "tip", "cartUri", "cart", "checkoutUrl"],
+          properties: {
+            tipUri: {
+              type: "string",
+              format: "at-uri",
+              description: "URI of the tip record in PDS"
+            },
+            tip: {
+              type: "ref",
+              ref: "com.atiproto.tip",
+              description: "The created tip record (status: pending)"
+            },
+            cartUri: {
+              type: "string",
+              format: "at-uri",
+              description: "URI of the cart record in PDS"
+            },
+            cart: {
+              type: "ref",
+              ref: "com.atiproto.cart",
+              description: "The cart record (new or updated)"
+            },
+            checkoutUrl: {
+              type: "string",
+              format: "uri",
+              description: "Checkout URL hosted by atiproto"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/tip/get.json
+var get_default4 = {
+  defs: {
+    main: {
+      description: "Get a specific tip by URI",
+      parameters: {
+        properties: {
+          uri: {
+            description: "AT-URI of the tip record",
+            format: "at-uri",
+            type: "string"
+          }
+        },
+        required: ["uri"],
+        type: "params"
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          properties: {
+            uri: {
+              description: "Tip record URI",
+              format: "at-uri",
+              type: "string"
+            },
+            cid: {
+              description: "Tip record CID",
+              format: "cid",
+              type: "string"
+            },
+            value: {
+              description: "The tip record data",
+              type: "ref",
+              ref: "com.atiproto.tip"
+            }
+          },
+          required: ["uri", "cid", "value"],
+          type: "object"
+        }
+      },
+      type: "query"
+    }
+  },
+  id: "com.atiproto.feed.tip.get",
+  lexicon: 1
+};
+
+// src/schemas/feed/tip/list.json
+var list_default4 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.tip.list",
+  defs: {
+    main: {
+      type: "query",
+      description: "List tips for the authenticated user",
+      input: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          properties: {
+            cursor: {
+              type: "string",
+              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: ["records"],
+          properties: {
+            records: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "com.atiproto.tip"
+              }
+            },
+            cursor: {
+              type: "string",
+              description: "Pagination cursor for next page"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/feed/tip/put.json
+var put_default4 = {
+  lexicon: 1,
+  id: "com.atiproto.feed.tip.put",
+  defs: {
+    main: {
+      type: "procedure",
+      description: "Update a pending tip. Only pending tips 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 tip record to update"
+            },
+            record: {
+              type: "ref",
+              ref: "com.atiproto.tip"
+            }
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          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/profile.json
+var profile_default = {
+  lexicon: 1,
+  id: "com.atiproto.profile",
+  defs: {
+    main: {
+      type: "record",
+      description: "A record representing a user's tipping/subscription settings",
+      key: "literal:self",
+      record: {
+        type: "object",
+        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 = {
+  lexicon: 1,
+  id: "com.atiproto.repo.profile.get",
+  defs: {
+    main: {
+      type: "query",
+      description: "Look up public profile information for any user",
+      parameters: {
+        type: "params",
+        required: ["did"],
+        properties: {
+          did: {
+            type: "string",
+            format: "did",
+            description: "DID of the user to look up"
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["did", "profile"],
+          properties: {
+            did: {
+              type: "string",
+              format: "did",
+              description: "User's DID"
+            },
+            profile: {
+              type: "ref",
+              ref: "com.atiproto.profile",
+              description: "Public profile data"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/repo/subscription/search.json
+var search_default = {
+  lexicon: 1,
+  id: "com.atiproto.repo.subscription.search",
+  defs: {
+    main: {
+      type: "query",
+      description: "Search for subscriptions to a user (subscriptions where subject matches the given DID)",
+      parameters: {
+        type: "params",
+        properties: {
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the user being subscribed to"
+          },
+          cursor: {
+            type: "string",
+            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",
+              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 to a recipient. Optionally check the subscription amount.",
+      parameters: {
+        type: "params",
+        required: ["sender", "subject"],
+        properties: {
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the subscriber"
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the creator being subscribed to"
+          },
+          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 sender has an active, verified subscription"
+            },
+            amount: {
+              type: "integer",
+              description: "Subscription amount in cents"
+            },
+            currency: {
+              type: "string",
+              description: "Currency of the subscription"
+            },
+            reason: {
+              type: "string",
+              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",
+            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",
+              description: "Pagination cursor for next page"
+            }
+          }
+        }
+      }
+    },
+    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 = {
+  lexicon: 1,
+  id: "com.atiproto.repo.tip.validate",
+  defs: {
+    main: {
+      type: "query",
+      description: "Validate that a sender has completed tip payment(s). Looks up by recordUri (sums all tips for that record) or by subject (recipient DID). These are mutually exclusive; if recordUri is provided, subject is ignored.",
+      parameters: {
+        type: "params",
+        required: ["sender"],
+        properties: {
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip sender"
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip recipient. Ignored if recordUri is provided."
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the record being tipped. Takes precedence over subject."
+          },
+          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: {
+            valid: {
+              type: "boolean",
+              description: "Whether the sender has completed and verified tip(s)"
+            },
+            amount: {
+              type: "integer",
+              description: "Sum of all verified completed tip amounts in cents"
+            },
+            currency: {
+              type: "string",
+              description: "Currency of the tips"
+            },
+            reason: {
+              type: "string",
+              description: "If invalid, reason for rejection"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schemas/subscription.json
+var subscription_default = {
+  defs: {
+    main: {
+      description: "A record representing a subscription from one user to another",
+      key: "any",
+      record: {
+        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",
+            type: "string"
+          },
+          interval: {
+            description: "Billing interval: monthly or yearly",
+            type: "string"
+          },
+          status: {
+            description: "Subscription status: 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"
+          }
+        },
+        required: [
+          "subject",
+          "amount",
+          "currency",
+          "interval",
+          "status",
+          "billingStartDate",
+          "createdAt"
+        ],
+        type: "object"
+      },
+      type: "record"
+    }
+  },
+  id: "com.atiproto.subscription",
+  lexicon: 1
+};
+
+// src/schemas/tip.json
+var tip_default = {
+  defs: {
+    main: {
+      description: "A record representing a tip given by one user to another",
+      key: "any",
+      record: {
+        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",
+            type: "string"
+          },
+          status: {
+            description: "Tip status: pending, authorized (payment held), completed, failed, refunded",
+            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"
+          }
+        },
+        required: ["subject", "amount", "currency", "status", "createdAt"],
+        type: "object"
+      },
+      type: "record"
+    }
+  },
+  id: "com.atiproto.tip",
+  lexicon: 1
+};
+
+// src/schemas.ts
+var schemas = [
+  clone_default,
+  create_default,
+  get_default,
+  list_default,
+  put_default,
+  get_default2,
+  put_default2,
+  cart_default,
+  list_default2,
+  cancel_default,
+  create_default2,
+  get_default3,
+  list_default3,
+  put_default3,
+  create_default3,
+  get_default4,
+  list_default4,
+  put_default4,
+  profile_default,
+  get_default5,
+  search_default,
+  validate_default,
+  search_default2,
+  validate_default2,
+  subscription_default,
+  tip_default
+];
+export {
+  com_exports as com,
+  schemas
+};
+//# sourceMappingURL=index.mjs.map