npm - vellum-ai - Versions diffs - 0.13.3 → 0.13.4 - Mend

vellum-ai 0.13.3 → 0.13.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1468) hide show

package/dist/core/schemas/builders/list/list.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.list = void 0;
+exports.list = list;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -19,7 +19,6 @@ function list(schema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.list = list;
 function validateAndTransformArray(value, transformItem) {
     if (!Array.isArray(value)) {
         return {

package/dist/core/schemas/builders/literals/booleanLiteral.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanLiteral = void 0;
+exports.booleanLiteral = booleanLiteral;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -26,4 +26,3 @@ function booleanLiteral(literal) {
     });
     return schemaCreator();
 }
-exports.booleanLiteral = booleanLiteral;

package/dist/core/schemas/builders/literals/stringLiteral.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringLiteral = void 0;
+exports.stringLiteral = stringLiteral;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -26,4 +26,3 @@ function stringLiteral(literal) {
     });
     return schemaCreator();
 }
-exports.stringLiteral = stringLiteral;

package/dist/core/schemas/builders/object/object.d.ts CHANGED Viewed

@@ -1,3 +1,3 @@
-import { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } from "./types";
+import { BaseObjectSchema, ObjectUtils, PropertySchemas, inferObjectSchemaFromPropertySchemas } from "./types";
 export declare function object<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectSchemaFromPropertySchemas<T>;
 export declare function getObjectUtils<Raw, Parsed>(schema: BaseObjectSchema<Raw, Parsed>): ObjectUtils<Raw, Parsed>;

package/dist/core/schemas/builders/object/object.js CHANGED Viewed

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectUtils = exports.object = void 0;
+exports.object = object;
+exports.getObjectUtils = getObjectUtils;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const filterObject_1 = require("../../utils/filterObject");
@@ -104,7 +105,6 @@ function object(schemas) {
     };
     return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
 }
-exports.object = object;
 function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
@@ -194,9 +194,36 @@ function getObjectUtils(schema) {
             };
             return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
         },
+        passthrough: () => {
+            const baseSchema = {
+                _getParsedProperties: () => schema._getParsedProperties(),
+                _getRawProperties: () => schema._getRawProperties(),
+                parse: (raw, opts) => {
+                    const transformed = schema.parse(raw, Object.assign(Object.assign({}, opts), { unrecognizedObjectKeys: "passthrough" }));
+                    if (!transformed.ok) {
+                        return transformed;
+                    }
+                    return {
+                        ok: true,
+                        value: Object.assign(Object.assign({}, raw), transformed.value),
+                    };
+                },
+                json: (parsed, opts) => {
+                    const transformed = schema.json(parsed, Object.assign(Object.assign({}, opts), { unrecognizedObjectKeys: "passthrough" }));
+                    if (!transformed.ok) {
+                        return transformed;
+                    }
+                    return {
+                        ok: true,
+                        value: Object.assign(Object.assign({}, parsed), transformed.value),
+                    };
+                },
+                getType: () => Schema_1.SchemaType.OBJECT,
+            };
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
+        },
     };
 }
-exports.getObjectUtils = getObjectUtils;
 function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
     const extensionPropertiesSet = new Set(extensionKeys);
     const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));

package/dist/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
-import { inferParsedPropertySchema, inferRawObjectFromPropertySchemas, ObjectSchema, PropertySchemas } from "./types";
+import { ObjectSchema, PropertySchemas, inferParsedPropertySchema, inferRawObjectFromPropertySchemas } from "./types";
 export declare function objectWithoutOptionalProperties<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T>;
-export declare type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
-export declare type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {
+export type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
+export type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {
     [K in keyof T]: inferParsedPropertySchema<T[K]>;
 };

package/dist/core/schemas/builders/object/objectWithoutOptionalProperties.js CHANGED Viewed

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectWithoutOptionalProperties = void 0;
+exports.objectWithoutOptionalProperties = objectWithoutOptionalProperties;
 const object_1 = require("./object");
 function objectWithoutOptionalProperties(schemas) {
     return (0, object_1.object)(schemas);
 }
-exports.objectWithoutOptionalProperties = objectWithoutOptionalProperties;

package/dist/core/schemas/builders/object/property.js CHANGED Viewed

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProperty = exports.property = void 0;
+exports.property = property;
+exports.isProperty = isProperty;
 function property(rawKey, valueSchema) {
     return {
         rawKey,
@@ -8,9 +9,7 @@ function property(rawKey, valueSchema) {
         isProperty: true,
     };
 }
-exports.property = property;
 function isProperty(maybeProperty) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return maybeProperty.isProperty;
 }
-exports.isProperty = isProperty;

package/dist/core/schemas/builders/object/types.d.ts CHANGED Viewed

@@ -1,26 +1,31 @@
-import { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import { BaseSchema, Schema, inferParsed, inferRaw } from "../../Schema";
 import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
 import { ObjectLikeUtils } from "../object-like";
 import { SchemaUtils } from "../schema-utils";
 import { Property } from "./property";
-export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => (keyof Raw)[];
     _getParsedProperties: () => (keyof Parsed)[];
 }
 export interface ObjectUtils<Raw, Parsed> {
     extend: <RawExtension, ParsedExtension>(schemas: ObjectSchema<RawExtension, ParsedExtension>) => ObjectSchema<Raw & RawExtension, Parsed & ParsedExtension>;
+    passthrough: () => ObjectSchema<Raw & {
+        [key: string]: unknown;
+    }, Parsed & {
+        [key: string]: unknown;
+    }>;
 }
-export declare type inferRawObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<infer Raw, any> ? Raw : never;
-export declare type inferParsedObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<any, infer Parsed> ? Parsed : never;
-export declare type inferObjectSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectFromPropertySchemas<T>>;
-export declare type inferRawObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+export type inferRawObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<infer Raw, any> ? Raw : never;
+export type inferParsedObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<any, infer Parsed> ? Parsed : never;
+export type inferObjectSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectFromPropertySchemas<T>>;
+export type inferRawObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
     [ParsedKey in keyof T as inferRawKey<ParsedKey, T[ParsedKey]>]: inferRawPropertySchema<T[ParsedKey]>;
 }>;
-export declare type inferParsedObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+export type inferParsedObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
     [K in keyof T]: inferParsedPropertySchema<T[K]>;
 }>;
-export declare type PropertySchemas<ParsedKeys extends string | number | symbol> = Record<ParsedKeys, Property<any, any, any> | Schema<any, any>>;
-export declare type inferRawPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, infer Raw, any> ? Raw : P extends Schema<any, any> ? inferRaw<P> : never;
-export declare type inferParsedPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, any, infer Parsed> ? Parsed : P extends Schema<any, any> ? inferParsed<P> : never;
-export declare type inferRawKey<ParsedKey extends string | number | symbol, P extends Property<any, any, any> | Schema<any, any>> = P extends Property<infer Raw, any, any> ? Raw : ParsedKey;
+export type PropertySchemas<ParsedKeys extends string | number | symbol> = Record<ParsedKeys, Property<any, any, any> | Schema<any, any>>;
+export type inferRawPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, infer Raw, any> ? Raw : P extends Schema<any, any> ? inferRaw<P> : never;
+export type inferParsedPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, any, infer Parsed> ? Parsed : P extends Schema<any, any> ? inferParsed<P> : never;
+export type inferRawKey<ParsedKey extends string | number | symbol, P extends Property<any, any, any> | Schema<any, any>> = P extends Property<infer Raw, any, any> ? Raw : ParsedKey;

package/dist/core/schemas/builders/object-like/getObjectLikeUtils.js CHANGED Viewed

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withParsedProperties = exports.getObjectLikeUtils = void 0;
+exports.getObjectLikeUtils = getObjectLikeUtils;
+exports.withParsedProperties = withParsedProperties;
 const filterObject_1 = require("../../utils/filterObject");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
@@ -10,7 +11,6 @@ function getObjectLikeUtils(schema) {
         withParsedProperties: (properties) => withParsedProperties(schema, properties),
     };
 }
-exports.getObjectLikeUtils = getObjectLikeUtils;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports
  */
@@ -51,4 +51,3 @@ function withParsedProperties(objectLike, properties) {
     };
     return Object.assign(Object.assign(Object.assign({}, objectSchema), (0, schema_utils_1.getSchemaUtils)(objectSchema)), getObjectLikeUtils(objectSchema));
 }
-exports.withParsedProperties = withParsedProperties;

package/dist/core/schemas/builders/object-like/types.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
+export type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
 export interface ObjectLikeUtils<Raw, Parsed> {
     withParsedProperties: <T extends Record<string, any>>(properties: {
         [K in keyof T]: T[K] | ((parsed: Parsed) => T[K]);

package/dist/core/schemas/builders/record/record.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.record = void 0;
+exports.record = record;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -43,7 +43,6 @@ function record(keySchema, valueSchema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.record = record;
 function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {

package/dist/core/schemas/builders/record/types.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 import { BaseSchema } from "../../Schema";
 import { SchemaUtils } from "../schema-utils";
-export declare type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
-export declare type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
+    nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
     transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
     parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
@@ -13,5 +14,6 @@ export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Pars
 /**
  * schema utils are defined in one file to resolve issues with circular imports
  */
+export declare function nullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null, Parsed | null>;
 export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
 export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.js CHANGED Viewed

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transform = exports.optional = exports.getSchemaUtils = void 0;
+exports.getSchemaUtils = getSchemaUtils;
+exports.nullable = nullable;
+exports.optional = optional;
+exports.transform = transform;
 const Schema_1 = require("../../Schema");
 const JsonError_1 = require("./JsonError");
 const ParseError_1 = require("./ParseError");
 function getSchemaUtils(schema) {
     return {
+        nullable: () => nullable(schema),
         optional: () => optional(schema),
         transform: (transformer) => transform(schema, transformer),
         parseOrThrow: (raw, opts) => {
@@ -24,10 +28,33 @@ function getSchemaUtils(schema) {
         },
     };
 }
-exports.getSchemaUtils = getSchemaUtils;
 /**
  * schema utils are defined in one file to resolve issues with circular imports
  */
+function nullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_1.SchemaType.NULLABLE,
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
 function optional(schema) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -58,7 +85,6 @@ function optional(schema) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.optional = optional;
 function transform(schema, transformer) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -79,4 +105,3 @@ function transform(schema, transformer) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.transform = transform;

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.js CHANGED Viewed

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyValidationError = void 0;
+exports.stringifyValidationError = stringifyValidationError;
 function stringifyValidationError(error) {
     if (error.path.length === 0) {
         return error.message;
     }
     return `${error.path.join(" -> ")}: ${error.message}`;
 }
-exports.stringifyValidationError = stringifyValidationError;

package/dist/core/schemas/builders/set/set.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.set = void 0;
+exports.set = set;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -41,4 +41,3 @@ function set(schema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.set = set;

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { inferParsed, inferRaw, Schema } from "../../Schema";
-export declare type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
-export declare type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
-export declare type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;
+import { Schema, inferParsed, inferRaw } from "../../Schema";
+export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
+export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
+export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undiscriminatedUnion = void 0;
+exports.undiscriminatedUnion = undiscriminatedUnion;
 const Schema_1 = require("../../Schema");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
@@ -16,7 +16,6 @@ function undiscriminatedUnion(schemas) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.undiscriminatedUnion = undiscriminatedUnion;
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
     const errors = [];
     for (const [index, schema] of schemas.entries()) {

package/dist/core/schemas/builders/union/discriminant.js CHANGED Viewed

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.discriminant = void 0;
+exports.discriminant = discriminant;
 function discriminant(parsedDiscriminant, rawDiscriminant) {
     return {
         parsedDiscriminant,
         rawDiscriminant,
     };
 }
-exports.discriminant = discriminant;

package/dist/core/schemas/builders/union/types.d.ts CHANGED Viewed

@@ -1,13 +1,13 @@
-import { inferParsedObject, inferRawObject, ObjectSchema } from "../object";
+import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
 import { Discriminant } from "./discriminant";
-export declare type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
+export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };
-export declare type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+export type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
     [K in keyof U]: Record<inferRawDiscriminant<D>, K> & inferRawObject<U[K]>;
 }[keyof U];
-export declare type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+export type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
     [K in keyof U]: Record<inferParsedDiscriminant<D>, K> & inferParsedObject<U[K]>;
 }[keyof U];
-export declare type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
-export declare type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;
+export type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
+export type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;

package/dist/core/schemas/builders/union/union.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 import { ObjectLikeSchema } from "../object-like";
 import { Discriminant } from "./discriminant";
-import { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
+import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
 export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/dist/core/schemas/builders/union/union.js CHANGED Viewed

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.union = void 0;
+exports.union = union;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
@@ -67,7 +67,6 @@ function union(discriminant, union) {
     };
     return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
-exports.union = union;
 function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {

package/dist/core/schemas/utils/MaybePromise.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export ~~declare~~ type MaybePromise<T> = T \| Promise<T>;
1	+ export type MaybePromise<T> = T \| Promise<T>;

package/dist/core/schemas/utils/addQuestionMarksToNullableProperties.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
-export declare type addQuestionMarksToNullableProperties<T> = {
+export type addQuestionMarksToNullableProperties<T> = {
     [K in OptionalKeys<T>]?: T[K];
 } & Pick<T, RequiredKeys<T>>;
-export declare type OptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : null extends T[K] ? K : 1 extends (any extends T[K] ? 0 : 1) ? never : K;
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
 }[keyof T];
-export declare type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;
+export type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;

package/dist/core/schemas/utils/createIdentitySchemaCreator.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIdentitySchemaCreator = void 0;
+exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
 const schema_utils_1 = require("../builders/schema-utils");
 const maybeSkipValidation_1 = require("./maybeSkipValidation");
 function createIdentitySchemaCreator(schemaType, validate) {
@@ -13,4 +13,3 @@ function createIdentitySchemaCreator(schemaType, validate) {
         return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
     };
 }
-exports.createIdentitySchemaCreator = createIdentitySchemaCreator;

package/dist/core/schemas/utils/entries.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare function entries<T>(object: T): [keyof T, T[keyof T]][];
1	+ export declare function entries<T extends object>(object: T): [keyof T, T[keyof T]][];

package/dist/core/schemas/utils/entries.js CHANGED Viewed

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entries = void 0;
+exports.entries = entries;
 function entries(object) {
     return Object.entries(object);
 }
-exports.entries = entries;

package/dist/core/schemas/utils/filterObject.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare function filterObject<T, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;
1	+ export declare function filterObject<T extends object, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;

package/dist/core/schemas/utils/filterObject.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterObject = void 0;
+exports.filterObject = filterObject;
 function filterObject(obj, keysToInclude) {
     const keysToIncludeSet = new Set(keysToInclude);
     return Object.entries(obj).reduce((acc, [key, value]) => {
@@ -11,4 +11,3 @@ function filterObject(obj, keysToInclude) {
         // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
     }, {});
 }
-exports.filterObject = filterObject;

package/dist/core/schemas/utils/getErrorMessageForIncorrectType.js CHANGED Viewed

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageForIncorrectType = void 0;
+exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getErrorMessageForIncorrectType(value, expectedType) {
     return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
 }
-exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getTypeAsString(value) {
     if (Array.isArray(value)) {
         return "list";

package/dist/core/schemas/utils/isPlainObject.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPlainObject = void 0;
+exports.isPlainObject = isPlainObject;
 // borrowed from https://github.com/lodash/lodash/blob/master/isPlainObject.js
 function isPlainObject(value) {
     if (typeof value !== "object" || value === null) {
@@ -15,4 +15,3 @@ function isPlainObject(value) {
     }
     return Object.getPrototypeOf(value) === proto;
 }
-exports.isPlainObject = isPlainObject;

package/dist/core/schemas/utils/keys.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare function keys<T>(object: T): (keyof T)[];
1	+ export declare function keys<T extends object>(object: T): (keyof T)[];

package/dist/core/schemas/utils/keys.js CHANGED Viewed

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keys = void 0;
+exports.keys = keys;
 function keys(object) {
     return Object.keys(object);
 }
-exports.keys = keys;

package/dist/core/schemas/utils/maybeSkipValidation.js CHANGED Viewed

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeSkipValidation = void 0;
+exports.maybeSkipValidation = maybeSkipValidation;
 function maybeSkipValidation(schema) {
     return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
 }
-exports.maybeSkipValidation = maybeSkipValidation;
 function transformAndMaybeSkipValidation(transform) {
     return (value, opts) => {
         const transformed = transform(value, opts);

package/dist/core/schemas/utils/partition.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.partition = void 0;
+exports.partition = partition;
 function partition(items, predicate) {
     const trueItems = [], falseItems = [];
     for (const item of items) {
@@ -13,4 +13,3 @@ function partition(items, predicate) {
     }
     return [trueItems, falseItems];
 }
-exports.partition = partition;

package/dist/core/streaming-fetcher/Stream.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Readable } from "stream";
 export declare namespace Stream {
     interface Args {