@atiproto/lexicons 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,20 +1,2953 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemas = void 0;
-__exportStar(require("./lexicons/index.js"), exports);
-var schemas_js_1 = require("./schemas.js");
-Object.defineProperty(exports, "schemas", { enumerable: true, get: function () { return schemas_js_1.schemas; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  com: () => com_exports,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+});
+var import_lex4 = require("@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
+});
+var import_lex = require("@atproto/lex");
+var $nsid = "com.atiproto.cart";
+var main = import_lex.l.record(
+  "any",
+  $nsid,
+  import_lex.l.object({
+    items: import_lex.l.array(import_lex.l.ref((() => cartItem))),
+    currency: import_lex.l.string(),
+    total: import_lex.l.integer(),
+    status: import_lex.l.string(),
+    createdAt: import_lex.l.string({ format: "datetime" }),
+    expiresAt: import_lex.l.string({ format: "datetime" }),
+    completedAt: import_lex.l.optional(import_lex.l.string({ format: "datetime" }))
+  })
+);
+var $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 = import_lex.l.typedObject(
+  $nsid,
+  "cartItem",
+  import_lex.l.object({
+    type: import_lex.l.enum(["com.atiproto.tip", "com.atiproto.subscription"]),
+    recordUri: import_lex.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
+});
+var import_lex2 = require("@atproto/lex");
+var $nsid2 = "com.atiproto.tip";
+var main2 = import_lex2.l.record(
+  "any",
+  $nsid2,
+  import_lex2.l.object({
+    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(),
+    status: import_lex2.l.enum([
+      "pending",
+      "authorized",
+      "completed",
+      "failed",
+      "refunded"
+    ]),
+    message: import_lex2.l.optional(import_lex2.l.string({ maxGraphemes: 500, maxLength: 5e3 })),
+    createdAt: import_lex2.l.string({ format: "datetime" }),
+    completedAt: import_lex2.l.optional(import_lex2.l.string({ format: "datetime" }))
+  })
+);
+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
+});
+var import_lex3 = require("@atproto/lex");
+var $nsid3 = "com.atiproto.subscription";
+var main3 = import_lex3.l.record(
+  "any",
+  $nsid3,
+  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(),
+    billingStartDate: import_lex3.l.string({ format: "datetime" }),
+    cancelledAt: import_lex3.l.optional(import_lex3.l.string({ format: "datetime" })),
+    accessUntil: import_lex3.l.optional(import_lex3.l.string({ format: "datetime" })),
+    createdAt: import_lex3.l.string({ format: "datetime" })
+  })
+);
+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 = import_lex4.l.procedure(
+  $nsid4,
+  import_lex4.l.params(),
+  import_lex4.l.jsonPayload({
+    uri: import_lex4.l.string({ format: "at-uri" }),
+    redirectUrl: import_lex4.l.optional(import_lex4.l.string({ format: "uri" }))
+  }),
+  import_lex4.l.jsonPayload({
+    cart: import_lex4.l.ref((() => main)),
+    cartUri: import_lex4.l.string({ format: "at-uri" }),
+    checkoutUrl: import_lex4.l.string({ format: "uri" }),
+    tips: import_lex4.l.array(import_lex4.l.ref((() => main2))),
+    subscriptions: import_lex4.l.array(
+      import_lex4.l.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
+});
+var import_lex5 = require("@atproto/lex");
+var $nsid5 = "com.atiproto.account.cart.create";
+var main5 = import_lex5.l.procedure(
+  $nsid5,
+  import_lex5.l.params(),
+  import_lex5.l.jsonPayload({
+    currency: import_lex5.l.string(),
+    redirectUrl: import_lex5.l.optional(import_lex5.l.string({ format: "uri" }))
+  }),
+  import_lex5.l.jsonPayload({
+    cart: import_lex5.l.ref((() => main)),
+    cartUri: import_lex5.l.string({ format: "at-uri" }),
+    checkoutUrl: import_lex5.l.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
+});
+var import_lex6 = require("@atproto/lex");
+var $nsid6 = "com.atiproto.account.cart.get";
+var main6 = import_lex6.l.query(
+  $nsid6,
+  import_lex6.l.params({ uri: import_lex6.l.string({ format: "at-uri" }) }),
+  import_lex6.l.jsonPayload({
+    uri: import_lex6.l.string({ format: "at-uri" }),
+    cid: import_lex6.l.optional(import_lex6.l.string({ format: "cid" })),
+    cart: import_lex6.l.ref((() => main)),
+    checkoutUrl: import_lex6.l.optional(import_lex6.l.string({ format: "uri" })),
+    tips: import_lex6.l.array(import_lex6.l.ref((() => main2))),
+    subscriptions: import_lex6.l.array(
+      import_lex6.l.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
+});
+var import_lex7 = require("@atproto/lex");
+var $nsid7 = "com.atiproto.account.cart.list";
+var main7 = import_lex7.l.query(
+  $nsid7,
+  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())
+  })
+);
+var $lxm4 = main7.nsid;
+var $params4 = main7.parameters;
+var $output4 = main7.output;
+var cartResponse = import_lex7.l.typedObject(
+  $nsid7,
+  "cartResponse",
+  import_lex7.l.object({
+    uri: import_lex7.l.string({ format: "at-uri" }),
+    cid: import_lex7.l.string({ format: "cid" }),
+    record: import_lex7.l.ref((() => main))
+  })
+);
+
+// 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
+});
+var import_lex8 = require("@atproto/lex");
+var $nsid8 = "com.atiproto.account.cart.put";
+var main8 = import_lex8.l.procedure(
+  $nsid8,
+  import_lex8.l.params(),
+  import_lex8.l.jsonPayload({
+    uri: import_lex8.l.string({ format: "at-uri" }),
+    record: import_lex8.l.ref((() => main))
+  }),
+  import_lex8.l.jsonPayload({
+    uri: import_lex8.l.string({ format: "at-uri" }),
+    cid: import_lex8.l.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
+});
+var import_lex10 = require("@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
+});
+var import_lex9 = require("@atproto/lex");
+var $nsid9 = "com.atiproto.profile";
+var main9 = import_lex9.l.record(
+  "literal:self",
+  $nsid9,
+  import_lex9.l.object({
+    acceptsTips: import_lex9.l.optional(import_lex9.l.boolean()),
+    acceptsSubscriptions: import_lex9.l.optional(import_lex9.l.boolean()),
+    disableReceiptNotifications: import_lex9.l.optional(import_lex9.l.boolean()),
+    createdAt: import_lex9.l.string({ format: "datetime" }),
+    updatedAt: import_lex9.l.optional(import_lex9.l.string({ format: "datetime" }))
+  })
+);
+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 = import_lex10.l.query(
+  $nsid10,
+  import_lex10.l.params(),
+  import_lex10.l.jsonPayload({
+    uri: import_lex10.l.optional(import_lex10.l.string({ format: "at-uri" })),
+    cid: import_lex10.l.optional(import_lex10.l.string({ format: "cid" })),
+    profile: import_lex10.l.ref((() => main9)),
+    hasProfile: import_lex10.l.boolean(),
+    readyForPayment: import_lex10.l.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
+});
+var import_lex11 = require("@atproto/lex");
+var $nsid11 = "com.atiproto.account.profile.put";
+var main11 = import_lex11.l.procedure(
+  $nsid11,
+  import_lex11.l.params(),
+  import_lex11.l.jsonPayload({
+    acceptsTips: import_lex11.l.optional(import_lex11.l.boolean()),
+    acceptsSubscriptions: import_lex11.l.optional(import_lex11.l.boolean()),
+    disableReceiptNotifications: import_lex11.l.optional(import_lex11.l.boolean())
+  }),
+  import_lex11.l.jsonPayload({
+    uri: import_lex11.l.string({ format: "at-uri" }),
+    cid: import_lex11.l.string({ format: "cid" }),
+    profile: import_lex11.l.ref((() => main9)),
+    hasProfile: import_lex11.l.boolean(),
+    readyForPayment: import_lex11.l.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
+});
+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(
+        [
+          import_lex12.l.typedRef((() => main2)),
+          import_lex12.l.typedRef(
+            (() => main3)
+          )
+        ],
+        false
+      )
+    ),
+    cursor: import_lex12.l.optional(import_lex12.l.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
+});
+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(
+      (() => main3)
+    ),
+    accessUntil: import_lex13.l.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
+});
+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()
+  }),
+  import_lex14.l.jsonPayload({
+    subscriptionUri: import_lex14.l.string({ format: "at-uri" }),
+    subscription: import_lex14.l.ref(
+      (() => main3)
+    ),
+    cartUri: import_lex14.l.string({ format: "at-uri" }),
+    cart: import_lex14.l.ref((() => main)),
+    checkoutUrl: import_lex14.l.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
+});
+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(
+      (() => 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
+});
+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))
+    ),
+    cursor: import_lex16.l.optional(import_lex16.l.string())
+  })
+);
+var $lxm12 = main16.nsid;
+var $params12 = main16.parameters;
+var $output12 = main16.output;
+var subscriptionResponse = import_lex16.l.typedObject(
+  $nsid16,
+  "subscriptionResponse",
+  import_lex16.l.object({
+    uri: import_lex16.l.string({ format: "at-uri" }),
+    record: import_lex16.l.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
+});
+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(
+      (() => main3)
+    )
+  }),
+  import_lex17.l.jsonPayload({
+    uri: import_lex17.l.string({ format: "at-uri" }),
+    cid: import_lex17.l.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
+});
+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 }))
+  }),
+  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" })
+  })
+);
+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
+});
+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 $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
+});
+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 $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
+});
+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))
+  }),
+  import_lex21.l.jsonPayload({
+    uri: import_lex21.l.string({ format: "at-uri" }),
+    cid: import_lex21.l.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
+});
+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 $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
+});
+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)
+    )
+  }),
+  import_lex23.l.jsonPayload({
+    subscriptions: import_lex23.l.array(
+      import_lex23.l.ref((() => subscriptionResponse2))
+    ),
+    cursor: import_lex23.l.optional(import_lex23.l.string())
+  })
+);
+var $lxm19 = main23.nsid;
+var $params19 = main23.parameters;
+var $output19 = main23.output;
+var subscriptionResponse2 = import_lex23.l.typedObject(
+  $nsid23,
+  "subscriptionResponse",
+  import_lex23.l.object({
+    uri: import_lex23.l.string({ format: "at-uri" }),
+    record: import_lex23.l.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
+});
+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())
+  }),
+  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())
+  })
+);
+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
+});
+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)
+    )
+  }),
+  import_lex25.l.jsonPayload({
+    tips: import_lex25.l.array(import_lex25.l.ref((() => tipResponse))),
+    cursor: import_lex25.l.optional(import_lex25.l.string())
+  })
+);
+var $lxm21 = main25.nsid;
+var $params21 = main25.parameters;
+var $output21 = main25.output;
+var tipResponse = import_lex25.l.typedObject(
+  $nsid25,
+  "tipResponse",
+  import_lex25.l.object({
+    uri: import_lex25.l.string({ format: "at-uri" }),
+    record: import_lex25.l.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
+});
+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())
+  }),
+  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())
+  })
+);
+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. Looks up by subscriptionUri (a specific subscription record) or subject (recipient DID). These are mutually exclusive; subscriptionUri takes precedence.",
+      parameters: {
+        type: "params",
+        required: ["sender"],
+        properties: {
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the subscriber"
+          },
+          subscriptionUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific subscription record. Takes precedence over subject."
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the creator being subscribed to. Ignored if subscriptionUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected subscription amount in cents. If omitted, only checks that a subscription exists."
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["valid"],
+          properties: {
+            valid: {
+              type: "boolean",
+              description: "Whether the 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 tipUri (a specific tip record), recordUri (sums all tips for that record), or subject (recipient DID). These are mutually exclusive and resolved in that order.",
+      parameters: {
+        type: "params",
+        required: ["sender"],
+        properties: {
+          sender: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip sender"
+          },
+          tipUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of a specific tip record. Takes precedence over recordUri and subject."
+          },
+          recordUri: {
+            type: "string",
+            format: "at-uri",
+            description: "AT-URI of the record being tipped. Takes precedence over subject."
+          },
+          subject: {
+            type: "string",
+            format: "did",
+            description: "DID of the tip recipient. Ignored if tipUri or recordUri is provided."
+          },
+          amount: {
+            type: "integer",
+            description: "Expected tip amount in cents. If omitted, only checks that a tip exists."
+          }
+        }
+      },
+      output: {
+        encoding: "application/json",
+        schema: {
+          type: "object",
+          required: ["valid"],
+          properties: {
+            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
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  com,
+  schemas
+});
+//# sourceMappingURL=index.js.map