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

package/dist/browser/cjs/serialization.js

@@ -792,12 +792,72 @@ var init_api = __esm({
   }
 });
 
-// src/core/schemas/builders/schema-utils/types.ts
-var OPTIONAL_BRAND;
-var init_types5 = __esm({
-  "src/core/schemas/builders/schema-utils/types.ts"() {
+// src/core/schemas/Schema.ts
+var SchemaType;
+var init_Schema = __esm({
+  "src/core/schemas/Schema.ts"() {
+    "use strict";
+    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}`;
+}
+var init_stringifyValidationErrors = __esm({
+  "src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/schemas/builders/schema-utils/JsonError.ts
+var JsonError;
+var init_JsonError = __esm({
+  "src/core/schemas/builders/schema-utils/JsonError.ts"() {
+    "use strict";
+    init_stringifyValidationErrors();
+    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;
+var init_ParseError = __esm({
+  "src/core/schemas/builders/schema-utils/ParseError.ts"() {
     "use strict";
-    OPTIONAL_BRAND = void 0;
+    init_stringifyValidationErrors();
+    ParseError = class extends Error {
+      constructor(errors) {
+        super(errors.map(stringifyValidationError).join("; "));
+        this.errors = errors;
+        Object.setPrototypeOf(this, ParseError.prototype);
+      }
+    };
   }
 });
 
@@ -805,16 +865,46 @@ var init_types5 = __esm({
 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)
   };
@@ -822,13 +912,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,
@@ -838,7 +935,9 @@ function transform(schema, transformer) {
 var init_getSchemaUtils = __esm({
   "src/core/schemas/builders/schema-utils/getSchemaUtils.ts"() {
     "use strict";
-    init_types5();
+    init_Schema();
+    init_JsonError();
+    init_ParseError();
   }
 });
 
@@ -847,25 +946,64 @@ var init_schema_utils = __esm({
   "src/core/schemas/builders/schema-utils/index.ts"() {
     "use strict";
     init_getSchemaUtils();
-    init_types5();
+    init_JsonError();
+    init_ParseError();
   }
 });
 
 // src/core/schemas/builders/date/date.ts
 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,
     ...getSchemaUtils(baseSchema)
   };
 }
+var ISO_8601_REGEX;
 var init_date = __esm({
   "src/core/schemas/builders/date/date.ts"() {
     "use strict";
+    init_Schema();
     init_schema_utils();
+    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)?)?)?)?$/;
   }
 });
 
@@ -877,52 +1015,55 @@ var init_date2 = __esm({
   }
 });
 
-// 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)
+    };
   };
 }
-var init_identity = __esm({
-  "src/core/schemas/builders/identity/identity.ts"() {
-    "use strict";
-    init_schema_utils();
-  }
-});
-
-// src/core/schemas/builders/identity/createIdentitySchemaCreator.ts
-function createIdentitySchemaCreator() {
-  return () => identity();
-}
 var init_createIdentitySchemaCreator = __esm({
-  "src/core/schemas/builders/identity/createIdentitySchemaCreator.ts"() {
-    "use strict";
-    init_identity();
-  }
-});
-
-// src/core/schemas/builders/identity/index.ts
-var init_identity2 = __esm({
-  "src/core/schemas/builders/identity/index.ts"() {
+  "src/core/schemas/utils/createIdentitySchemaCreator.ts"() {
     "use strict";
-    init_createIdentitySchemaCreator();
-    init_identity();
+    init_schema_utils();
   }
 });
 
 // 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();
 }
 var init_enum = __esm({
   "src/core/schemas/builders/enum/enum.ts"() {
     "use strict";
-    init_identity2();
+    init_Schema();
+    init_createIdentitySchemaCreator();
   }
 });
 
@@ -944,8 +1085,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) {
@@ -988,6 +1130,28 @@ var init_filterObject = __esm({
   }
 });
 
+// src/core/schemas/utils/isPlainObject.ts
+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;
+}
+var NOT_AN_OBJECT_ERROR_MESSAGE;
+var init_isPlainObject = __esm({
+  "src/core/schemas/utils/isPlainObject.ts"() {
+    "use strict";
+    NOT_AN_OBJECT_ERROR_MESSAGE = "Not an object";
+  }
+});
+
 // src/core/schemas/utils/keys.ts
 function keys(object2) {
   return Object.keys(object2);
@@ -1016,53 +1180,56 @@ var init_partition = __esm({
   }
 });
 
-// src/core/schemas/builders/object-like/types.ts
-var OBJECT_LIKE_BRAND;
-var init_types6 = __esm({
-  "src/core/schemas/builders/object-like/types.ts"() {
-    "use strict";
-    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,
@@ -1073,8 +1240,9 @@ function withProperties(objectLike, properties) {
 var init_getObjectLikeUtils = __esm({
   "src/core/schemas/builders/object-like/getObjectLikeUtils.ts"() {
     "use strict";
+    init_filterObject();
+    init_isPlainObject();
     init_schema_utils();
-    init_types6();
   }
 });
 
@@ -1083,7 +1251,6 @@ var init_object_like = __esm({
   "src/core/schemas/builders/object-like/index.ts"() {
     "use strict";
     init_getObjectLikeUtils();
-    init_types6();
   }
 });
 
@@ -1107,54 +1274,76 @@ var init_property = __esm({
 // 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,
@@ -1163,11 +1352,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()
@@ -1177,27 +1427,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,
@@ -1208,11 +1453,44 @@ 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
+      ]
+    };
+  }
+}
 var init_object = __esm({
   "src/core/schemas/builders/object/object.ts"() {
     "use strict";
+    init_Schema();
     init_entries();
     init_filterObject();
+    init_isPlainObject();
     init_keys();
     init_partition();
     init_object_like();
@@ -1233,7 +1511,6 @@ var init_object2 = __esm({
 // 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()
@@ -1267,17 +1544,60 @@ var init_lazy2 = __esm({
 // 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: [] }
+  );
+}
 var init_list = __esm({
   "src/core/schemas/builders/list/list.ts"() {
     "use strict";
+    init_Schema();
     init_schema_utils();
   }
 });
@@ -1291,13 +1611,32 @@ var init_list2 = __esm({
 });
 
 // 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();
 }
 var init_stringLiteral = __esm({
   "src/core/schemas/builders/literals/stringLiteral.ts"() {
     "use strict";
-    init_identity2();
+    init_Schema();
+    init_createIdentitySchemaCreator();
   }
 });
 
@@ -1314,8 +1653,9 @@ var any;
 var init_any = __esm({
   "src/core/schemas/builders/primitives/any.ts"() {
     "use strict";
-    init_identity2();
-    any = createIdentitySchemaCreator();
+    init_Schema();
+    init_createIdentitySchemaCreator();
+    any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));
   }
 });
 
@@ -1324,8 +1664,26 @@ var boolean;
 var init_boolean = __esm({
   "src/core/schemas/builders/primitives/boolean.ts"() {
     "use strict";
-    init_identity2();
-    boolean = createIdentitySchemaCreator();
+    init_Schema();
+    init_createIdentitySchemaCreator();
+    boolean = createIdentitySchemaCreator(SchemaType.BOOLEAN, (value) => {
+      if (typeof value === "boolean") {
+        return {
+          ok: true,
+          value
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not a boolean"
+            }
+          ]
+        };
+      }
+    });
   }
 });
 
@@ -1334,8 +1692,26 @@ var number;
 var init_number = __esm({
   "src/core/schemas/builders/primitives/number.ts"() {
     "use strict";
-    init_identity2();
-    number = createIdentitySchemaCreator();
+    init_Schema();
+    init_createIdentitySchemaCreator();
+    number = createIdentitySchemaCreator(SchemaType.NUMBER, (value) => {
+      if (typeof value === "number") {
+        return {
+          ok: true,
+          value
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not a number"
+            }
+          ]
+        };
+      }
+    });
   }
 });
 
@@ -1344,8 +1720,26 @@ var string;
 var init_string = __esm({
   "src/core/schemas/builders/primitives/string.ts"() {
     "use strict";
-    init_identity2();
-    string = createIdentitySchemaCreator();
+    init_Schema();
+    init_createIdentitySchemaCreator();
+    string = createIdentitySchemaCreator(SchemaType.STRING, (value) => {
+      if (typeof value === "string") {
+        return {
+          ok: true,
+          value
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: [],
+              message: "Not a string"
+            }
+          ]
+        };
+      }
+    });
   }
 });
 
@@ -1354,8 +1748,9 @@ var unknown;
 var init_unknown = __esm({
   "src/core/schemas/builders/primitives/unknown.ts"() {
     "use strict";
-    init_identity2();
-    unknown = createIdentitySchemaCreator();
+    init_Schema();
+    init_createIdentitySchemaCreator();
+    unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));
   }
 });
 
@@ -1374,32 +1769,104 @@ var init_primitives = __esm({
 // 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: {} })
+  );
+}
 var init_record = __esm({
   "src/core/schemas/builders/record/record.ts"() {
     "use strict";
+    init_Schema();
     init_entries();
+    init_isPlainObject();
     init_schema_utils();
   }
 });
@@ -1414,9 +1881,35 @@ var init_record2 = __esm({
 
 // 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,
@@ -1426,6 +1919,8 @@ function set(schema) {
 var init_set = __esm({
   "src/core/schemas/builders/set/set.ts"() {
     "use strict";
+    init_Schema();
+    init_list2();
     init_schema_utils();
   }
 });
@@ -1455,36 +1950,31 @@ var init_discriminant = __esm({
 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,
@@ -1492,9 +1982,84 @@ 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
+    }
+  };
+}
 var init_union = __esm({
   "src/core/schemas/builders/union/union.ts"() {
     "use strict";
+    init_Schema();
+    init_isPlainObject();
+    init_keys();
+    init_enum2();
     init_object_like();
     init_schema_utils();
   }
@@ -1515,7 +2080,6 @@ var init_builders = __esm({
     "use strict";
     init_date2();
     init_enum2();
-    init_identity2();
     init_lazy2();
     init_list2();
     init_literals();
@@ -1532,18 +2096,16 @@ var init_builders = __esm({
 // 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,
@@ -1559,12 +2121,13 @@ __export(schemas_exports, {
   transform: () => transform,
   union: () => union,
   unknown: () => unknown,
-  withProperties: () => withProperties
+  withParsedProperties: () => withParsedProperties
 });
 var init_schemas = __esm({
   "src/core/schemas/index.ts"() {
     "use strict";
     init_builders();
+    init_Schema();
   }
 });
 
@@ -3641,7 +4204,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;
       }
@@ -3694,9 +4257,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();
@@ -3785,7 +4348,7 @@ var require_utils = __commonJS({
       isString,
       isNumber,
       isObject,
-      isPlainObject,
+      isPlainObject: isPlainObject2,
       isUndefined,
       isDate,
       isFile,
@@ -5231,8 +5794,8 @@ var init_OrganizationId2 = __esm({
     init_src();
     init_core();
     OrganizationId2 = schemas_exports.string().transform({
-      parse: api_exports.OrganizationId,
-      json: (value) => value
+      transform: api_exports.OrganizationId,
+      untransform: (value) => value
     });
   }
 });
@@ -5245,14 +5808,14 @@ var init_UserId2 = __esm({
     init_src();
     init_core();
     UserId2 = schemas_exports.string().transform({
-      parse: api_exports.UserId,
-      json: (value) => value
+      transform: api_exports.UserId,
+      untransform: (value) => value
     });
   }
 });
 
 // src/serialization/resources/commons/types/index.ts
-var init_types7 = __esm({
+var init_types5 = __esm({
   "src/serialization/resources/commons/types/index.ts"() {
     "use strict";
     init_OrganizationId2();
@@ -5269,7 +5832,7 @@ __export(commons_exports2, {
 var init_commons2 = __esm({
   "src/serialization/resources/commons/index.ts"() {
     "use strict";
-    init_types7();
+    init_types5();
   }
 });
 
@@ -5287,7 +5850,7 @@ var init_Organization2 = __esm({
 });
 
 // src/serialization/resources/organization/types/index.ts
-var init_types8 = __esm({
+var init_types6 = __esm({
   "src/serialization/resources/organization/types/index.ts"() {
     "use strict";
     init_Organization2();
@@ -5297,24 +5860,19 @@ var init_types8 = __esm({
 // src/serialization/resources/organization/client/create.ts
 var create_exports2 = {};
 __export(create_exports2, {
-  Error: () => Error13,
-  Request: () => Request
+  Error: () => Error13
 });
-var Request, Error13;
+var Error13;
 var init_create2 = __esm({
   "src/serialization/resources/organization/client/create.ts"() {
     "use strict";
     init_src();
     init_core();
-    Request = schemas_exports.object({
-      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
-      artifactReadRequiresToken: schemas_exports.boolean().optional()
-    });
     Error13 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({}),
       OrganizationAlreadyExistsError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.organization.create.Error.unauthorizedError();
@@ -5322,7 +5880,7 @@ var init_create2 = __esm({
             return api_exports.organization.create.Error.organizationAlreadyExistsError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5330,28 +5888,24 @@ var init_create2 = __esm({
 // src/serialization/resources/organization/client/update.ts
 var update_exports2 = {};
 __export(update_exports2, {
-  Error: () => Error14,
-  Request: () => Request2
+  Error: () => Error14
 });
-var Request2, Error14;
+var Error14;
 var init_update2 = __esm({
   "src/serialization/resources/organization/client/update.ts"() {
     "use strict";
     init_src();
     init_core();
-    Request2 = schemas_exports.object({
-      artifactReadRequiresToken: schemas_exports.boolean()
-    });
     Error14 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.organization.update.Error.unauthorizedError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5359,26 +5913,24 @@ var init_update2 = __esm({
 // src/serialization/resources/organization/client/get.ts
 var get_exports2 = {};
 __export(get_exports2, {
-  Error: () => Error15,
-  Response: () => Response
+  Error: () => Error15
 });
-var Response, Error15;
+var Error15;
 var init_get2 = __esm({
   "src/serialization/resources/organization/client/get.ts"() {
     "use strict";
     init_src();
     init_core();
-    Response = schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).Organization);
     Error15 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.organization.get.Error.unauthorizedError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5386,40 +5938,38 @@ var init_get2 = __esm({
 // src/serialization/resources/organization/client/isMember.ts
 var isMember_exports2 = {};
 __export(isMember_exports2, {
-  Response: () => Response2
+  Response: () => Response
 });
-var Response2;
+var Response;
 var init_isMember2 = __esm({
   "src/serialization/resources/organization/client/isMember.ts"() {
     "use strict";
     init_core();
-    Response2 = schemas_exports.boolean();
+    Response = schemas_exports.boolean();
   }
 });
 
 // src/serialization/resources/organization/client/getMyOrganizationFromScopedToken.ts
 var getMyOrganizationFromScopedToken_exports2 = {};
 __export(getMyOrganizationFromScopedToken_exports2, {
-  Error: () => Error16,
-  Response: () => Response3
+  Error: () => Error16
 });
-var Response3, Error16;
+var Error16;
 var init_getMyOrganizationFromScopedToken2 = __esm({
   "src/serialization/resources/organization/client/getMyOrganizationFromScopedToken.ts"() {
     "use strict";
     init_src();
     init_core();
-    Response3 = schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).Organization);
     Error16 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.organization.getMyOrganizationFromScopedToken.Error.unauthorizedError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5427,24 +5977,19 @@ var init_getMyOrganizationFromScopedToken2 = __esm({
 // src/serialization/resources/organization/client/addUser.ts
 var addUser_exports2 = {};
 __export(addUser_exports2, {
-  Error: () => Error17,
-  Request: () => Request3
+  Error: () => Error17
 });
-var Request3, Error17;
+var Error17;
 var init_addUser2 = __esm({
   "src/serialization/resources/organization/client/addUser.ts"() {
     "use strict";
     init_src();
     init_core();
-    Request3 = schemas_exports.object({
-      userId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).UserId),
-      orgId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId)
-    });
     Error17 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({}),
       UserIdDoesNotExistError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.organization.addUser.Error.unauthorizedError();
@@ -5452,11 +5997,59 @@ var init_addUser2 = __esm({
             return api_exports.organization.addUser.Error.userIdDoesNotExistError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
+    });
+  }
+});
+
+// src/serialization/resources/organization/client/requests/CreateOrganizationRequest.ts
+var CreateOrganizationRequest;
+var init_CreateOrganizationRequest = __esm({
+  "src/serialization/resources/organization/client/requests/CreateOrganizationRequest.ts"() {
+    "use strict";
+    init_core();
+    CreateOrganizationRequest = schemas_exports.object({
+      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
+      artifactReadRequiresToken: schemas_exports.boolean().optional()
+    });
+  }
+});
+
+// src/serialization/resources/organization/client/requests/UpdateOrganizationRequest.ts
+var UpdateOrganizationRequest;
+var init_UpdateOrganizationRequest = __esm({
+  "src/serialization/resources/organization/client/requests/UpdateOrganizationRequest.ts"() {
+    "use strict";
+    init_core();
+    UpdateOrganizationRequest = schemas_exports.object({
+      artifactReadRequiresToken: schemas_exports.boolean()
+    });
+  }
+});
+
+// src/serialization/resources/organization/client/requests/AddUserToOrgRequest.ts
+var AddUserToOrgRequest;
+var init_AddUserToOrgRequest = __esm({
+  "src/serialization/resources/organization/client/requests/AddUserToOrgRequest.ts"() {
+    "use strict";
+    init_core();
+    AddUserToOrgRequest = schemas_exports.object({
+      userId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).UserId),
+      orgId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId)
     });
   }
 });
 
+// src/serialization/resources/organization/client/requests/index.ts
+var init_requests4 = __esm({
+  "src/serialization/resources/organization/client/requests/index.ts"() {
+    "use strict";
+    init_CreateOrganizationRequest();
+    init_UpdateOrganizationRequest();
+    init_AddUserToOrgRequest();
+  }
+});
+
 // src/serialization/resources/organization/client/index.ts
 var init_client4 = __esm({
   "src/serialization/resources/organization/client/index.ts"() {
@@ -5467,13 +6060,17 @@ var init_client4 = __esm({
     init_isMember2();
     init_getMyOrganizationFromScopedToken2();
     init_addUser2();
+    init_requests4();
   }
 });
 
 // src/serialization/resources/organization/index.ts
 var organization_exports2 = {};
 __export(organization_exports2, {
+  AddUserToOrgRequest: () => AddUserToOrgRequest,
+  CreateOrganizationRequest: () => CreateOrganizationRequest,
   Organization: () => Organization,
+  UpdateOrganizationRequest: () => UpdateOrganizationRequest,
   addUser: () => addUser_exports2,
   create: () => create_exports2,
   get: () => get_exports2,
@@ -5484,7 +6081,7 @@ __export(organization_exports2, {
 var init_organization2 = __esm({
   "src/serialization/resources/organization/index.ts"() {
     "use strict";
-    init_types8();
+    init_types6();
     init_client4();
   }
 });
@@ -5538,7 +6135,7 @@ var init_RegistryToken2 = __esm({
       npm: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).NpmRegistryToken),
       maven: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).MavenRegistryToken)
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.type) {
           case "npm":
             return api_exports.RegistryToken.npm(value);
@@ -5548,13 +6145,13 @@ var init_RegistryToken2 = __esm({
             return api_exports.RegistryToken._unknown(value);
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
 
 // src/serialization/resources/registry/types/index.ts
-var init_types9 = __esm({
+var init_types7 = __esm({
   "src/serialization/resources/registry/types/index.ts"() {
     "use strict";
     init_RegistryTokens2();
@@ -5567,25 +6164,19 @@ var init_types9 = __esm({
 // src/serialization/resources/registry/client/generateRegistryTokens.ts
 var generateRegistryTokens_exports2 = {};
 __export(generateRegistryTokens_exports2, {
-  Error: () => Error18,
-  Request: () => Request4,
-  Response: () => Response4
+  Error: () => Error18
 });
-var Request4, Response4, Error18;
+var Error18;
 var init_generateRegistryTokens2 = __esm({
   "src/serialization/resources/registry/client/generateRegistryTokens.ts"() {
     "use strict";
     init_src();
     init_core();
-    Request4 = schemas_exports.object({
-      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId)
-    });
-    Response4 = schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).RegistryTokens);
     Error18 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({}),
       OrganizationNotFoundError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.registry.generateRegistryTokens.Error.unauthorizedError();
@@ -5593,7 +6184,7 @@ var init_generateRegistryTokens2 = __esm({
             return api_exports.registry.generateRegistryTokens.Error.organizationNotFoundError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5602,25 +6193,20 @@ var init_generateRegistryTokens2 = __esm({
 var hasRegistryPermission_exports2 = {};
 __export(hasRegistryPermission_exports2, {
   Error: () => Error19,
-  Request: () => Request5,
-  Response: () => Response5
+  Response: () => Response2
 });
-var Request5, Response5, Error19;
+var Response2, Error19;
 var init_hasRegistryPermission2 = __esm({
   "src/serialization/resources/registry/client/hasRegistryPermission.ts"() {
     "use strict";
-    init_src();
     init_core();
-    Request5 = schemas_exports.object({
-      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
-      token: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).RegistryToken).optional()
-    });
-    Response5 = schemas_exports.boolean();
+    init_src();
+    Response2 = schemas_exports.boolean();
     Error19 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({}),
       OrganizationNotFoundError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.registry.hasRegistryPermission.Error.unauthorizedError();
@@ -5628,7 +6214,7 @@ var init_hasRegistryPermission2 = __esm({
             return api_exports.registry.hasRegistryPermission.Error.organizationNotFoundError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
     });
   }
 });
@@ -5636,24 +6222,19 @@ var init_hasRegistryPermission2 = __esm({
 // src/serialization/resources/registry/client/revokeToken.ts
 var revokeToken_exports2 = {};
 __export(revokeToken_exports2, {
-  Error: () => Error20,
-  Request: () => Request6
+  Error: () => Error20
 });
-var Request6, Error20;
+var Error20;
 var init_revokeToken2 = __esm({
   "src/serialization/resources/registry/client/revokeToken.ts"() {
     "use strict";
     init_src();
     init_core();
-    Request6 = schemas_exports.object({
-      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
-      token: schemas_exports.string()
-    });
     Error20 = schemas_exports.union("error", {
       UnauthorizedError: schemas_exports.object({}),
       OrganizationNotFoundError: schemas_exports.object({})
     }).transform({
-      parse: (value) => {
+      transform: (value) => {
         switch (value.error) {
           case "UnauthorizedError":
             return api_exports.registry.revokeToken.Error.unauthorizedError();
@@ -5661,11 +6242,59 @@ var init_revokeToken2 = __esm({
             return api_exports.registry.revokeToken.Error.organizationNotFoundError();
         }
       },
-      json: (value) => value
+      untransform: ({ _visit, ...value }) => value
+    });
+  }
+});
+
+// src/serialization/resources/registry/client/requests/GenerateRegistryTokensRequest.ts
+var GenerateRegistryTokensRequest;
+var init_GenerateRegistryTokensRequest = __esm({
+  "src/serialization/resources/registry/client/requests/GenerateRegistryTokensRequest.ts"() {
+    "use strict";
+    init_core();
+    GenerateRegistryTokensRequest = schemas_exports.object({
+      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId)
     });
   }
 });
 
+// src/serialization/resources/registry/client/requests/CheckRegistryPermissionRequest.ts
+var CheckRegistryPermissionRequest;
+var init_CheckRegistryPermissionRequest = __esm({
+  "src/serialization/resources/registry/client/requests/CheckRegistryPermissionRequest.ts"() {
+    "use strict";
+    init_core();
+    CheckRegistryPermissionRequest = schemas_exports.object({
+      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
+      token: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).RegistryToken).optional()
+    });
+  }
+});
+
+// src/serialization/resources/registry/client/requests/RevokeTokenRequest.ts
+var RevokeTokenRequest;
+var init_RevokeTokenRequest = __esm({
+  "src/serialization/resources/registry/client/requests/RevokeTokenRequest.ts"() {
+    "use strict";
+    init_core();
+    RevokeTokenRequest = schemas_exports.object({
+      organizationId: schemas_exports.lazy(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationId),
+      token: schemas_exports.string()
+    });
+  }
+});
+
+// src/serialization/resources/registry/client/requests/index.ts
+var init_requests5 = __esm({
+  "src/serialization/resources/registry/client/requests/index.ts"() {
+    "use strict";
+    init_GenerateRegistryTokensRequest();
+    init_CheckRegistryPermissionRequest();
+    init_RevokeTokenRequest();
+  }
+});
+
 // src/serialization/resources/registry/client/index.ts
 var init_client5 = __esm({
   "src/serialization/resources/registry/client/index.ts"() {
@@ -5673,16 +6302,20 @@ var init_client5 = __esm({
     init_generateRegistryTokens2();
     init_hasRegistryPermission2();
     init_revokeToken2();
+    init_requests5();
   }
 });
 
 // src/serialization/resources/registry/index.ts
 var registry_exports2 = {};
 __export(registry_exports2, {
+  CheckRegistryPermissionRequest: () => CheckRegistryPermissionRequest,
+  GenerateRegistryTokensRequest: () => GenerateRegistryTokensRequest,
   MavenRegistryToken: () => MavenRegistryToken,
   NpmRegistryToken: () => NpmRegistryToken,
   RegistryToken: () => RegistryToken2,
   RegistryTokens: () => RegistryTokens,
+  RevokeTokenRequest: () => RevokeTokenRequest,
   generateRegistryTokens: () => generateRegistryTokens_exports2,
   hasRegistryPermission: () => hasRegistryPermission_exports2,
   revokeToken: () => revokeToken_exports2
@@ -5690,7 +6323,7 @@ __export(registry_exports2, {
 var init_registry2 = __esm({
   "src/serialization/resources/registry/index.ts"() {
     "use strict";
-    init_types9();
+    init_types7();
     init_client5();
   }
 });
@@ -5728,7 +6361,7 @@ var init_OrganizationsPage2 = __esm({
 });
 
 // src/serialization/resources/user/types/index.ts
-var init_types10 = __esm({
+var init_types8 = __esm({
   "src/serialization/resources/user/types/index.ts"() {
     "use strict";
     init_User2();
@@ -5736,56 +6369,16 @@ var init_types10 = __esm({
   }
 });
 
-// src/serialization/resources/user/client/getMyself.ts
-var getMyself_exports2 = {};
-__export(getMyself_exports2, {
-  Response: () => Response6
-});
-var Response6;
-var init_getMyself2 = __esm({
-  "src/serialization/resources/user/client/getMyself.ts"() {
-    "use strict";
-    init_core();
-    Response6 = schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).User);
-  }
-});
-
-// src/serialization/resources/user/client/getMyOrganizations.ts
-var getMyOrganizations_exports2 = {};
-__export(getMyOrganizations_exports2, {
-  Response: () => Response7
-});
-var Response7;
-var init_getMyOrganizations2 = __esm({
-  "src/serialization/resources/user/client/getMyOrganizations.ts"() {
-    "use strict";
-    init_core();
-    Response7 = schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization(), serialization_exports))).OrganizationsPage);
-  }
-});
-
-// src/serialization/resources/user/client/index.ts
-var init_client6 = __esm({
-  "src/serialization/resources/user/client/index.ts"() {
-    "use strict";
-    init_getMyself2();
-    init_getMyOrganizations2();
-  }
-});
-
 // src/serialization/resources/user/index.ts
 var user_exports2 = {};
 __export(user_exports2, {
   OrganizationsPage: () => OrganizationsPage,
-  User: () => User,
-  getMyOrganizations: () => getMyOrganizations_exports2,
-  getMyself: () => getMyself_exports2
+  User: () => User
 });
 var init_user2 = __esm({
   "src/serialization/resources/user/index.ts"() {
     "use strict";
-    init_types10();
-    init_client6();
+    init_types8();
   }
 });
 
@@ -5794,19 +6387,25 @@ var init_resources2 = __esm({
   "src/serialization/resources/index.ts"() {
     "use strict";
     init_commons2();
-    init_types7();
+    init_types5();
     init_organization2();
-    init_types8();
+    init_types6();
     init_registry2();
-    init_types9();
+    init_types7();
     init_user2();
-    init_types10();
+    init_types8();
+    init_requests4();
+    init_requests5();
   }
 });
 
 // src/serialization/index.ts
 var serialization_exports = {};
 __export(serialization_exports, {
+  AddUserToOrgRequest: () => AddUserToOrgRequest,
+  CheckRegistryPermissionRequest: () => CheckRegistryPermissionRequest,
+  CreateOrganizationRequest: () => CreateOrganizationRequest,
+  GenerateRegistryTokensRequest: () => GenerateRegistryTokensRequest,
   MavenRegistryToken: () => MavenRegistryToken,
   NpmRegistryToken: () => NpmRegistryToken,
   Organization: () => Organization,
@@ -5814,6 +6413,8 @@ __export(serialization_exports, {
   OrganizationsPage: () => OrganizationsPage,
   RegistryToken: () => RegistryToken2,
   RegistryTokens: () => RegistryTokens,
+  RevokeTokenRequest: () => RevokeTokenRequest,
+  UpdateOrganizationRequest: () => UpdateOrganizationRequest,
   User: () => User,
   UserId: () => UserId2,
   commons: () => commons_exports2,