@fern-api/venus-api-sdk 0.0.18 → 0.0.20

package/dist/browser/cjs/core.js

@@ -2078,7 +2078,7 @@ var require_utils = __commonJS({
     function isObject(val) {
       return val !== null && typeof val === "object";
     }
-    function isPlainObject(val) {
+    function isPlainObject2(val) {
       if (kindOf(val) !== "object") {
         return false;
       }
@@ -2131,9 +2131,9 @@ var require_utils = __commonJS({
     function merge() {
       var result = {};
       function assignValue(val, key) {
-        if (isPlainObject(result[key]) && isPlainObject(val)) {
+        if (isPlainObject2(result[key]) && isPlainObject2(val)) {
           result[key] = merge(result[key], val);
-        } else if (isPlainObject(val)) {
+        } else if (isPlainObject2(val)) {
           result[key] = merge({}, val);
         } else if (isArray(val)) {
           result[key] = val.slice();
@@ -2222,7 +2222,7 @@ var require_utils = __commonJS({
       isString,
       isNumber,
       isObject,
-      isPlainObject,
+      isPlainObject: isPlainObject2,
       isUndefined,
       isDate,
       isFile,
@@ -3519,18 +3519,16 @@ module.exports = __toCommonJS(core_exports);
 // src/core/schemas/index.ts
 var schemas_exports = {};
 __export(schemas_exports, {
-  OBJECT_LIKE_BRAND: () => OBJECT_LIKE_BRAND,
-  OPTIONAL_BRAND: () => OPTIONAL_BRAND,
+  JsonError: () => JsonError,
+  ParseError: () => ParseError,
   any: () => any,
   boolean: () => boolean,
-  createIdentitySchemaCreator: () => createIdentitySchemaCreator,
   date: () => date,
   discriminant: () => discriminant,
   enum_: () => enum_,
   getObjectLikeUtils: () => getObjectLikeUtils,
   getObjectUtils: () => getObjectUtils,
   getSchemaUtils: () => getSchemaUtils,
-  identity: () => identity,
   isProperty: () => isProperty,
   lazy: () => lazy,
   lazyObject: () => lazyObject,
@@ -3546,26 +3544,97 @@ __export(schemas_exports, {
   transform: () => transform,
   union: () => union,
   unknown: () => unknown,
-  withProperties: () => withProperties
+  withParsedProperties: () => withParsedProperties
 });
 
-// src/core/schemas/builders/schema-utils/types.ts
-var OPTIONAL_BRAND = void 0;
+// src/core/schemas/Schema.ts
+var SchemaType = {
+  DATE: "date",
+  ENUM: "enum",
+  LIST: "list",
+  STRING_LITERAL: "stringLiteral",
+  OBJECT: "object",
+  ANY: "any",
+  BOOLEAN: "boolean",
+  NUMBER: "number",
+  STRING: "string",
+  UNKNOWN: "unknown",
+  RECORD: "record",
+  SET: "set",
+  UNION: "union",
+  OPTIONAL: "optional"
+};
+
+// src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts
+function stringifyValidationError(error) {
+  if (error.path.length === 0) {
+    return error.message;
+  }
+  return `${error.path.join(" -> ")}: ${error.message}`;
+}
+
+// src/core/schemas/builders/schema-utils/JsonError.ts
+var JsonError = class extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, JsonError.prototype);
+  }
+};
+
+// src/core/schemas/builders/schema-utils/ParseError.ts
+var ParseError = class extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, ParseError.prototype);
+  }
+};
 
 // src/core/schemas/builders/schema-utils/getSchemaUtils.ts
 function getSchemaUtils(schema) {
   return {
     optional: () => optional(schema),
-    transform: (transformer) => transform(schema, transformer)
+    transform: (transformer) => transform(schema, transformer),
+    parseOrThrow: async (raw, opts) => {
+      const parsed = await schema.parse(raw, opts);
+      if (parsed.ok) {
+        return parsed.value;
+      }
+      throw new ParseError(parsed.errors);
+    },
+    jsonOrThrow: async (parsed, opts) => {
+      const raw = await schema.json(parsed, opts);
+      if (raw.ok) {
+        return raw.value;
+      }
+      throw new JsonError(raw.errors);
+    }
   };
 }
 function optional(schema) {
   const baseSchema = {
-    parse: (raw, opts) => raw != null ? schema.parse(raw, opts) : void 0,
-    json: (parsed, opts) => parsed != null ? schema.json(parsed, opts) : void 0
+    parse: (raw, opts) => {
+      if (raw == null) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (parsed == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.OPTIONAL
   };
   return {
-    ...OPTIONAL_BRAND,
     ...baseSchema,
     ...getSchemaUtils(baseSchema)
   };
@@ -3573,13 +3642,20 @@ function optional(schema) {
 function transform(schema, transformer) {
   const baseSchema = {
     parse: async (raw, opts) => {
-      const postTransformParsed = await schema.parse(raw, opts);
-      return transformer.parse(postTransformParsed, opts);
+      const parsed = await schema.parse(raw, opts);
+      if (!parsed.ok) {
+        return parsed;
+      }
+      return {
+        ok: true,
+        value: transformer.transform(parsed.value)
+      };
     },
-    json: async (parsed, opts) => {
-      const preTransformParsed = await transformer.json(parsed, opts);
-      return schema.json(preTransformParsed, opts);
-    }
+    json: async (transformed, opts) => {
+      const parsed = await transformer.untransform(transformed);
+      return schema.json(parsed, opts);
+    },
+    getType: () => schema.getType()
   };
   return {
     ...baseSchema,
@@ -3588,10 +3664,46 @@ function transform(schema, transformer) {
 }
 
 // src/core/schemas/builders/date/date.ts
+var ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 function date() {
   const baseSchema = {
-    parse: (raw) => new Date(raw),
-    json: (date2) => date2.toISOString()
+    parse: (raw) => {
+      if (typeof raw === "string" && ISO_8601_REGEX.test(raw)) {
+        return {
+          ok: true,
+          value: new Date(raw)
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not an ISO 8601 date string"
+            }
+          ]
+        };
+      }
+    },
+    json: (date2) => {
+      if (date2 instanceof Date) {
+        return {
+          ok: true,
+          value: date2.toISOString()
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not a Date object"
+            }
+          ]
+        };
+      }
+    },
+    getType: () => SchemaType.DATE
   };
   return {
     ...baseSchema,
@@ -3599,26 +3711,43 @@ function date() {
   };
 }
 
-// src/core/schemas/builders/identity/identity.ts
-function identity() {
-  const baseSchema = {
-    parse: (raw) => raw,
-    json: (parsed) => parsed
-  };
-  return {
-    ...baseSchema,
-    ...getSchemaUtils(baseSchema)
+// src/core/schemas/utils/createIdentitySchemaCreator.ts
+function createIdentitySchemaCreator(schemaType, validate) {
+  return () => {
+    const baseSchema = {
+      parse: validate,
+      json: validate,
+      getType: () => schemaType
+    };
+    return {
+      ...baseSchema,
+      ...getSchemaUtils(baseSchema)
+    };
   };
 }
 
-// src/core/schemas/builders/identity/createIdentitySchemaCreator.ts
-function createIdentitySchemaCreator() {
-  return () => identity();
-}
-
 // src/core/schemas/builders/enum/enum.ts
-function enum_(_values) {
-  return createIdentitySchemaCreator()();
+function enum_(values) {
+  const validValues = new Set(values);
+  const schemaCreator = createIdentitySchemaCreator(SchemaType.ENUM, (value, { allowUnknownKeys = false } = {}) => {
+    if (typeof value === "string" && (validValues.has(value) || allowUnknownKeys)) {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: [],
+            message: "Not one of the allowed values"
+          }
+        ]
+      };
+    }
+  });
+  return schemaCreator();
 }
 
 // src/core/schemas/builders/lazy/lazy.ts
@@ -3631,8 +3760,9 @@ function lazy(getter) {
 }
 function constructLazyBaseSchema(getter) {
   return {
-    parse: async (raw) => (await getMemoizedSchema(getter)).parse(raw),
-    json: async (parsed) => (await getMemoizedSchema(getter)).json(parsed)
+    parse: async (raw, opts) => (await getMemoizedSchema(getter)).parse(raw, opts),
+    json: async (parsed, opts) => (await getMemoizedSchema(getter)).json(parsed, opts),
+    getType: async () => (await getMemoizedSchema(getter)).getType()
   };
 }
 async function getMemoizedSchema(getter) {
@@ -3659,6 +3789,22 @@ function filterObject(obj, keysToInclude) {
   }, {});
 }
 
+// src/core/schemas/utils/isPlainObject.ts
+var NOT_AN_OBJECT_ERROR_MESSAGE = "Not an object";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) === null) {
+    return true;
+  }
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+
 // src/core/schemas/utils/keys.ts
 function keys(object2) {
   return Object.keys(object2);
@@ -3677,47 +3823,56 @@ function partition(items, predicate) {
   return [trueItems, falseItems];
 }
 
-// src/core/schemas/builders/object-like/types.ts
-var OBJECT_LIKE_BRAND = void 0;
-
 // src/core/schemas/builders/object-like/getObjectLikeUtils.ts
 function getObjectLikeUtils(schema) {
   return {
-    withProperties: (properties) => withProperties(schema, properties)
+    withParsedProperties: (properties) => withParsedProperties(schema, properties)
   };
 }
-function withProperties(objectLike, properties) {
+function withParsedProperties(objectLike, properties) {
   const objectSchema = {
-    ...OBJECT_LIKE_BRAND,
     parse: async (raw, opts) => {
       const parsedObject = await objectLike.parse(raw, opts);
+      if (!parsedObject.ok) {
+        return parsedObject;
+      }
       const additionalProperties = Object.entries(properties).reduce(
         (processed, [key, value]) => {
           return {
             ...processed,
-            [key]: typeof value === "function" ? value(parsedObject) : value
+            [key]: typeof value === "function" ? value(parsedObject.value) : value
           };
         },
         {}
       );
       return {
-        ...parsedObject,
-        ...additionalProperties
+        ok: true,
+        value: {
+          ...parsedObject.value,
+          ...additionalProperties
+        }
       };
     },
     json: (parsed, opts) => {
+      if (!isPlainObject(parsed)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: NOT_AN_OBJECT_ERROR_MESSAGE
+            }
+          ]
+        };
+      }
       const addedPropertyKeys = new Set(Object.keys(properties));
-      const parsedWithoutAddedProperties = Object.entries(parsed).reduce(
-        (filtered, [key, value]) => {
-          if (!addedPropertyKeys.has(key)) {
-            filtered[key] = value;
-          }
-          return filtered;
-        },
-        {}
+      const parsedWithoutAddedProperties = filterObject(
+        parsed,
+        Object.keys(parsed).filter((key) => !addedPropertyKeys.has(key))
       );
       return objectLike.json(parsedWithoutAddedProperties, opts);
-    }
+    },
+    getType: () => objectLike.getType()
   };
   return {
     ...objectSchema,
@@ -3741,54 +3896,76 @@ function isProperty(maybeProperty) {
 // src/core/schemas/builders/object/object.ts
 function object(schemas) {
   const baseSchema = {
-    ...OBJECT_LIKE_BRAND,
     _getRawProperties: () => Promise.resolve(
       Object.entries(schemas).map(
         ([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey
       )
     ),
     _getParsedProperties: () => Promise.resolve(keys(schemas)),
-    parse: async (raw, { skipUnknownKeysOnParse = false } = {}) => {
+    parse: async (raw, opts) => {
       const rawKeyToProperty = {};
+      const requiredKeys = [];
       for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
         const rawKey = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
         const property2 = {
           rawKey,
           parsedKey,
-          valueSchema: isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty
+          valueSchema
         };
         rawKeyToProperty[rawKey] = property2;
-      }
-      const parsed = {};
-      for (const [rawKey, rawPropertyValue] of Object.entries(raw)) {
-        const property2 = rawKeyToProperty[rawKey];
-        if (property2 != null) {
-          const value = await property2.valueSchema.parse(rawPropertyValue);
-          parsed[property2.parsedKey] = value;
-        } else if (!skipUnknownKeysOnParse && rawPropertyValue != null) {
-          parsed[rawKey] = rawPropertyValue;
+        if (await valueSchema.getType() !== "optional") {
+          requiredKeys.push(rawKey);
         }
       }
-      return parsed;
-    },
-    json: async (parsed, { includeUnknownKeysOnJson = false } = {}) => {
-      const raw = {};
-      for (const [parsedKey, parsedPropertyValue] of entries(parsed)) {
-        const schemaOrObjectProperty = schemas[parsedKey];
-        if (schemaOrObjectProperty != null) {
-          if (isProperty(schemaOrObjectProperty)) {
-            const value = await schemaOrObjectProperty.valueSchema.json(parsedPropertyValue);
-            raw[schemaOrObjectProperty.rawKey] = value;
-          } else {
-            const value = await schemaOrObjectProperty.json(parsedPropertyValue);
-            raw[parsedKey] = value;
+      return validateAndTransformObject({
+        value: raw,
+        requiredKeys,
+        getProperty: (rawKey) => {
+          const property2 = rawKeyToProperty[rawKey];
+          if (property2 == null) {
+            return void 0;
           }
-        } else if (includeUnknownKeysOnJson && parsedPropertyValue != null) {
-          raw[parsedKey] = parsedPropertyValue;
+          return {
+            transformedKey: property2.parsedKey,
+            transform: (propertyValue) => property2.valueSchema.parse(propertyValue, opts)
+          };
+        },
+        allowUnknownKeys: opts?.allowUnknownKeys ?? false
+      });
+    },
+    json: async (parsed, opts) => {
+      const requiredKeys = [];
+      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
+        if (await valueSchema.getType() !== "optional") {
+          requiredKeys.push(parsedKey);
         }
       }
-      return raw;
-    }
+      return validateAndTransformObject({
+        value: parsed,
+        requiredKeys,
+        getProperty: (parsedKey) => {
+          const property2 = schemas[parsedKey];
+          if (property2 == null) {
+            return void 0;
+          }
+          if (isProperty(property2)) {
+            return {
+              transformedKey: property2.rawKey,
+              transform: (propertyValue) => property2.valueSchema.json(propertyValue, opts)
+            };
+          } else {
+            return {
+              transformedKey: parsedKey,
+              transform: (propertyValue) => property2.json(propertyValue, opts)
+            };
+          }
+        },
+        allowUnknownKeys: opts?.allowUnknownKeys ?? false
+      });
+    },
+    getType: () => SchemaType.OBJECT
   };
   return {
     ...baseSchema,
@@ -3797,11 +3974,72 @@ function object(schemas) {
     ...getObjectUtils(baseSchema)
   };
 }
+async function validateAndTransformObject({
+  value,
+  requiredKeys,
+  getProperty,
+  allowUnknownKeys
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: NOT_AN_OBJECT_ERROR_MESSAGE
+        }
+      ]
+    };
+  }
+  const missingRequiredKeys = new Set(requiredKeys);
+  const errors = [];
+  const transformed = {};
+  for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
+    const property2 = getProperty(preTransformedKey);
+    if (property2 != null) {
+      missingRequiredKeys.delete(preTransformedKey);
+      const value2 = await property2.transform(preTransformedItemValue);
+      if (value2.ok) {
+        transformed[property2.transformedKey] = value2.value;
+      } else {
+        errors.push(
+          ...value2.errors.map((error) => ({
+            path: [preTransformedKey, ...error.path],
+            message: error.message
+          }))
+        );
+      }
+    } else if (allowUnknownKeys) {
+      transformed[preTransformedKey] = preTransformedItemValue;
+    } else {
+      errors.push({
+        path: [preTransformedKey],
+        message: `Unrecognized key "${preTransformedKey}"`
+      });
+    }
+  }
+  errors.push(
+    ...requiredKeys.filter((key) => missingRequiredKeys.has(key)).map((key) => ({
+      path: [],
+      message: `Missing required key "${key}"`
+    }))
+  );
+  if (errors.length === 0) {
+    return {
+      ok: true,
+      value: transformed
+    };
+  } else {
+    return {
+      ok: false,
+      errors
+    };
+  }
+}
 function getObjectUtils(schema) {
   return {
     extend: (extension) => {
       const baseSchema = {
-        ...OBJECT_LIKE_BRAND,
         _getParsedProperties: async () => [
           ...await schema._getParsedProperties(),
           ...await extension._getParsedProperties()
@@ -3811,27 +4049,22 @@ function getObjectUtils(schema) {
           ...await extension._getRawProperties()
         ],
         parse: async (raw, opts) => {
-          const rawExtensionPropertiesSet = new Set(await extension._getRawProperties());
-          const [extensionProperties, otherProperties] = partition(
-            keys(raw),
-            (key) => rawExtensionPropertiesSet.has(key)
-          );
-          return {
-            ...await schema.parse(filterObject(raw, otherProperties), opts),
-            ...await extension.parse(filterObject(raw, extensionProperties), opts)
-          };
+          return validateAndTransformExtendedObject({
+            extensionKeys: await extension._getRawProperties(),
+            value: raw,
+            transformBase: (rawBase) => schema.parse(rawBase, opts),
+            transformExtension: (rawExtension) => extension.parse(rawExtension, opts)
+          });
         },
         json: async (parsed, opts) => {
-          const parsedExtensionPropertiesSet = new Set(await extension._getParsedProperties());
-          const [extensionProperties, otherProperties] = partition(
-            keys(parsed),
-            (key) => parsedExtensionPropertiesSet.has(key)
-          );
-          return {
-            ...await schema.json(filterObject(parsed, otherProperties), opts),
-            ...await extension.json(filterObject(parsed, extensionProperties), opts)
-          };
-        }
+          return validateAndTransformExtendedObject({
+            extensionKeys: await extension._getParsedProperties(),
+            value: parsed,
+            transformBase: (parsedBase) => schema.json(parsedBase, opts),
+            transformExtension: (parsedExtension) => extension.json(parsedExtension, opts)
+          });
+        },
+        getType: () => SchemaType.OBJECT
       };
       return {
         ...baseSchema,
@@ -3842,11 +4075,41 @@ function getObjectUtils(schema) {
     }
   };
 }
+async function validateAndTransformExtendedObject({
+  extensionKeys,
+  value,
+  transformBase,
+  transformExtension
+}) {
+  const extensionPropertiesSet = new Set(extensionKeys);
+  const [extensionProperties, baseProperties] = partition(
+    keys(value),
+    (key) => extensionPropertiesSet.has(key)
+  );
+  const transformedBase = await transformBase(filterObject(value, baseProperties));
+  const transformedExtension = await transformExtension(filterObject(value, extensionProperties));
+  if (transformedBase.ok && transformedExtension.ok) {
+    return {
+      ok: true,
+      value: {
+        ...transformedBase.value,
+        ...transformedExtension.value
+      }
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        ...transformedBase.ok ? [] : transformedBase.errors,
+        ...transformedExtension.ok ? [] : transformedExtension.errors
+      ]
+    };
+  }
+}
 
 // src/core/schemas/builders/lazy/lazyObject.ts
 function lazyObject(getter) {
   const baseSchema = {
-    ...OBJECT_LIKE_BRAND,
     ...constructLazyBaseSchema(getter),
     _getRawProperties: async () => (await getMemoizedSchema(getter))._getRawProperties(),
     _getParsedProperties: async () => (await getMemoizedSchema(getter))._getParsedProperties()
@@ -3862,66 +4125,273 @@ function lazyObject(getter) {
 // src/core/schemas/builders/list/list.ts
 function list(schema) {
   const baseSchema = {
-    parse: (raw, opts) => Promise.all(raw.map((item) => schema.parse(item, opts))),
-    json: (parsed, opts) => Promise.all(parsed.map((item) => schema.json(item, opts)))
+    parse: async (raw, opts) => validateAndTransformArray(raw, (item) => schema.parse(item, opts)),
+    json: (parsed, opts) => validateAndTransformArray(parsed, (item) => schema.json(item, opts)),
+    getType: () => SchemaType.LIST
   };
   return {
     ...baseSchema,
     ...getSchemaUtils(baseSchema)
   };
 }
+async function validateAndTransformArray(value, transformItem) {
+  if (!Array.isArray(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          message: "Not a list",
+          path: []
+        }
+      ]
+    };
+  }
+  const maybeValidItems = await Promise.all(value.map((item) => transformItem(item)));
+  return maybeValidItems.reduce(
+    (acc, item, index) => {
+      if (acc.ok && item.ok) {
+        return {
+          ok: true,
+          value: [...acc.value, item.value]
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!item.ok) {
+        errors.push(
+          ...item.errors.map((error) => ({
+            path: [`[${index}]`, ...error.path],
+            message: error.message
+          }))
+        );
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    { ok: true, value: [] }
+  );
+}
 
 // src/core/schemas/builders/literals/stringLiteral.ts
-function stringLiteral(_value) {
-  return createIdentitySchemaCreator()();
+function stringLiteral(literal) {
+  const schemaCreator = createIdentitySchemaCreator(SchemaType.STRING_LITERAL, (value) => {
+    if (value === literal) {
+      return {
+        ok: true,
+        value: literal
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: [],
+            message: `Not equal to "${literal}"`
+          }
+        ]
+      };
+    }
+  });
+  return schemaCreator();
 }
 
 // src/core/schemas/builders/primitives/any.ts
-var any = createIdentitySchemaCreator();
+var any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));
 
 // src/core/schemas/builders/primitives/boolean.ts
-var boolean = createIdentitySchemaCreator();
+var boolean = createIdentitySchemaCreator(SchemaType.BOOLEAN, (value) => {
+  if (typeof value === "boolean") {
+    return {
+      ok: true,
+      value
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: "Not a boolean"
+        }
+      ]
+    };
+  }
+});
 
 // src/core/schemas/builders/primitives/number.ts
-var number = createIdentitySchemaCreator();
+var number = createIdentitySchemaCreator(SchemaType.NUMBER, (value) => {
+  if (typeof value === "number") {
+    return {
+      ok: true,
+      value
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: "Not a number"
+        }
+      ]
+    };
+  }
+});
 
 // src/core/schemas/builders/primitives/string.ts
-var string = createIdentitySchemaCreator();
+var string = createIdentitySchemaCreator(SchemaType.STRING, (value) => {
+  if (typeof value === "string") {
+    return {
+      ok: true,
+      value
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: "Not a string"
+        }
+      ]
+    };
+  }
+});
 
 // src/core/schemas/builders/primitives/unknown.ts
-var unknown = createIdentitySchemaCreator();
+var unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));
 
 // src/core/schemas/builders/record/record.ts
 function record(keySchema, valueSchema) {
   const baseSchema = {
-    parse: (raw, opts) => {
-      return entries(raw).reduce(async (parsedPromise, [key, value]) => {
-        const parsed = await parsedPromise;
-        const parsedKey = await keySchema.parse(key, opts);
-        parsed[parsedKey] = await valueSchema.parse(value, opts);
-        return parsedPromise;
-      }, Promise.resolve({}));
+    parse: async (raw, opts) => {
+      return validateAndTransformRecord({
+        value: raw,
+        isKeyNumeric: await keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.parse(key, opts),
+        transformValue: (value) => valueSchema.parse(value, opts)
+      });
     },
-    json: (parsed, opts) => {
-      return entries(parsed).reduce(async (rawPromise, [key, value]) => {
-        const raw = await rawPromise;
-        const rawKey = await keySchema.json(key, opts);
-        raw[rawKey] = await valueSchema.json(value, opts);
-        return rawPromise;
-      }, Promise.resolve({}));
-    }
+    json: async (parsed, opts) => {
+      return validateAndTransformRecord({
+        value: parsed,
+        isKeyNumeric: await keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.json(key, opts),
+        transformValue: (value) => valueSchema.json(value, opts)
+      });
+    },
+    getType: () => SchemaType.RECORD
   };
   return {
     ...baseSchema,
     ...getSchemaUtils(baseSchema)
   };
 }
+async function validateAndTransformRecord({
+  value,
+  isKeyNumeric,
+  transformKey,
+  transformValue
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: NOT_AN_OBJECT_ERROR_MESSAGE
+        }
+      ]
+    };
+  }
+  return entries(value).reduce(
+    async (accPromise, [stringKey, value2]) => {
+      if (value2 == null) {
+        return accPromise;
+      }
+      const acc = await accPromise;
+      let key = stringKey;
+      if (isKeyNumeric) {
+        const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+        if (!isNaN(numberKey)) {
+          key = numberKey;
+        }
+      }
+      const transformedKey = await transformKey(key);
+      const transformedValue = await transformValue(value2);
+      if (acc.ok && transformedKey.ok && transformedValue.ok) {
+        return {
+          ok: true,
+          value: {
+            ...acc.value,
+            [transformedKey.value]: transformedValue.value
+          }
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!transformedKey.ok) {
+        errors.push(
+          ...transformedKey.errors.map((error) => ({
+            path: [`${key} (key)`, ...error.path],
+            message: error.message
+          }))
+        );
+      }
+      if (!transformedValue.ok) {
+        errors.push(
+          ...transformedValue.errors.map((error) => ({
+            path: [stringKey, ...error.path],
+            message: error.message
+          }))
+        );
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    Promise.resolve({ ok: true, value: {} })
+  );
+}
 
 // src/core/schemas/builders/set/set.ts
 function set(schema) {
+  const listSchema = list(schema);
   const baseSchema = {
-    parse: async (raw, opts) => new Set(await Promise.all(raw.map((item) => schema.parse(item, opts)))),
-    json: (parsed, opts) => Promise.all([...parsed].map((item) => schema.json(item, opts)))
+    parse: async (raw, opts) => {
+      const parsedList = await listSchema.parse(raw, opts);
+      if (parsedList.ok) {
+        return {
+          ok: true,
+          value: new Set(parsedList.value)
+        };
+      } else {
+        return parsedList;
+      }
+    },
+    json: async (parsed, opts) => {
+      if (!(parsed instanceof Set)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not a Set"
+            }
+          ]
+        };
+      }
+      const jsonList = await listSchema.json([...parsed], opts);
+      return jsonList;
+    },
+    getType: () => SchemaType.SET
   };
   return {
     ...baseSchema,
@@ -3941,36 +4411,31 @@ function discriminant(parsedDiscriminant, rawDiscriminant) {
 function union(discriminant2, union2) {
   const rawDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.rawDiscriminant;
   const parsedDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.parsedDiscriminant;
+  const discriminantValueSchema = enum_(keys(union2));
   const baseSchema = {
-    ...OBJECT_LIKE_BRAND,
     parse: async (raw, opts) => {
-      const { [rawDiscriminant]: discriminantValue, ...additionalProperties } = raw;
-      const additionalPropertySchemas = union2[discriminantValue];
-      if (additionalPropertySchemas == null) {
-        return {
-          ...additionalProperties,
-          [parsedDiscriminant]: discriminantValue
-        };
-      }
-      return {
-        ...await additionalPropertySchemas.parse(additionalProperties, opts),
-        [parsedDiscriminant]: discriminantValue
-      };
+      return transformAndValidateUnion(
+        raw,
+        rawDiscriminant,
+        parsedDiscriminant,
+        (discriminantValue) => discriminantValueSchema.parse(discriminantValue, opts),
+        (discriminantValue) => union2[discriminantValue],
+        opts?.allowUnknownKeys ?? false,
+        (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts)
+      );
     },
     json: async (parsed, opts) => {
-      const { [parsedDiscriminant]: discriminantValue, ...additionalProperties } = parsed;
-      const additionalPropertySchemas = union2[discriminantValue];
-      if (additionalPropertySchemas == null) {
-        return {
-          ...additionalProperties,
-          [rawDiscriminant]: discriminantValue
-        };
-      }
-      return {
-        ...await additionalPropertySchemas.json(additionalProperties, opts),
-        [rawDiscriminant]: discriminantValue
-      };
-    }
+      return transformAndValidateUnion(
+        parsed,
+        parsedDiscriminant,
+        rawDiscriminant,
+        (discriminantValue) => discriminantValueSchema.json(discriminantValue, opts),
+        (discriminantValue) => union2[discriminantValue],
+        opts?.allowUnknownKeys ?? false,
+        (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts)
+      );
+    },
+    getType: () => SchemaType.UNION
   };
   return {
     ...baseSchema,
@@ -3978,12 +4443,83 @@ function union(discriminant2, union2) {
     ...getObjectLikeUtils(baseSchema)
   };
 }
+async function transformAndValidateUnion(value, discriminant2, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnknownKeys, transformAdditionalProperties) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: NOT_AN_OBJECT_ERROR_MESSAGE
+        }
+      ]
+    };
+  }
+  const { [discriminant2]: discriminantValue, ...additionalProperties } = value;
+  if (discriminantValue == null) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: [],
+          message: `Missing discriminant ("${discriminant2}")`
+        }
+      ]
+    };
+  }
+  const transformedDiscriminantValue = await transformDiscriminantValue(discriminantValue);
+  if (!transformedDiscriminantValue.ok) {
+    return {
+      ok: false,
+      errors: transformedDiscriminantValue.errors.map((error) => ({
+        path: [discriminant2, ...error.path],
+        message: error.message
+      }))
+    };
+  }
+  const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+  if (additionalPropertiesSchema == null) {
+    if (allowUnknownKeys) {
+      return {
+        ok: true,
+        value: {
+          [transformedDiscriminant]: transformedDiscriminantValue.value,
+          ...additionalProperties
+        }
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: [discriminant2],
+            message: "Unrecognized discriminant value"
+          }
+        ]
+      };
+    }
+  }
+  const transformedAdditionalProperties = await transformAdditionalProperties(
+    additionalProperties,
+    additionalPropertiesSchema
+  );
+  if (!transformedAdditionalProperties.ok) {
+    return transformedAdditionalProperties;
+  }
+  return {
+    ok: true,
+    value: {
+      [transformedDiscriminant]: discriminantValue,
+      ...transformedAdditionalProperties.value
+    }
+  };
+}
 
 // src/core/auth/BasicAuth.ts
 var import_basic_auth = __toESM(require_basic_auth());
 
-// .yarn/cache/js-base64-npm-3.7.4-2c2ed9fbc0-b8f6b10033.zip/node_modules/js-base64/base64.mjs
-var version = "3.7.4";
+// .yarn/cache/js-base64-npm-3.7.5-81a9ad2ffd-67a78c8b1c.zip/node_modules/js-base64/base64.mjs
+var version = "3.7.5";
 var VERSION = version;
 var _hasatob = typeof atob === "function";
 var _hasbtoa = typeof btoa === "function";
@@ -3999,7 +4535,7 @@ var b64tab = ((a) => {
 })(b64chs);
 var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
 var _fromCC = String.fromCharCode.bind(String);
-var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it, fn = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn));
+var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it) => new Uint8Array(Array.prototype.slice.call(it, 0));
 var _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
 var _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, "");
 var btoaPolyfill = (bin) => {
@@ -4063,7 +4599,7 @@ var atobPolyfill = (asc) => {
   return bin;
 };
 var _atob = _hasatob ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
-var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a), (c) => c.charCodeAt(0));
+var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a).split("").map((c) => c.charCodeAt(0)));
 var toUint8Array = (a) => _toUint8Array(_unURI(a));
 var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
 var _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
@@ -4200,7 +4736,7 @@ var fetcher = async (args) => {
       transitional: {
         clarifyTimeoutError: true
       },
-      withCredentials: true
+      withCredentials: args.withCredentials
     });
     let body;
     if (response.data != null && response.data.length > 0) {
@@ -4228,7 +4764,6 @@ var fetcher = async (args) => {
         error: {
           reason: "status-code",
           statusCode: response.status,
-          rawBody: response.data,
           body
         }
       };