@atproto/api 0.3.0 → 0.3.2

package/dist/index.js

@@ -5,8 +5,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod2) => function __require() {
-  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
   for (var name2 in all)
@@ -20,11 +20,11 @@ var __copyProps = (to, from3, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-  mod2
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
 ));
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/iso-datestring-validator/dist/index.js
 var require_dist = __commonJS({
@@ -78,6 +78,7 @@ var require_dist = __commonJS({
 // src/index.ts
 var src_exports4 = {};
 __export(src_exports4, {
+  APP_BSKY_GRAPH: () => APP_BSKY_GRAPH,
   ActorNS: () => ActorNS,
   AdminNS: () => AdminNS,
   AppBskyActorDefs: () => defs_exports5,
@@ -102,13 +103,21 @@ __export(src_exports4, {
   AppBskyFeedPost: () => post_exports,
   AppBskyFeedRepost: () => repost_exports,
   AppBskyGraphBlock: () => block_exports,
+  AppBskyGraphDefs: () => defs_exports7,
   AppBskyGraphFollow: () => follow_exports,
   AppBskyGraphGetBlocks: () => getBlocks_exports2,
   AppBskyGraphGetFollowers: () => getFollowers_exports,
   AppBskyGraphGetFollows: () => getFollows_exports,
+  AppBskyGraphGetList: () => getList_exports,
+  AppBskyGraphGetListMutes: () => getListMutes_exports,
+  AppBskyGraphGetLists: () => getLists_exports,
   AppBskyGraphGetMutes: () => getMutes_exports,
+  AppBskyGraphList: () => list_exports,
+  AppBskyGraphListitem: () => listitem_exports,
   AppBskyGraphMuteActor: () => muteActor_exports,
+  AppBskyGraphMuteActorList: () => muteActorList_exports,
   AppBskyGraphUnmuteActor: () => unmuteActor_exports,
+  AppBskyGraphUnmuteActorList: () => unmuteActorList_exports,
   AppBskyNotificationGetUnreadCount: () => getUnreadCount_exports,
   AppBskyNotificationListNotifications: () => listNotifications_exports,
   AppBskyNotificationUpdateSeen: () => updateSeen_exports,
@@ -197,6 +206,8 @@ __export(src_exports4, {
   IdentityNS: () => IdentityNS,
   LabelNS: () => LabelNS,
   LikeRecord: () => LikeRecord,
+  ListRecord: () => ListRecord,
+  ListitemRecord: () => ListitemRecord,
   ModerationNS: () => ModerationNS,
   NotificationNS: () => NotificationNS,
   PostRecord: () => PostRecord,
@@ -1453,6 +1464,15 @@ var util;
     return value;
   };
 })(util || (util = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
+    return {
+      ...first,
+      ...second
+    };
+  };
+})(objectUtil || (objectUtil = {}));
 var ZodParsedType = util.arrayToEnum([
   "string",
   "nan",
@@ -1490,6 +1510,8 @@ var getParsedType = (data) => {
       return ZodParsedType.function;
     case "bigint":
       return ZodParsedType.bigint;
+    case "symbol":
+      return ZodParsedType.symbol;
     case "object":
       if (Array.isArray(data)) {
         return ZodParsedType.array;
@@ -1529,7 +1551,8 @@ var ZodIssueCode = util.arrayToEnum([
   "too_small",
   "too_big",
   "invalid_intersection_types",
-  "not_multiple_of"
+  "not_multiple_of",
+  "not_finite"
 ]);
 var quotelessJson = (obj) => {
   const json = JSON.stringify(obj, null, 2);
@@ -1659,7 +1682,12 @@ var errorMap = (issue, _ctx) => {
       break;
     case ZodIssueCode.invalid_string:
       if (typeof issue.validation === "object") {
-        if ("startsWith" in issue.validation) {
+        if ("includes" in issue.validation) {
+          message = `Invalid input: must include "${issue.validation.includes}"`;
+          if (typeof issue.validation.position === "number") {
+            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+          }
+        } else if ("startsWith" in issue.validation) {
           message = `Invalid input: must start with "${issue.validation.startsWith}"`;
         } else if ("endsWith" in issue.validation) {
           message = `Invalid input: must end with "${issue.validation.endsWith}"`;
@@ -1674,25 +1702,27 @@ var errorMap = (issue, _ctx) => {
       break;
     case ZodIssueCode.too_small:
       if (issue.type === "array")
-        message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+        message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+        message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
       else if (issue.type === "date")
-        message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
+        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
       else
         message = "Invalid input";
       break;
     case ZodIssueCode.too_big:
       if (issue.type === "array")
-        message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+      else if (issue.type === "bigint")
+        message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
       else if (issue.type === "date")
-        message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
+        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
       else
         message = "Invalid input";
       break;
@@ -1705,6 +1735,9 @@ var errorMap = (issue, _ctx) => {
     case ZodIssueCode.not_multiple_of:
       message = `Number must be a multiple of ${issue.multipleOf}`;
       break;
+    case ZodIssueCode.not_finite:
+      message = "Number must be finite";
+      break;
     default:
       message = _ctx.defaultError;
       util.assertNever(issue);
@@ -1811,7 +1844,7 @@ var OK = (value) => ({ status: "valid", value });
 var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
-var isAsync = (x) => typeof Promise !== void 0 && x instanceof Promise;
+var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
@@ -1819,13 +1852,21 @@ var errorUtil;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
+    this._cachedPath = [];
     this.parent = parent;
     this.data = value;
     this._path = path;
     this._key = key;
   }
   get path() {
-    return this._path.concat(this._key);
+    if (!this._cachedPath.length) {
+      if (this._key instanceof Array) {
+        this._cachedPath.push(...this._path, ...this._key);
+      } else {
+        this._cachedPath.push(...this._path, this._key);
+      }
+    }
+    return this._cachedPath;
   }
 };
 var handleResult = (ctx, result) => {
@@ -1835,8 +1876,16 @@ var handleResult = (ctx, result) => {
     if (!ctx.common.issues.length) {
       throw new Error("Validation failed but no issues detected.");
     }
-    const error = new ZodError(ctx.common.issues);
-    return { success: false, error };
+    return {
+      success: false,
+      get error() {
+        if (this._error)
+          return this._error;
+        const error = new ZodError(ctx.common.issues);
+        this._error = error;
+        return this._error;
+      }
+    };
   }
 };
 function processCreateParams(params2) {
@@ -1861,7 +1910,6 @@ function processCreateParams(params2) {
 var ZodType = class {
   constructor(def2) {
     this.spa = this.safeParseAsync;
-    this.superRefine = this._refinement;
     this._def = def2;
     this.parse = this.parse.bind(this);
     this.safeParse = this.safeParse.bind(this);
@@ -1879,8 +1927,11 @@ var ZodType = class {
     this.or = this.or.bind(this);
     this.and = this.and.bind(this);
     this.transform = this.transform.bind(this);
+    this.brand = this.brand.bind(this);
     this.default = this.default.bind(this);
+    this.catch = this.catch.bind(this);
     this.describe = this.describe.bind(this);
+    this.pipe = this.pipe.bind(this);
     this.isNullable = this.isNullable.bind(this);
     this.isOptional = this.isOptional.bind(this);
   }
@@ -1966,7 +2017,7 @@ var ZodType = class {
       data,
       parsedType: getParsedType(data)
     };
-    const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
+    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
     const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
     return handleResult(ctx, result);
   }
@@ -2021,29 +2072,33 @@ var ZodType = class {
       effect: { type: "refinement", refinement }
     });
   }
+  superRefine(refinement) {
+    return this._refinement(refinement);
+  }
   optional() {
-    return ZodOptional.create(this);
+    return ZodOptional.create(this, this._def);
   }
   nullable() {
-    return ZodNullable.create(this);
+    return ZodNullable.create(this, this._def);
   }
   nullish() {
-    return this.optional().nullable();
+    return this.nullable().optional();
   }
   array() {
-    return ZodArray.create(this);
+    return ZodArray.create(this, this._def);
   }
   promise() {
-    return ZodPromise.create(this);
+    return ZodPromise.create(this, this._def);
   }
   or(option) {
-    return ZodUnion.create([this, option]);
+    return ZodUnion.create([this, option], this._def);
   }
   and(incoming) {
-    return ZodIntersection.create(this, incoming);
+    return ZodIntersection.create(this, incoming, this._def);
   }
   transform(transform) {
     return new ZodEffects({
+      ...processCreateParams(this._def),
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
       effect: { type: "transform", transform }
@@ -2052,6 +2107,7 @@ var ZodType = class {
   default(def2) {
     const defaultValueFunc = typeof def2 === "function" ? def2 : () => def2;
     return new ZodDefault({
+      ...processCreateParams(this._def),
       innerType: this,
       defaultValue: defaultValueFunc,
       typeName: ZodFirstPartyTypeKind.ZodDefault
@@ -2061,7 +2117,16 @@ var ZodType = class {
     return new ZodBranded({
       typeName: ZodFirstPartyTypeKind.ZodBranded,
       type: this,
-      ...processCreateParams(void 0)
+      ...processCreateParams(this._def)
+    });
+  }
+  catch(def2) {
+    const catchValueFunc = typeof def2 === "function" ? def2 : () => def2;
+    return new ZodCatch({
+      ...processCreateParams(this._def),
+      innerType: this,
+      catchValue: catchValueFunc,
+      typeName: ZodFirstPartyTypeKind.ZodCatch
     });
   }
   describe(description) {
@@ -2071,6 +2136,9 @@ var ZodType = class {
       description
     });
   }
+  pipe(target) {
+    return ZodPipeline.create(this, target);
+  }
   isOptional() {
     return this.safeParse(void 0).success;
   }
@@ -2079,8 +2147,43 @@ var ZodType = class {
   }
 };
 var cuidRegex = /^c[^\s-]{8,}$/i;
+var cuid2Regex = /^[a-z][a-z0-9]*$/;
+var ulidRegex = /[0-9A-HJKMNP-TV-Z]{26}/;
 var uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
-var emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+var emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\])|(\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\.[A-Za-z]{2,})+))$/;
+var emojiRegex = /^(\p{Extended_Pictographic}|\p{Emoji_Component})+$/u;
+var ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
+var ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
+var datetimeRegex = (args) => {
+  if (args.precision) {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
+    }
+  } else if (args.precision === 0) {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
+    }
+  } else {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
+    }
+  }
+};
+function isValidIP(ip, version2) {
+  if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
+    return true;
+  }
+  if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) {
+    return true;
+  }
+  return false;
+}
 var ZodString = class extends ZodType {
   constructor() {
     super(...arguments);
@@ -2094,8 +2197,19 @@ var ZodString = class extends ZodType {
       ...this._def,
       checks: [...this._def.checks, { kind: "trim" }]
     });
+    this.toLowerCase = () => new ZodString({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+    this.toUpperCase = () => new ZodString({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
   }
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = String(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -2120,6 +2234,7 @@ var ZodString = class extends ZodType {
             minimum: check.value,
             type: "string",
             inclusive: true,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -2132,10 +2247,37 @@ var ZodString = class extends ZodType {
             maximum: check.value,
             type: "string",
             inclusive: true,
+            exact: false,
             message: check.message
           });
           status.dirty();
         }
+      } else if (check.kind === "length") {
+        const tooBig = input.data.length > check.value;
+        const tooSmall = input.data.length < check.value;
+        if (tooBig || tooSmall) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          if (tooBig) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_big,
+              maximum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: true,
+              message: check.message
+            });
+          } else if (tooSmall) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_small,
+              minimum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: true,
+              message: check.message
+            });
+          }
+          status.dirty();
+        }
       } else if (check.kind === "email") {
         if (!emailRegex.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -2146,6 +2288,16 @@ var ZodString = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "emoji") {
+        if (!emojiRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "emoji",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else if (check.kind === "uuid") {
         if (!uuidRegex.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -2166,6 +2318,26 @@ var ZodString = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "cuid2") {
+        if (!cuid2Regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "cuid2",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "ulid") {
+        if (!ulidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "ulid",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else if (check.kind === "url") {
         try {
           new URL(input.data);
@@ -2192,6 +2364,20 @@ var ZodString = class extends ZodType {
         }
       } else if (check.kind === "trim") {
         input.data = input.data.trim();
+      } else if (check.kind === "includes") {
+        if (!input.data.includes(check.value, check.position)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_string,
+            validation: { includes: check.value, position: check.position },
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "toLowerCase") {
+        input.data = input.data.toLowerCase();
+      } else if (check.kind === "toUpperCase") {
+        input.data = input.data.toUpperCase();
       } else if (check.kind === "startsWith") {
         if (!input.data.startsWith(check.value)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -2212,6 +2398,27 @@ var ZodString = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "datetime") {
+        const regex = datetimeRegex(check);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_string,
+            validation: "datetime",
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "ip") {
+        if (!isValidIP(input.data, check.version)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "ip",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else {
         util.assertNever(check);
       }
@@ -2230,12 +2437,41 @@ var ZodString = class extends ZodType {
   url(message) {
     return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
   }
+  emoji(message) {
+    return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
+  }
   uuid(message) {
     return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
   }
   cuid(message) {
     return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
   }
+  cuid2(message) {
+    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
+  }
+  ulid(message) {
+    return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
+  }
+  ip(options) {
+    return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
+  }
+  datetime(options) {
+    var _a;
+    if (typeof options === "string") {
+      return this._addCheck({
+        kind: "datetime",
+        precision: null,
+        offset: false,
+        message: options
+      });
+    }
+    return this._addCheck({
+      kind: "datetime",
+      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
+      offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
+      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
+    });
+  }
   regex(regex, message) {
     return this._addCheck({
       kind: "regex",
@@ -2243,6 +2479,14 @@ var ZodString = class extends ZodType {
       ...errorUtil.errToObj(message)
     });
   }
+  includes(value, options) {
+    return this._addCheck({
+      kind: "includes",
+      value,
+      position: options === null || options === void 0 ? void 0 : options.position,
+      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
+    });
+  }
   startsWith(value, message) {
     return this._addCheck({
       kind: "startsWith",
@@ -2272,7 +2516,14 @@ var ZodString = class extends ZodType {
     });
   }
   length(len, message) {
-    return this.min(len, message).max(len, message);
+    return this._addCheck({
+      kind: "length",
+      value: len,
+      ...errorUtil.errToObj(message)
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((ch) => ch.kind === "datetime");
   }
   get isEmail() {
     return !!this._def.checks.find((ch) => ch.kind === "email");
@@ -2280,12 +2531,24 @@ var ZodString = class extends ZodType {
   get isURL() {
     return !!this._def.checks.find((ch) => ch.kind === "url");
   }
+  get isEmoji() {
+    return !!this._def.checks.find((ch) => ch.kind === "emoji");
+  }
   get isUUID() {
     return !!this._def.checks.find((ch) => ch.kind === "uuid");
   }
   get isCUID() {
     return !!this._def.checks.find((ch) => ch.kind === "cuid");
   }
+  get isCUID2() {
+    return !!this._def.checks.find((ch) => ch.kind === "cuid2");
+  }
+  get isULID() {
+    return !!this._def.checks.find((ch) => ch.kind === "ulid");
+  }
+  get isIP() {
+    return !!this._def.checks.find((ch) => ch.kind === "ip");
+  }
   get minLength() {
     let min = null;
     for (const ch of this._def.checks) {
@@ -2308,9 +2571,11 @@ var ZodString = class extends ZodType {
   }
 };
 ZodString.create = (params2) => {
+  var _a;
   return new ZodString({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodString,
+    coerce: (_a = params2 === null || params2 === void 0 ? void 0 : params2.coerce) !== null && _a !== void 0 ? _a : false,
     ...processCreateParams(params2)
   });
 };
@@ -2330,6 +2595,9 @@ var ZodNumber = class extends ZodType {
     this.step = this.multipleOf;
   }
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = Number(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -2363,6 +2631,7 @@ var ZodNumber = class extends ZodType {
             minimum: check.value,
             type: "number",
             inclusive: check.inclusive,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -2376,6 +2645,7 @@ var ZodNumber = class extends ZodType {
             maximum: check.value,
             type: "number",
             inclusive: check.inclusive,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -2390,6 +2660,15 @@ var ZodNumber = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "finite") {
+        if (!Number.isFinite(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.not_finite,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else {
         util.assertNever(check);
       }
@@ -2473,6 +2752,25 @@ var ZodNumber = class extends ZodType {
       message: errorUtil.toString(message)
     });
   }
+  finite(message) {
+    return this._addCheck({
+      kind: "finite",
+      message: errorUtil.toString(message)
+    });
+  }
+  safe(message) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: true,
+      value: Number.MIN_SAFE_INTEGER,
+      message: errorUtil.toString(message)
+    })._addCheck({
+      kind: "max",
+      inclusive: true,
+      value: Number.MAX_SAFE_INTEGER,
+      message: errorUtil.toString(message)
+    });
+  }
   get minValue() {
     let min = null;
     for (const ch of this._def.checks) {
@@ -2494,39 +2792,203 @@ var ZodNumber = class extends ZodType {
     return max;
   }
   get isInt() {
-    return !!this._def.checks.find((ch) => ch.kind === "int");
+    return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
+  }
+  get isFinite() {
+    let max = null, min = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
+        return true;
+      } else if (ch.kind === "min") {
+        if (min === null || ch.value > min)
+          min = ch.value;
+      } else if (ch.kind === "max") {
+        if (max === null || ch.value < max)
+          max = ch.value;
+      }
+    }
+    return Number.isFinite(min) && Number.isFinite(max);
   }
 };
 ZodNumber.create = (params2) => {
   return new ZodNumber({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodNumber,
+    coerce: (params2 === null || params2 === void 0 ? void 0 : params2.coerce) || false,
     ...processCreateParams(params2)
   });
 };
 var ZodBigInt = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this.min = this.gte;
+    this.max = this.lte;
+  }
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = BigInt(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.bigint) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.bigint,
-        received: ctx.parsedType
+        received: ctx2.parsedType
       });
       return INVALID;
     }
-    return OK(input.data);
+    let ctx = void 0;
+    const status = new ParseStatus();
+    for (const check of this._def.checks) {
+      if (check.kind === "min") {
+        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        if (tooSmall) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_small,
+            type: "bigint",
+            minimum: check.value,
+            inclusive: check.inclusive,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "max") {
+        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        if (tooBig) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_big,
+            type: "bigint",
+            maximum: check.value,
+            inclusive: check.inclusive,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "multipleOf") {
+        if (input.data % check.value !== BigInt(0)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.not_multiple_of,
+            multipleOf: check.value,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else {
+        util.assertNever(check);
+      }
+    }
+    return { status: status.value, value: input.data };
+  }
+  gte(value, message) {
+    return this.setLimit("min", value, true, errorUtil.toString(message));
+  }
+  gt(value, message) {
+    return this.setLimit("min", value, false, errorUtil.toString(message));
+  }
+  lte(value, message) {
+    return this.setLimit("max", value, true, errorUtil.toString(message));
+  }
+  lt(value, message) {
+    return this.setLimit("max", value, false, errorUtil.toString(message));
+  }
+  setLimit(kind, value, inclusive, message) {
+    return new ZodBigInt({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind,
+          value,
+          inclusive,
+          message: errorUtil.toString(message)
+        }
+      ]
+    });
+  }
+  _addCheck(check) {
+    return new ZodBigInt({
+      ...this._def,
+      checks: [...this._def.checks, check]
+    });
+  }
+  positive(message) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: false,
+      message: errorUtil.toString(message)
+    });
+  }
+  negative(message) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: false,
+      message: errorUtil.toString(message)
+    });
+  }
+  nonpositive(message) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: true,
+      message: errorUtil.toString(message)
+    });
+  }
+  nonnegative(message) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: true,
+      message: errorUtil.toString(message)
+    });
+  }
+  multipleOf(value, message) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value,
+      message: errorUtil.toString(message)
+    });
+  }
+  get minValue() {
+    let min = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "min") {
+        if (min === null || ch.value > min)
+          min = ch.value;
+      }
+    }
+    return min;
+  }
+  get maxValue() {
+    let max = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "max") {
+        if (max === null || ch.value < max)
+          max = ch.value;
+      }
+    }
+    return max;
   }
 };
 ZodBigInt.create = (params2) => {
+  var _a;
   return new ZodBigInt({
+    checks: [],
     typeName: ZodFirstPartyTypeKind.ZodBigInt,
+    coerce: (_a = params2 === null || params2 === void 0 ? void 0 : params2.coerce) !== null && _a !== void 0 ? _a : false,
     ...processCreateParams(params2)
   });
 };
 var ZodBoolean = class extends ZodType {
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = Boolean(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.boolean) {
       const ctx = this._getOrReturnCtx(input);
@@ -2543,11 +3005,15 @@ var ZodBoolean = class extends ZodType {
 ZodBoolean.create = (params2) => {
   return new ZodBoolean({
     typeName: ZodFirstPartyTypeKind.ZodBoolean,
+    coerce: (params2 === null || params2 === void 0 ? void 0 : params2.coerce) || false,
     ...processCreateParams(params2)
   });
 };
 var ZodDate = class extends ZodType {
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = new Date(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -2575,6 +3041,7 @@ var ZodDate = class extends ZodType {
             code: ZodIssueCode.too_small,
             message: check.message,
             inclusive: true,
+            exact: false,
             minimum: check.value,
             type: "date"
           });
@@ -2587,6 +3054,7 @@ var ZodDate = class extends ZodType {
             code: ZodIssueCode.too_big,
             message: check.message,
             inclusive: true,
+            exact: false,
             maximum: check.value,
             type: "date"
           });
@@ -2645,10 +3113,32 @@ var ZodDate = class extends ZodType {
 ZodDate.create = (params2) => {
   return new ZodDate({
     checks: [],
+    coerce: (params2 === null || params2 === void 0 ? void 0 : params2.coerce) || false,
     typeName: ZodFirstPartyTypeKind.ZodDate,
     ...processCreateParams(params2)
   });
 };
+var ZodSymbol = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.symbol) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.symbol,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+ZodSymbol.create = (params2) => {
+  return new ZodSymbol({
+    typeName: ZodFirstPartyTypeKind.ZodSymbol,
+    ...processCreateParams(params2)
+  });
+};
 var ZodUndefined = class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
@@ -2771,6 +3261,22 @@ var ZodArray = class extends ZodType {
       });
       return INVALID;
     }
+    if (def2.exactLength !== null) {
+      const tooBig = ctx.data.length > def2.exactLength.value;
+      const tooSmall = ctx.data.length < def2.exactLength.value;
+      if (tooBig || tooSmall) {
+        addIssueToContext(ctx, {
+          code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
+          minimum: tooSmall ? def2.exactLength.value : void 0,
+          maximum: tooBig ? def2.exactLength.value : void 0,
+          type: "array",
+          inclusive: true,
+          exact: true,
+          message: def2.exactLength.message
+        });
+        status.dirty();
+      }
+    }
     if (def2.minLength !== null) {
       if (ctx.data.length < def2.minLength.value) {
         addIssueToContext(ctx, {
@@ -2778,6 +3284,7 @@ var ZodArray = class extends ZodType {
           minimum: def2.minLength.value,
           type: "array",
           inclusive: true,
+          exact: false,
           message: def2.minLength.message
         });
         status.dirty();
@@ -2790,19 +3297,20 @@ var ZodArray = class extends ZodType {
           maximum: def2.maxLength.value,
           type: "array",
           inclusive: true,
+          exact: false,
           message: def2.maxLength.message
         });
         status.dirty();
       }
     }
     if (ctx.common.async) {
-      return Promise.all(ctx.data.map((item, i) => {
+      return Promise.all([...ctx.data].map((item, i) => {
         return def2.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       })).then((result2) => {
         return ParseStatus.mergeArray(status, result2);
       });
     }
-    const result = ctx.data.map((item, i) => {
+    const result = [...ctx.data].map((item, i) => {
       return def2.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
     return ParseStatus.mergeArray(status, result);
@@ -2823,7 +3331,10 @@ var ZodArray = class extends ZodType {
     });
   }
   length(len, message) {
-    return this.min(len, message).max(len, message);
+    return new ZodArray({
+      ...this._def,
+      exactLength: { value: len, message: errorUtil.toString(message) }
+    });
   }
   nonempty(message) {
     return this.min(1, message);
@@ -2834,28 +3345,11 @@ ZodArray.create = (schema2, params2) => {
     type: schema2,
     minLength: null,
     maxLength: null,
+    exactLength: null,
     typeName: ZodFirstPartyTypeKind.ZodArray,
     ...processCreateParams(params2)
   });
 };
-var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
-    return {
-      ...first,
-      ...second
-    };
-  };
-})(objectUtil || (objectUtil = {}));
-var AugmentFactory = (def2) => (augmentation) => {
-  return new ZodObject({
-    ...def2,
-    shape: () => ({
-      ...def2.shape(),
-      ...augmentation
-    })
-  });
-};
 function deepPartialify(schema2) {
   if (schema2 instanceof ZodObject) {
     const newShape = {};
@@ -2868,7 +3362,10 @@ function deepPartialify(schema2) {
       shape: () => newShape
     });
   } else if (schema2 instanceof ZodArray) {
-    return ZodArray.create(deepPartialify(schema2.element));
+    return new ZodArray({
+      ...schema2._def,
+      type: deepPartialify(schema2.element)
+    });
   } else if (schema2 instanceof ZodOptional) {
     return ZodOptional.create(deepPartialify(schema2.unwrap()));
   } else if (schema2 instanceof ZodNullable) {
@@ -2884,8 +3381,7 @@ var ZodObject = class extends ZodType {
     super(...arguments);
     this._cached = null;
     this.nonstrict = this.passthrough;
-    this.augment = AugmentFactory(this._def);
-    this.extend = AugmentFactory(this._def);
+    this.augment = this.extend;
   }
   _getCached() {
     if (this._cached !== null)
@@ -3014,18 +3510,30 @@ var ZodObject = class extends ZodType {
       unknownKeys: "passthrough"
     });
   }
-  setKey(key, schema2) {
-    return this.augment({ [key]: schema2 });
+  extend(augmentation) {
+    return new ZodObject({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...augmentation
+      })
+    });
   }
   merge(merging) {
     const merged = new ZodObject({
       unknownKeys: merging._def.unknownKeys,
       catchall: merging._def.catchall,
-      shape: () => objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+      shape: () => ({
+        ...this._def.shape(),
+        ...merging._def.shape()
+      }),
       typeName: ZodFirstPartyTypeKind.ZodObject
     });
     return merged;
   }
+  setKey(key, schema2) {
+    return this.augment({ [key]: schema2 });
+  }
   catchall(index) {
     return new ZodObject({
       ...this._def,
@@ -3034,9 +3542,10 @@ var ZodObject = class extends ZodType {
   }
   pick(mask) {
     const shape = {};
-    util.objectKeys(mask).map((key) => {
-      if (this.shape[key])
+    util.objectKeys(mask).forEach((key) => {
+      if (mask[key] && this.shape[key]) {
         shape[key] = this.shape[key];
+      }
     });
     return new ZodObject({
       ...this._def,
@@ -3045,8 +3554,8 @@ var ZodObject = class extends ZodType {
   }
   omit(mask) {
     const shape = {};
-    util.objectKeys(this.shape).map((key) => {
-      if (util.objectKeys(mask).indexOf(key) === -1) {
+    util.objectKeys(this.shape).forEach((key) => {
+      if (!mask[key]) {
         shape[key] = this.shape[key];
       }
     });
@@ -3060,39 +3569,33 @@ var ZodObject = class extends ZodType {
   }
   partial(mask) {
     const newShape = {};
-    if (mask) {
-      util.objectKeys(this.shape).map((key) => {
-        if (util.objectKeys(mask).indexOf(key) === -1) {
-          newShape[key] = this.shape[key];
-        } else {
-          newShape[key] = this.shape[key].optional();
-        }
-      });
-      return new ZodObject({
-        ...this._def,
-        shape: () => newShape
-      });
-    } else {
-      for (const key in this.shape) {
-        const fieldSchema = this.shape[key];
+    util.objectKeys(this.shape).forEach((key) => {
+      const fieldSchema = this.shape[key];
+      if (mask && !mask[key]) {
+        newShape[key] = fieldSchema;
+      } else {
         newShape[key] = fieldSchema.optional();
       }
-    }
+    });
     return new ZodObject({
       ...this._def,
       shape: () => newShape
     });
   }
-  required() {
+  required(mask) {
     const newShape = {};
-    for (const key in this.shape) {
-      const fieldSchema = this.shape[key];
-      let newField = fieldSchema;
-      while (newField instanceof ZodOptional) {
-        newField = newField._def.innerType;
+    util.objectKeys(this.shape).forEach((key) => {
+      if (mask && !mask[key]) {
+        newShape[key] = this.shape[key];
+      } else {
+        const fieldSchema = this.shape[key];
+        let newField = fieldSchema;
+        while (newField instanceof ZodOptional) {
+          newField = newField._def.innerType;
+        }
+        newShape[key] = newField;
       }
-      newShape[key] = newField;
-    }
+    });
     return new ZodObject({
       ...this._def,
       shape: () => newShape
@@ -3220,6 +3723,27 @@ ZodUnion.create = (types, params2) => {
     ...processCreateParams(params2)
   });
 };
+var getDiscriminator = (type) => {
+  if (type instanceof ZodLazy) {
+    return getDiscriminator(type.schema);
+  } else if (type instanceof ZodEffects) {
+    return getDiscriminator(type.innerType());
+  } else if (type instanceof ZodLiteral) {
+    return [type.value];
+  } else if (type instanceof ZodEnum) {
+    return type.options;
+  } else if (type instanceof ZodNativeEnum) {
+    return Object.keys(type.enum);
+  } else if (type instanceof ZodDefault) {
+    return getDiscriminator(type._def.innerType);
+  } else if (type instanceof ZodUndefined) {
+    return [void 0];
+  } else if (type instanceof ZodNull) {
+    return [null];
+  } else {
+    return null;
+  }
+};
 var ZodDiscriminatedUnion = class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
@@ -3233,11 +3757,11 @@ var ZodDiscriminatedUnion = class extends ZodType {
     }
     const discriminator = this.discriminator;
     const discriminatorValue = ctx.data[discriminator];
-    const option = this.options.get(discriminatorValue);
+    const option = this.optionsMap.get(discriminatorValue);
     if (!option) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
-        options: this.validDiscriminatorValues,
+        options: Array.from(this.optionsMap.keys()),
         path: [discriminator]
       });
       return INVALID;
@@ -3259,29 +3783,31 @@ var ZodDiscriminatedUnion = class extends ZodType {
   get discriminator() {
     return this._def.discriminator;
   }
-  get validDiscriminatorValues() {
-    return Array.from(this.options.keys());
-  }
   get options() {
     return this._def.options;
   }
-  static create(discriminator, types, params2) {
-    const options = /* @__PURE__ */ new Map();
-    try {
-      types.forEach((type) => {
-        const discriminatorValue = type.shape[discriminator].value;
-        options.set(discriminatorValue, type);
-      });
-    } catch (e) {
-      throw new Error("The discriminator value could not be extracted from all the provided schemas");
-    }
-    if (options.size !== types.length) {
-      throw new Error("Some of the discriminator values are not unique");
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+  static create(discriminator, options, params2) {
+    const optionsMap = /* @__PURE__ */ new Map();
+    for (const type of options) {
+      const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+      if (!discriminatorValues) {
+        throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
+      }
+      for (const value of discriminatorValues) {
+        if (optionsMap.has(value)) {
+          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
+        }
+        optionsMap.set(value, type);
+      }
     }
     return new ZodDiscriminatedUnion({
       typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
       discriminator,
       options,
+      optionsMap,
       ...processCreateParams(params2)
     });
   }
@@ -3393,6 +3919,7 @@ var ZodTuple = class extends ZodType {
         code: ZodIssueCode.too_small,
         minimum: this._def.items.length,
         inclusive: true,
+        exact: false,
         type: "array"
       });
       return INVALID;
@@ -3403,11 +3930,12 @@ var ZodTuple = class extends ZodType {
         code: ZodIssueCode.too_big,
         maximum: this._def.items.length,
         inclusive: true,
+        exact: false,
         type: "array"
       });
       status.dirty();
     }
-    const items = ctx.data.map((item, itemIndex) => {
+    const items = [...ctx.data].map((item, itemIndex) => {
       const schema2 = this._def.items[itemIndex] || this._def.rest;
       if (!schema2)
         return null;
@@ -3573,6 +4101,7 @@ var ZodSet = class extends ZodType {
           minimum: def2.minSize.value,
           type: "set",
           inclusive: true,
+          exact: false,
           message: def2.minSize.message
         });
         status.dirty();
@@ -3585,6 +4114,7 @@ var ZodSet = class extends ZodType {
           maximum: def2.maxSize.value,
           type: "set",
           inclusive: true,
+          exact: false,
           message: def2.maxSize.message
         });
         status.dirty();
@@ -3772,6 +4302,7 @@ var ZodLiteral = class extends ZodType {
     if (input.data !== this._def.value) {
       const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
+        received: ctx.data,
         code: ZodIssueCode.invalid_literal,
         expected: this._def.value
       });
@@ -3845,6 +4376,12 @@ var ZodEnum = class extends ZodType {
     }
     return enumValues;
   }
+  extract(values) {
+    return ZodEnum.create(values);
+  }
+  exclude(values) {
+    return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)));
+  }
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
@@ -3883,6 +4420,9 @@ ZodNativeEnum.create = (values, params2) => {
   });
 };
 var ZodPromise = class extends ZodType {
+  unwrap() {
+    return this._def.type;
+  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
@@ -3913,6 +4453,9 @@ var ZodEffects = class extends ZodType {
   innerType() {
     return this._def.schema;
   }
+  sourceType() {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
@@ -4075,14 +4618,68 @@ var ZodDefault = class extends ZodType {
       parent: ctx
     });
   }
-  removeDefault() {
+  removeDefault() {
+    return this._def.innerType;
+  }
+};
+ZodDefault.create = (type, params2) => {
+  return new ZodDefault({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params2.default === "function" ? params2.default : () => params2.default,
+    ...processCreateParams(params2)
+  });
+};
+var ZodCatch = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const newCtx = {
+      ...ctx,
+      common: {
+        ...ctx.common,
+        issues: []
+      }
+    };
+    const result = this._def.innerType._parse({
+      data: newCtx.data,
+      path: newCtx.path,
+      parent: {
+        ...newCtx
+      }
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+            get error() {
+              return new ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
+      });
+    } else {
+      return {
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.catchValue({
+          get error() {
+            return new ZodError(newCtx.common.issues);
+          },
+          input: newCtx.data
+        })
+      };
+    }
+  }
+  removeCatch() {
     return this._def.innerType;
   }
 };
-ZodDefault.create = (type, params2) => {
-  return new ZodOptional({
+ZodCatch.create = (type, params2) => {
+  return new ZodCatch({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodOptional,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    catchValue: typeof params2.catch === "function" ? params2.catch : () => params2.catch,
     ...processCreateParams(params2)
   });
 };
@@ -4122,13 +4719,70 @@ var ZodBranded = class extends ZodType {
     return this._def.type;
   }
 };
+var ZodPipeline = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
+          status.dirty();
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
+      } else {
+        return this._def.out._parseSync({
+          data: inResult.value,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+    }
+  }
+  static create(a, b) {
+    return new ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
+  }
+};
 var custom = (check, params2 = {}, fatal) => {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
+      var _a, _b;
       if (!check(data)) {
-        const p = typeof params2 === "function" ? params2(data) : params2;
+        const p = typeof params2 === "function" ? params2(data) : typeof params2 === "string" ? { message: params2 } : params2;
+        const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
         const p2 = typeof p === "string" ? { message: p } : p;
-        ctx.addIssue({ code: "custom", ...p2, fatal });
+        ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
       }
     });
   return ZodAny.create();
@@ -4144,6 +4798,7 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
   ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
   ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
   ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
   ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
   ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
@@ -4168,18 +4823,21 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
   ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
   ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
   ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
   ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 var instanceOfType = (cls, params2 = {
   message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params2, true);
+}) => custom((data) => data instanceof cls, params2);
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
 var nanType = ZodNaN.create;
 var bigIntType = ZodBigInt.create;
 var booleanType = ZodBoolean.create;
 var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
 var undefinedType = ZodUndefined.create;
 var nullType = ZodNull.create;
 var anyType = ZodAny.create;
@@ -4206,14 +4864,23 @@ var effectsType = ZodEffects.create;
 var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
 var ostring = () => stringType().optional();
 var onumber = () => numberType().optional();
 var oboolean = () => booleanType().optional();
+var coerce2 = {
+  string: (arg) => ZodString.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  }),
+  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+};
 var NEVER = INVALID;
-var mod = /* @__PURE__ */ Object.freeze({
+var z = /* @__PURE__ */ Object.freeze({
   __proto__: null,
-  getParsedType,
-  ZodParsedType,
   defaultErrorMap: errorMap,
   setErrorMap,
   getErrorMap,
@@ -4228,12 +4895,21 @@ var mod = /* @__PURE__ */ Object.freeze({
   isDirty,
   isValid,
   isAsync,
+  get util() {
+    return util;
+  },
+  get objectUtil() {
+    return objectUtil;
+  },
+  ZodParsedType,
+  getParsedType,
   ZodType,
   ZodString,
   ZodNumber,
   ZodBigInt,
   ZodBoolean,
   ZodDate,
+  ZodSymbol,
   ZodUndefined,
   ZodNull,
   ZodAny,
@@ -4241,9 +4917,6 @@ var mod = /* @__PURE__ */ Object.freeze({
   ZodNever,
   ZodVoid,
   ZodArray,
-  get objectUtil() {
-    return objectUtil;
-  },
   ZodObject,
   ZodUnion,
   ZodDiscriminatedUnion,
@@ -4263,9 +4936,11 @@ var mod = /* @__PURE__ */ Object.freeze({
   ZodOptional,
   ZodNullable,
   ZodDefault,
+  ZodCatch,
   ZodNaN,
   BRAND,
   ZodBranded,
+  ZodPipeline,
   custom,
   Schema: ZodType,
   ZodSchema: ZodType,
@@ -4273,6 +4948,7 @@ var mod = /* @__PURE__ */ Object.freeze({
   get ZodFirstPartyTypeKind() {
     return ZodFirstPartyTypeKind;
   },
+  coerce: coerce2,
   any: anyType,
   array: arrayType,
   bigint: bigIntType,
@@ -4298,12 +4974,14 @@ var mod = /* @__PURE__ */ Object.freeze({
   onumber,
   optional: optionalType,
   ostring,
+  pipeline: pipelineType,
   preprocess: preprocessType,
   promise: promiseType,
   record: recordType,
   set: setType,
   strictObject: strictObjectType,
   string: stringType,
+  symbol: symbolType,
   transformer: effectsType,
   tuple: tupleType,
   "undefined": undefinedType,
@@ -4317,16 +4995,16 @@ var mod = /* @__PURE__ */ Object.freeze({
 });
 
 // ../common-web/src/types.ts
-var cidSchema = mod.any().refine((obj) => CID.asCID(obj) !== null, {
+var cidSchema = z.any().refine((obj) => CID.asCID(obj) !== null, {
   message: "Not a CID"
 }).transform((obj) => CID.asCID(obj));
 var schema = {
   cid: cidSchema,
-  bytes: mod.instanceof(Uint8Array),
-  string: mod.string(),
-  array: mod.array(mod.unknown()),
-  map: mod.record(mod.string(), mod.unknown()),
-  unknown: mod.unknown()
+  bytes: z.instanceof(Uint8Array),
+  string: z.string(),
+  array: z.array(z.unknown()),
+  map: z.record(z.string(), z.unknown()),
+  unknown: z.unknown()
 };
 var def = {
   cid: {
@@ -5731,22 +6409,22 @@ function parseRelative(str) {
 }
 
 // ../lexicon/src/types.ts
-var lexBoolean = mod.object({
-  type: mod.literal("boolean"),
-  description: mod.string().optional(),
-  default: mod.boolean().optional(),
-  const: mod.boolean().optional()
+var lexBoolean = z.object({
+  type: z.literal("boolean"),
+  description: z.string().optional(),
+  default: z.boolean().optional(),
+  const: z.boolean().optional()
 });
-var lexInteger = mod.object({
-  type: mod.literal("integer"),
-  description: mod.string().optional(),
-  default: mod.number().int().optional(),
-  minimum: mod.number().int().optional(),
-  maximum: mod.number().int().optional(),
-  enum: mod.number().int().array().optional(),
-  const: mod.number().int().optional()
+var lexInteger = z.object({
+  type: z.literal("integer"),
+  description: z.string().optional(),
+  default: z.number().int().optional(),
+  minimum: z.number().int().optional(),
+  maximum: z.number().int().optional(),
+  enum: z.number().int().array().optional(),
+  const: z.number().int().optional()
 });
-var lexStringFormat = mod.enum([
+var lexStringFormat = z.enum([
   "datetime",
   "uri",
   "at-uri",
@@ -5756,132 +6434,132 @@ var lexStringFormat = mod.enum([
   "nsid",
   "cid"
 ]);
-var lexString = mod.object({
-  type: mod.literal("string"),
+var lexString = z.object({
+  type: z.literal("string"),
   format: lexStringFormat.optional(),
-  description: mod.string().optional(),
-  default: mod.string().optional(),
-  minLength: mod.number().int().optional(),
-  maxLength: mod.number().int().optional(),
-  minGraphemes: mod.number().int().optional(),
-  maxGraphemes: mod.number().int().optional(),
-  enum: mod.string().array().optional(),
-  const: mod.string().optional(),
-  knownValues: mod.string().array().optional()
+  description: z.string().optional(),
+  default: z.string().optional(),
+  minLength: z.number().int().optional(),
+  maxLength: z.number().int().optional(),
+  minGraphemes: z.number().int().optional(),
+  maxGraphemes: z.number().int().optional(),
+  enum: z.string().array().optional(),
+  const: z.string().optional(),
+  knownValues: z.string().array().optional()
 });
-var lexUnknown = mod.object({
-  type: mod.literal("unknown"),
-  description: mod.string().optional()
+var lexUnknown = z.object({
+  type: z.literal("unknown"),
+  description: z.string().optional()
 });
-var lexPrimitive = mod.discriminatedUnion("type", [
+var lexPrimitive = z.discriminatedUnion("type", [
   lexBoolean,
   lexInteger,
   lexString,
   lexUnknown
 ]);
-var lexBytes = mod.object({
-  type: mod.literal("bytes"),
-  description: mod.string().optional(),
-  maxLength: mod.number().optional(),
-  minLength: mod.number().optional()
+var lexBytes = z.object({
+  type: z.literal("bytes"),
+  description: z.string().optional(),
+  maxLength: z.number().optional(),
+  minLength: z.number().optional()
 });
-var lexCidLink = mod.object({
-  type: mod.literal("cid-link"),
-  description: mod.string().optional()
+var lexCidLink = z.object({
+  type: z.literal("cid-link"),
+  description: z.string().optional()
 });
-var lexIpldType = mod.discriminatedUnion("type", [lexBytes, lexCidLink]);
-var lexRef = mod.object({
-  type: mod.literal("ref"),
-  description: mod.string().optional(),
-  ref: mod.string()
+var lexIpldType = z.discriminatedUnion("type", [lexBytes, lexCidLink]);
+var lexRef = z.object({
+  type: z.literal("ref"),
+  description: z.string().optional(),
+  ref: z.string()
 });
-var lexRefUnion = mod.object({
-  type: mod.literal("union"),
-  description: mod.string().optional(),
-  refs: mod.string().array(),
-  closed: mod.boolean().optional()
+var lexRefUnion = z.object({
+  type: z.literal("union"),
+  description: z.string().optional(),
+  refs: z.string().array(),
+  closed: z.boolean().optional()
 });
-var lexRefVariant = mod.discriminatedUnion("type", [lexRef, lexRefUnion]);
-var lexBlob = mod.object({
-  type: mod.literal("blob"),
-  description: mod.string().optional(),
-  accept: mod.string().array().optional(),
-  maxSize: mod.number().optional()
+var lexRefVariant = z.discriminatedUnion("type", [lexRef, lexRefUnion]);
+var lexBlob = z.object({
+  type: z.literal("blob"),
+  description: z.string().optional(),
+  accept: z.string().array().optional(),
+  maxSize: z.number().optional()
 });
-var lexArray = mod.object({
-  type: mod.literal("array"),
-  description: mod.string().optional(),
-  items: mod.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
-  minLength: mod.number().int().optional(),
-  maxLength: mod.number().int().optional()
+var lexArray = z.object({
+  type: z.literal("array"),
+  description: z.string().optional(),
+  items: z.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
+  minLength: z.number().int().optional(),
+  maxLength: z.number().int().optional()
 });
 var lexPrimitiveArray = lexArray.merge(
-  mod.object({
+  z.object({
     items: lexPrimitive
   })
 );
-var lexToken = mod.object({
-  type: mod.literal("token"),
-  description: mod.string().optional()
+var lexToken = z.object({
+  type: z.literal("token"),
+  description: z.string().optional()
 });
-var lexObject = mod.object({
-  type: mod.literal("object"),
-  description: mod.string().optional(),
-  required: mod.string().array().optional(),
-  nullable: mod.string().array().optional(),
-  properties: mod.record(
-    mod.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive])
+var lexObject = z.object({
+  type: z.literal("object"),
+  description: z.string().optional(),
+  required: z.string().array().optional(),
+  nullable: z.string().array().optional(),
+  properties: z.record(
+    z.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive])
   ).optional()
 });
-var lexXrpcParameters = mod.object({
-  type: mod.literal("params"),
-  description: mod.string().optional(),
-  required: mod.string().array().optional(),
-  properties: mod.record(mod.union([lexPrimitive, lexPrimitiveArray]))
+var lexXrpcParameters = z.object({
+  type: z.literal("params"),
+  description: z.string().optional(),
+  required: z.string().array().optional(),
+  properties: z.record(z.union([lexPrimitive, lexPrimitiveArray]))
 });
-var lexXrpcBody = mod.object({
-  description: mod.string().optional(),
-  encoding: mod.string(),
-  schema: mod.union([lexRefVariant, lexObject]).optional()
+var lexXrpcBody = z.object({
+  description: z.string().optional(),
+  encoding: z.string(),
+  schema: z.union([lexRefVariant, lexObject]).optional()
 });
-var lexXrpcSubscriptionMessage = mod.object({
-  description: mod.string().optional(),
-  schema: mod.union([lexRefVariant, lexObject]).optional()
+var lexXrpcSubscriptionMessage = z.object({
+  description: z.string().optional(),
+  schema: z.union([lexRefVariant, lexObject]).optional()
 });
-var lexXrpcError = mod.object({
-  name: mod.string(),
-  description: mod.string().optional()
+var lexXrpcError = z.object({
+  name: z.string(),
+  description: z.string().optional()
 });
-var lexXrpcQuery = mod.object({
-  type: mod.literal("query"),
-  description: mod.string().optional(),
+var lexXrpcQuery = z.object({
+  type: z.literal("query"),
+  description: z.string().optional(),
   parameters: lexXrpcParameters.optional(),
   output: lexXrpcBody.optional(),
   errors: lexXrpcError.array().optional()
 });
-var lexXrpcProcedure = mod.object({
-  type: mod.literal("procedure"),
-  description: mod.string().optional(),
+var lexXrpcProcedure = z.object({
+  type: z.literal("procedure"),
+  description: z.string().optional(),
   parameters: lexXrpcParameters.optional(),
   input: lexXrpcBody.optional(),
   output: lexXrpcBody.optional(),
   errors: lexXrpcError.array().optional()
 });
-var lexXrpcSubscription = mod.object({
-  type: mod.literal("subscription"),
-  description: mod.string().optional(),
+var lexXrpcSubscription = z.object({
+  type: z.literal("subscription"),
+  description: z.string().optional(),
   parameters: lexXrpcParameters.optional(),
   message: lexXrpcSubscriptionMessage.optional(),
   infos: lexXrpcError.array().optional(),
   errors: lexXrpcError.array().optional()
 });
-var lexRecord = mod.object({
-  type: mod.literal("record"),
-  description: mod.string().optional(),
-  key: mod.string().optional(),
+var lexRecord = z.object({
+  type: z.literal("record"),
+  description: z.string().optional(),
+  key: z.string().optional(),
   record: lexObject
 });
-var lexUserType = mod.discriminatedUnion("type", [
+var lexUserType = z.discriminatedUnion("type", [
   lexRecord,
   lexXrpcQuery,
   lexXrpcProcedure,
@@ -5897,20 +6575,20 @@ var lexUserType = mod.discriminatedUnion("type", [
   lexCidLink,
   lexUnknown
 ]);
-var lexiconDoc = mod.object({
-  lexicon: mod.literal(1),
-  id: mod.string().refine((v) => NSID.isValid(v), {
+var lexiconDoc = z.object({
+  lexicon: z.literal(1),
+  id: z.string().refine((v) => NSID.isValid(v), {
     message: "Must be a valid NSID"
   }),
-  revision: mod.number().optional(),
-  description: mod.string().optional(),
-  defs: mod.record(lexUserType)
+  revision: z.number().optional(),
+  description: z.string().optional(),
+  defs: z.record(lexUserType)
 }).superRefine((doc, ctx) => {
   for (const defId in doc.defs) {
     const def2 = doc.defs[defId];
     if (defId !== "main" && (def2.type === "record" || def2.type === "procedure" || def2.type === "query" || def2.type === "subscription")) {
       ctx.addIssue({
-        code: mod.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         message: `Records, procedures, queries, and subscriptions must be the main definition.`
       });
     }
@@ -5922,7 +6600,7 @@ function isObj(obj) {
 function hasProp(data, prop) {
   return prop in data;
 }
-var discriminatedObject = mod.object({ $type: mod.string() });
+var discriminatedObject = z.object({ $type: z.string() });
 function isDiscriminatedObject(value) {
   return discriminatedObject.safeParse(value).success;
 }
@@ -6290,17 +6968,17 @@ function unknown(lexicons2, path, def2, value) {
 }
 
 // ../lexicon/src/blob-refs.ts
-var typedJsonBlobRef = mod.object({
-  $type: mod.literal("blob"),
+var typedJsonBlobRef = z.object({
+  $type: z.literal("blob"),
   ref: schema.cid,
-  mimeType: mod.string(),
-  size: mod.number()
+  mimeType: z.string(),
+  size: z.number()
 }).strict();
-var untypedJsonBlobRef = mod.object({
-  cid: mod.string(),
-  mimeType: mod.string()
+var untypedJsonBlobRef = z.object({
+  cid: z.string(),
+  mimeType: z.string()
 }).strict();
-var jsonBlobRef = mod.union([typedJsonBlobRef, untypedJsonBlobRef]);
+var jsonBlobRef = z.union([typedJsonBlobRef, untypedJsonBlobRef]);
 var BlobRef = class {
   constructor(ref, mimeType, size, original) {
     this.ref = ref;
@@ -6818,9 +7496,9 @@ var jsonStringToLex = (val) => {
 };
 
 // ../xrpc/src/types.ts
-var errorResponseBody = mod.object({
-  error: mod.string().optional(),
-  message: mod.string().optional()
+var errorResponseBody = z.object({
+  error: z.string().optional(),
+  message: z.string().optional()
 });
 var ResponseType = /* @__PURE__ */ ((ResponseType2) => {
   ResponseType2[ResponseType2["Unknown"] = 1] = "Unknown";
@@ -10585,6 +11263,10 @@ var schemaDict = {
           muted: {
             type: "boolean"
           },
+          mutedByList: {
+            type: "ref",
+            ref: "lex:app.bsky.graph.defs#listViewBasic"
+          },
           blockedBy: {
             type: "boolean"
           },
@@ -11768,6 +12450,114 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphDefs: {
+    lexicon: 1,
+    id: "app.bsky.graph.defs",
+    defs: {
+      listViewBasic: {
+        type: "object",
+        required: ["uri", "creator", "name", "purpose"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          },
+          name: {
+            type: "string",
+            maxLength: 64,
+            minLength: 1
+          },
+          purpose: {
+            type: "ref",
+            ref: "lex:app.bsky.graph.defs#listPurpose"
+          },
+          avatar: {
+            type: "string"
+          },
+          viewer: {
+            type: "ref",
+            ref: "lex:app.bsky.graph.defs#listViewerState"
+          },
+          indexedAt: {
+            type: "string",
+            format: "datetime"
+          }
+        }
+      },
+      listView: {
+        type: "object",
+        required: ["uri", "creator", "name", "purpose", "indexedAt"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          },
+          creator: {
+            type: "ref",
+            ref: "lex:app.bsky.actor.defs#profileView"
+          },
+          name: {
+            type: "string",
+            maxLength: 64,
+            minLength: 1
+          },
+          purpose: {
+            type: "ref",
+            ref: "lex:app.bsky.graph.defs#listPurpose"
+          },
+          description: {
+            type: "string",
+            maxGraphemes: 300,
+            maxLength: 3e3
+          },
+          descriptionFacets: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:app.bsky.richtext.facet"
+            }
+          },
+          avatar: {
+            type: "string"
+          },
+          viewer: {
+            type: "ref",
+            ref: "lex:app.bsky.graph.defs#listViewerState"
+          },
+          indexedAt: {
+            type: "string",
+            format: "datetime"
+          }
+        }
+      },
+      listItemView: {
+        type: "object",
+        required: ["subject"],
+        properties: {
+          subject: {
+            type: "ref",
+            ref: "lex:app.bsky.actor.defs#profileView"
+          }
+        }
+      },
+      listPurpose: {
+        type: "string",
+        knownValues: ["app.bsky.graph.defs#modlist"]
+      },
+      modlist: {
+        type: "token",
+        description: "A list of actors to apply an aggregate moderation action (mute/block) on"
+      },
+      listViewerState: {
+        type: "object",
+        properties: {
+          muted: {
+            type: "boolean"
+          }
+        }
+      }
+    }
+  },
   AppBskyGraphFollow: {
     lexicon: 1,
     id: "app.bsky.graph.follow",
@@ -11940,6 +12730,149 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphGetList: {
+    lexicon: 1,
+    id: "app.bsky.graph.getList",
+    defs: {
+      main: {
+        type: "query",
+        description: "Fetch a list of actors",
+        parameters: {
+          type: "params",
+          required: ["list"],
+          properties: {
+            list: {
+              type: "string",
+              format: "at-uri"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["list", "items"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              list: {
+                type: "ref",
+                ref: "lex:app.bsky.graph.defs#listView"
+              },
+              items: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.graph.defs#listItemView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyGraphGetListMutes: {
+    lexicon: 1,
+    id: "app.bsky.graph.getListMutes",
+    defs: {
+      main: {
+        type: "query",
+        description: "Which lists is the requester's account muting?",
+        parameters: {
+          type: "params",
+          properties: {
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["lists"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              lists: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.graph.defs#listView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyGraphGetLists: {
+    lexicon: 1,
+    id: "app.bsky.graph.getLists",
+    defs: {
+      main: {
+        type: "query",
+        description: "Fetch a list of lists that belong to an actor",
+        parameters: {
+          type: "params",
+          required: ["actor"],
+          properties: {
+            actor: {
+              type: "string",
+              format: "at-identifier"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["lists"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              lists: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.graph.defs#listView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyGraphGetMutes: {
     lexicon: 1,
     id: "app.bsky.graph.getMutes",
@@ -11983,6 +12916,82 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphList: {
+    lexicon: 1,
+    id: "app.bsky.graph.list",
+    defs: {
+      main: {
+        type: "record",
+        description: "A declaration of a list of actors.",
+        key: "tid",
+        record: {
+          type: "object",
+          required: ["name", "purpose", "createdAt"],
+          properties: {
+            purpose: {
+              type: "ref",
+              ref: "lex:app.bsky.graph.defs#listPurpose"
+            },
+            name: {
+              type: "string",
+              maxLength: 64,
+              minLength: 1
+            },
+            description: {
+              type: "string",
+              maxGraphemes: 300,
+              maxLength: 3e3
+            },
+            descriptionFacets: {
+              type: "array",
+              items: {
+                type: "ref",
+                ref: "lex:app.bsky.richtext.facet"
+              }
+            },
+            avatar: {
+              type: "blob",
+              accept: ["image/png", "image/jpeg"],
+              maxSize: 1e6
+            },
+            createdAt: {
+              type: "string",
+              format: "datetime"
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyGraphListitem: {
+    lexicon: 1,
+    id: "app.bsky.graph.listitem",
+    defs: {
+      main: {
+        type: "record",
+        description: "An item under a declared list of actors",
+        key: "tid",
+        record: {
+          type: "object",
+          required: ["subject", "list", "createdAt"],
+          properties: {
+            subject: {
+              type: "string",
+              format: "did"
+            },
+            list: {
+              type: "string",
+              format: "at-uri"
+            },
+            createdAt: {
+              type: "string",
+              format: "datetime"
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyGraphMuteActor: {
     lexicon: 1,
     id: "app.bsky.graph.muteActor",
@@ -12006,6 +13015,29 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphMuteActorList: {
+    lexicon: 1,
+    id: "app.bsky.graph.muteActorList",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Mute a list of actors.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["list"],
+            properties: {
+              list: {
+                type: "string",
+                format: "at-uri"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyGraphUnmuteActor: {
     lexicon: 1,
     id: "app.bsky.graph.unmuteActor",
@@ -12029,6 +13061,29 @@ var schemaDict = {
       }
     }
   },
+  AppBskyGraphUnmuteActorList: {
+    lexicon: 1,
+    id: "app.bsky.graph.unmuteActorList",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Unmute a list of actors.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["list"],
+            properties: {
+              list: {
+                type: "string",
+                format: "at-uri"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyNotificationGetUnreadCount: {
     lexicon: 1,
     id: "app.bsky.notification.getUnreadCount",
@@ -13351,12 +14406,45 @@ function toKnownErr70(e) {
   return e;
 }
 
+// src/client/types/app/bsky/graph/getList.ts
+var getList_exports = {};
+__export(getList_exports, {
+  toKnownErr: () => toKnownErr71
+});
+function toKnownErr71(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/graph/getListMutes.ts
+var getListMutes_exports = {};
+__export(getListMutes_exports, {
+  toKnownErr: () => toKnownErr72
+});
+function toKnownErr72(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/graph/getLists.ts
+var getLists_exports = {};
+__export(getLists_exports, {
+  toKnownErr: () => toKnownErr73
+});
+function toKnownErr73(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
 // src/client/types/app/bsky/graph/getMutes.ts
 var getMutes_exports = {};
 __export(getMutes_exports, {
-  toKnownErr: () => toKnownErr71
+  toKnownErr: () => toKnownErr74
 });
-function toKnownErr71(e) {
+function toKnownErr74(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13365,9 +14453,20 @@ function toKnownErr71(e) {
 // src/client/types/app/bsky/graph/muteActor.ts
 var muteActor_exports = {};
 __export(muteActor_exports, {
-  toKnownErr: () => toKnownErr72
+  toKnownErr: () => toKnownErr75
 });
-function toKnownErr72(e) {
+function toKnownErr75(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/graph/muteActorList.ts
+var muteActorList_exports = {};
+__export(muteActorList_exports, {
+  toKnownErr: () => toKnownErr76
+});
+function toKnownErr76(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13376,9 +14475,20 @@ function toKnownErr72(e) {
 // src/client/types/app/bsky/graph/unmuteActor.ts
 var unmuteActor_exports = {};
 __export(unmuteActor_exports, {
-  toKnownErr: () => toKnownErr73
+  toKnownErr: () => toKnownErr77
 });
-function toKnownErr73(e) {
+function toKnownErr77(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// src/client/types/app/bsky/graph/unmuteActorList.ts
+var unmuteActorList_exports = {};
+__export(unmuteActorList_exports, {
+  toKnownErr: () => toKnownErr78
+});
+function toKnownErr78(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13387,9 +14497,9 @@ function toKnownErr73(e) {
 // src/client/types/app/bsky/notification/getUnreadCount.ts
 var getUnreadCount_exports = {};
 __export(getUnreadCount_exports, {
-  toKnownErr: () => toKnownErr74
+  toKnownErr: () => toKnownErr79
 });
-function toKnownErr74(e) {
+function toKnownErr79(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13399,10 +14509,10 @@ function toKnownErr74(e) {
 var listNotifications_exports = {};
 __export(listNotifications_exports, {
   isNotification: () => isNotification,
-  toKnownErr: () => toKnownErr75,
+  toKnownErr: () => toKnownErr80,
   validateNotification: () => validateNotification
 });
-function toKnownErr75(e) {
+function toKnownErr80(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13420,9 +14530,9 @@ function validateNotification(v) {
 // src/client/types/app/bsky/notification/updateSeen.ts
 var updateSeen_exports = {};
 __export(updateSeen_exports, {
-  toKnownErr: () => toKnownErr76
+  toKnownErr: () => toKnownErr81
 });
-function toKnownErr76(e) {
+function toKnownErr81(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -13431,9 +14541,9 @@ function toKnownErr76(e) {
 // src/client/types/app/bsky/unspecced/getPopular.ts
 var getPopular_exports = {};
 __export(getPopular_exports, {
-  toKnownErr: () => toKnownErr77
+  toKnownErr: () => toKnownErr82
 });
-function toKnownErr77(e) {
+function toKnownErr82(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -14053,6 +15163,45 @@ function validateRecord6(v) {
   return lexicons.validate("app.bsky.graph.block#main", v);
 }
 
+// src/client/types/app/bsky/graph/defs.ts
+var defs_exports7 = {};
+__export(defs_exports7, {
+  MODLIST: () => MODLIST,
+  isListItemView: () => isListItemView,
+  isListView: () => isListView,
+  isListViewBasic: () => isListViewBasic,
+  isListViewerState: () => isListViewerState,
+  validateListItemView: () => validateListItemView,
+  validateListView: () => validateListView,
+  validateListViewBasic: () => validateListViewBasic,
+  validateListViewerState: () => validateListViewerState
+});
+function isListViewBasic(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.defs#listViewBasic";
+}
+function validateListViewBasic(v) {
+  return lexicons.validate("app.bsky.graph.defs#listViewBasic", v);
+}
+function isListView(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.defs#listView";
+}
+function validateListView(v) {
+  return lexicons.validate("app.bsky.graph.defs#listView", v);
+}
+function isListItemView(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.defs#listItemView";
+}
+function validateListItemView(v) {
+  return lexicons.validate("app.bsky.graph.defs#listItemView", v);
+}
+var MODLIST = "app.bsky.graph.defs#modlist";
+function isListViewerState(v) {
+  return isObj2(v) && hasProp2(v, "$type") && v.$type === "app.bsky.graph.defs#listViewerState";
+}
+function validateListViewerState(v) {
+  return lexicons.validate("app.bsky.graph.defs#listViewerState", v);
+}
+
 // src/client/types/app/bsky/graph/follow.ts
 var follow_exports = {};
 __export(follow_exports, {
@@ -14066,6 +15215,32 @@ function validateRecord7(v) {
   return lexicons.validate("app.bsky.graph.follow#main", v);
 }
 
+// src/client/types/app/bsky/graph/list.ts
+var list_exports = {};
+__export(list_exports, {
+  isRecord: () => isRecord8,
+  validateRecord: () => validateRecord8
+});
+function isRecord8(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.list#main" || v.$type === "app.bsky.graph.list");
+}
+function validateRecord8(v) {
+  return lexicons.validate("app.bsky.graph.list#main", v);
+}
+
+// src/client/types/app/bsky/graph/listitem.ts
+var listitem_exports = {};
+__export(listitem_exports, {
+  isRecord: () => isRecord9,
+  validateRecord: () => validateRecord9
+});
+function isRecord9(v) {
+  return isObj2(v) && hasProp2(v, "$type") && (v.$type === "app.bsky.graph.listitem#main" || v.$type === "app.bsky.graph.listitem");
+}
+function validateRecord9(v) {
+  return lexicons.validate("app.bsky.graph.listitem#main", v);
+}
+
 // src/client/types/app/bsky/richtext/facet.ts
 var facet_exports = {};
 __export(facet_exports, {
@@ -14118,6 +15293,9 @@ var COM_ATPROTO_MODERATION = {
   DefsReasonRude: "com.atproto.moderation.defs#reasonRude",
   DefsReasonOther: "com.atproto.moderation.defs#reasonOther"
 };
+var APP_BSKY_GRAPH = {
+  DefsModlist: "app.bsky.graph.defs#modlist"
+};
 var AtpBaseClient = class {
   constructor() {
     this.xrpc = new Client();
@@ -14716,6 +15894,8 @@ var GraphNS = class {
     this._service = service;
     this.block = new BlockRecord(service);
     this.follow = new FollowRecord(service);
+    this.list = new ListRecord(service);
+    this.listitem = new ListitemRecord(service);
   }
   getBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getBlocks", params2, void 0, opts).catch((e) => {
@@ -14732,19 +15912,44 @@ var GraphNS = class {
       throw toKnownErr70(e);
     });
   }
+  getList(params2, opts) {
+    return this._service.xrpc.call("app.bsky.graph.getList", params2, void 0, opts).catch((e) => {
+      throw toKnownErr71(e);
+    });
+  }
+  getListMutes(params2, opts) {
+    return this._service.xrpc.call("app.bsky.graph.getListMutes", params2, void 0, opts).catch((e) => {
+      throw toKnownErr72(e);
+    });
+  }
+  getLists(params2, opts) {
+    return this._service.xrpc.call("app.bsky.graph.getLists", params2, void 0, opts).catch((e) => {
+      throw toKnownErr73(e);
+    });
+  }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr71(e);
+      throw toKnownErr74(e);
     });
   }
   muteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr72(e);
+      throw toKnownErr75(e);
+    });
+  }
+  muteActorList(data, opts) {
+    return this._service.xrpc.call("app.bsky.graph.muteActorList", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr76(e);
     });
   }
   unmuteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr73(e);
+      throw toKnownErr77(e);
+    });
+  }
+  unmuteActorList(data, opts) {
+    return this._service.xrpc.call("app.bsky.graph.unmuteActorList", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr78(e);
     });
   }
 };
@@ -14822,23 +16027,97 @@ var FollowRecord = class {
     );
   }
 };
+var ListRecord = class {
+  constructor(service) {
+    this._service = service;
+  }
+  async list(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.listRecords", {
+      collection: "app.bsky.graph.list",
+      ...params2
+    });
+    return res.data;
+  }
+  async get(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.getRecord", {
+      collection: "app.bsky.graph.list",
+      ...params2
+    });
+    return res.data;
+  }
+  async create(params2, record, headers) {
+    record.$type = "app.bsky.graph.list";
+    const res = await this._service.xrpc.call(
+      "com.atproto.repo.createRecord",
+      void 0,
+      { collection: "app.bsky.graph.list", ...params2, record },
+      { encoding: "application/json", headers }
+    );
+    return res.data;
+  }
+  async delete(params2, headers) {
+    await this._service.xrpc.call(
+      "com.atproto.repo.deleteRecord",
+      void 0,
+      { collection: "app.bsky.graph.list", ...params2 },
+      { headers }
+    );
+  }
+};
+var ListitemRecord = class {
+  constructor(service) {
+    this._service = service;
+  }
+  async list(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.listRecords", {
+      collection: "app.bsky.graph.listitem",
+      ...params2
+    });
+    return res.data;
+  }
+  async get(params2) {
+    const res = await this._service.xrpc.call("com.atproto.repo.getRecord", {
+      collection: "app.bsky.graph.listitem",
+      ...params2
+    });
+    return res.data;
+  }
+  async create(params2, record, headers) {
+    record.$type = "app.bsky.graph.listitem";
+    const res = await this._service.xrpc.call(
+      "com.atproto.repo.createRecord",
+      void 0,
+      { collection: "app.bsky.graph.listitem", ...params2, record },
+      { encoding: "application/json", headers }
+    );
+    return res.data;
+  }
+  async delete(params2, headers) {
+    await this._service.xrpc.call(
+      "com.atproto.repo.deleteRecord",
+      void 0,
+      { collection: "app.bsky.graph.listitem", ...params2 },
+      { headers }
+    );
+  }
+};
 var NotificationNS = class {
   constructor(service) {
     this._service = service;
   }
   getUnreadCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getUnreadCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr74(e);
+      throw toKnownErr79(e);
     });
   }
   listNotifications(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.listNotifications", params2, void 0, opts).catch((e) => {
-      throw toKnownErr75(e);
+      throw toKnownErr80(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr76(e);
+      throw toKnownErr81(e);
     });
   }
 };
@@ -14853,7 +16132,7 @@ var UnspeccedNS = class {
   }
   getPopular(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopular", params2, void 0, opts).catch((e) => {
-      throw toKnownErr77(e);
+      throw toKnownErr82(e);
     });
   }
 };