webflow-api 3.2.0 → 3.3.0-beta

package/core/schemas/builders/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./bigint";
-export * from "./date";
-export * from "./enum";
-export * from "./lazy";
-export * from "./list";
-export * from "./literals";
-export * from "./object";
-export * from "./object-like";
-export * from "./primitives";
-export * from "./record";
-export * from "./schema-utils";
-export * from "./set";
-export * from "./undiscriminated-union";
-export * from "./union";
+export * from "./bigint/index";
+export * from "./date/index";
+export * from "./enum/index";
+export * from "./lazy/index";
+export * from "./list/index";
+export * from "./literals/index";
+export * from "./object/index";
+export * from "./object-like/index";
+export * from "./primitives/index";
+export * from "./record/index";
+export * from "./schema-utils/index";
+export * from "./set/index";
+export * from "./undiscriminated-union/index";
+export * from "./union/index";

package/core/schemas/builders/index.js

@@ -14,17 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./bigint"), exports);
-__exportStar(require("./date"), exports);
-__exportStar(require("./enum"), exports);
-__exportStar(require("./lazy"), exports);
-__exportStar(require("./list"), exports);
-__exportStar(require("./literals"), exports);
-__exportStar(require("./object"), exports);
-__exportStar(require("./object-like"), exports);
-__exportStar(require("./primitives"), exports);
-__exportStar(require("./record"), exports);
-__exportStar(require("./schema-utils"), exports);
-__exportStar(require("./set"), exports);
-__exportStar(require("./undiscriminated-union"), exports);
-__exportStar(require("./union"), exports);
+__exportStar(require("./bigint/index"), exports);
+__exportStar(require("./date/index"), exports);
+__exportStar(require("./enum/index"), exports);
+__exportStar(require("./lazy/index"), exports);
+__exportStar(require("./list/index"), exports);
+__exportStar(require("./literals/index"), exports);
+__exportStar(require("./object/index"), exports);
+__exportStar(require("./object-like/index"), exports);
+__exportStar(require("./primitives/index"), exports);
+__exportStar(require("./record/index"), exports);
+__exportStar(require("./schema-utils/index"), exports);
+__exportStar(require("./set/index"), exports);
+__exportStar(require("./undiscriminated-union/index"), exports);
+__exportStar(require("./union/index"), exports);

package/core/schemas/builders/lazy/index.d.ts

@@ -1,3 +1,3 @@
-export { lazy } from "./lazy";
 export type { SchemaGetter } from "./lazy";
+export { lazy } from "./lazy";
 export { lazyObject } from "./lazyObject";

package/core/schemas/builders/lazy/lazy.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 export type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;

package/core/schemas/builders/lazy/lazy.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazy = lazy;
 exports.constructLazyBaseSchema = constructLazyBaseSchema;
 exports.getMemoizedSchema = getMemoizedSchema;
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function lazy(getter) {
     const baseSchema = constructLazyBaseSchema(getter);
-    return Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, baseSchema), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function constructLazyBaseSchema(getter) {
     return {

package/core/schemas/builders/lazy/lazyObject.d.ts

@@ -1,3 +1,3 @@
-import { ObjectSchema } from "../object/types";
-import { SchemaGetter } from "./lazy";
+import type { ObjectSchema } from "../object/types";
+import { type SchemaGetter } from "./lazy";
 export declare function lazyObject<Raw, Parsed>(getter: SchemaGetter<ObjectSchema<Raw, Parsed>>): ObjectSchema<Raw, Parsed>;

package/core/schemas/builders/lazy/lazyObject.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyObject = lazyObject;
-const object_1 = require("../object");
-const object_like_1 = require("../object-like");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../object/index");
+const index_2 = require("../object-like/index");
+const index_3 = require("../schema-utils/index");
 const lazy_1 = require("./lazy");
 function lazyObject(getter) {
     const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getRawProperties(), _getParsedProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getParsedProperties() });
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), (0, object_1.getObjectUtils)(baseSchema));
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, index_3.getSchemaUtils)(baseSchema)), (0, index_2.getObjectLikeUtils)(baseSchema)), (0, index_1.getObjectUtils)(baseSchema));
 }

package/core/schemas/builders/list/list.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function list<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Parsed[]>;

package/core/schemas/builders/list/list.js

@@ -4,7 +4,7 @@ exports.list = list;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function list(schema) {
     const baseSchema = {
         parse: (raw, opts) => validateAndTransformArray(raw, (item, index) => {
@@ -17,7 +17,7 @@ function list(schema) {
         }),
         getType: () => Schema_1.SchemaType.LIST,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function validateAndTransformArray(value, transformItem) {
     if (!Array.isArray(value)) {

package/core/schemas/builders/literals/booleanLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

package/core/schemas/builders/literals/index.d.ts

@@ -1,2 +1,2 @@
-export { stringLiteral } from "./stringLiteral";
 export { booleanLiteral } from "./booleanLiteral";
+export { stringLiteral } from "./stringLiteral";

package/core/schemas/builders/literals/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanLiteral = exports.stringLiteral = void 0;
-var stringLiteral_1 = require("./stringLiteral");
-Object.defineProperty(exports, "stringLiteral", { enumerable: true, get: function () { return stringLiteral_1.stringLiteral; } });
+exports.stringLiteral = exports.booleanLiteral = void 0;
 var booleanLiteral_1 = require("./booleanLiteral");
 Object.defineProperty(exports, "booleanLiteral", { enumerable: true, get: function () { return booleanLiteral_1.booleanLiteral; } });
+var stringLiteral_1 = require("./stringLiteral");
+Object.defineProperty(exports, "stringLiteral", { enumerable: true, get: function () { return stringLiteral_1.stringLiteral; } });

package/core/schemas/builders/literals/stringLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

package/core/schemas/builders/object/index.d.ts

@@ -1,6 +1,6 @@
 export { getObjectUtils, object } from "./object";
-export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
-export { isProperty, property } from "./property";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { Property } from "./property";
+export { isProperty, property } from "./property";
 export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

package/core/schemas/builders/object/object.d.ts

@@ -1,3 +1,3 @@
-import { BaseObjectSchema, ObjectUtils, PropertySchemas, inferObjectSchemaFromPropertySchemas } from "./types";
+import type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } 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/core/schemas/builders/object/object.js

@@ -10,8 +10,8 @@ const isPlainObject_1 = require("../../utils/isPlainObject");
 const keys_1 = require("../../utils/keys");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const partition_1 = require("../../utils/partition");
-const object_like_1 = require("../object-like");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../object-like/index");
+const index_2 = require("../schema-utils/index");
 const property_1 = require("./property");
 function object(schemas) {
     const baseSchema = {
@@ -103,7 +103,7 @@ function object(schemas) {
         },
         getType: () => Schema_1.SchemaType.OBJECT,
     };
-    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));
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_2.getSchemaUtils)(baseSchema)), (0, index_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
 }
 function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
@@ -192,7 +192,7 @@ function getObjectUtils(schema) {
                 },
                 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));
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, index_2.getSchemaUtils)(baseSchema)), (0, index_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
         },
         passthrough: () => {
             const baseSchema = {
@@ -220,7 +220,7 @@ function getObjectUtils(schema) {
                 },
                 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));
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, index_2.getSchemaUtils)(baseSchema)), (0, index_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
         },
     };
 }

package/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts

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

package/core/schemas/builders/object/property.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "../../Schema";
+import type { Schema } from "../../Schema";
 export declare function property<RawKey extends string, RawValue, ParsedValue>(rawKey: RawKey, valueSchema: Schema<RawValue, ParsedValue>): Property<RawKey, RawValue, ParsedValue>;
 export interface Property<RawKey extends string, RawValue, ParsedValue> {
     rawKey: RawKey;

package/core/schemas/builders/object/types.d.ts

@@ -1,8 +1,8 @@
-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";
+import type { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import type { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
+import type { ObjectLikeUtils } from "../object-like/index";
+import type { SchemaUtils } from "../schema-utils/index";
+import type { Property } from "./property";
 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)[];

package/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -1,5 +1,5 @@
-import { BaseSchema } from "../../Schema";
-import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
+import type { BaseSchema } from "../../Schema";
+import type { ObjectLikeSchema, ObjectLikeUtils } from "./types";
 export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports

package/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -5,7 +5,7 @@ exports.withParsedProperties = withParsedProperties;
 const filterObject_1 = require("../../utils/filterObject");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function getObjectLikeUtils(schema) {
     return {
         withParsedProperties: (properties) => withParsedProperties(schema, properties),
@@ -49,5 +49,5 @@ function withParsedProperties(objectLike, properties) {
         },
         getType: () => objectLike.getType(),
     };
-    return Object.assign(Object.assign(Object.assign({}, objectSchema), (0, schema_utils_1.getSchemaUtils)(objectSchema)), getObjectLikeUtils(objectSchema));
+    return Object.assign(Object.assign(Object.assign({}, objectSchema), (0, index_1.getSchemaUtils)(objectSchema)), getObjectLikeUtils(objectSchema));
 }

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

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 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: {

package/core/schemas/builders/primitives/any.d.ts

@@ -1 +1,2 @@
-export declare const any: () => import("../../Schema").Schema<any, any>;
+import { type Schema } from "../../Schema";
+export declare const any: () => Schema<any, any>;

package/core/schemas/builders/primitives/any.js

@@ -3,4 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.any = void 0;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
-exports.any = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.ANY, (value) => ({ ok: true, value }));
+exports.any = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.ANY, (value) => ({
+    ok: true,
+    value,
+}));

package/core/schemas/builders/primitives/boolean.d.ts

@@ -1 +1,2 @@
-export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;
+import { type Schema } from "../../Schema";
+export declare const boolean: () => Schema<boolean, boolean>;

package/core/schemas/builders/primitives/number.d.ts

@@ -1 +1,2 @@
-export declare const number: () => import("../../Schema").Schema<number, number>;
+import { type Schema } from "../../Schema";
+export declare const number: () => Schema<number, number>;

package/core/schemas/builders/primitives/string.d.ts

@@ -1 +1,2 @@
-export declare const string: () => import("../../Schema").Schema<string, string>;
+import { type Schema } from "../../Schema";
+export declare const string: () => Schema<string, string>;

package/core/schemas/builders/primitives/unknown.d.ts

@@ -1 +1,2 @@
-export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;
+import { type Schema } from "../../Schema";
+export declare const unknown: () => Schema<unknown, unknown>;

package/core/schemas/builders/record/record.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { RecordSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { RecordSchema } from "./types";
 export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/core/schemas/builders/record/record.js

@@ -6,7 +6,7 @@ const entries_1 = require("../../utils/entries");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function record(keySchema, valueSchema) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -41,7 +41,7 @@ function record(keySchema, valueSchema) {
         },
         getType: () => Schema_1.SchemaType.RECORD,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
@@ -63,7 +63,7 @@ function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transfo
         let key = stringKey;
         if (isKeyNumeric) {
             const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
-            if (!isNaN(numberKey)) {
+            if (!Number.isNaN(numberKey)) {
                 key = numberKey;
             }
         }

package/core/schemas/builders/record/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema } from "../../Schema";
-import { SchemaUtils } from "../schema-utils";
+import type { BaseSchema } from "../../Schema";
+import type { SchemaUtils } from "../schema-utils/index";
 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/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class JsonError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class ParseError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

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

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+import { type BaseSchema, type Schema, type SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;

package/core/schemas/builders/schema-utils/index.d.ts

@@ -1,4 +1,4 @@
-export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export type { SchemaUtils } from "./getSchemaUtils";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export { JsonError } from "./JsonError";
 export { ParseError } from "./ParseError";

package/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare function stringifyValidationError(error: ValidationError): string;

package/core/schemas/builders/set/set.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/core/schemas/builders/set/set.js

@@ -4,10 +4,10 @@ exports.set = set;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const list_1 = require("../list");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../list/index");
+const index_2 = require("../schema-utils/index");
 function set(schema) {
-    const listSchema = (0, list_1.list)(schema);
+    const listSchema = (0, index_1.list)(schema);
     const baseSchema = {
         parse: (raw, opts) => {
             const parsedList = listSchema.parse(raw, opts);
@@ -39,5 +39,5 @@ function set(schema) {
         },
         getType: () => Schema_1.SchemaType.SET,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_2.getSchemaUtils)(baseSchema));
 }

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

@@ -1,4 +1,4 @@
-import { Schema, inferParsed, inferRaw } from "../../Schema";
+import type { inferParsed, inferRaw, Schema } 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/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
 export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.undiscriminatedUnion = undiscriminatedUnion;
 const Schema_1 = require("../../Schema");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function undiscriminatedUnion(schemas) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -14,7 +14,7 @@ function undiscriminatedUnion(schemas) {
         },
         getType: () => Schema_1.SchemaType.UNDISCRIMINATED_UNION,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
     const errors = [];

package/core/schemas/builders/union/index.d.ts

@@ -1,4 +1,4 @@
-export { discriminant } from "./discriminant";
 export type { Discriminant } from "./discriminant";
+export { discriminant } from "./discriminant";
 export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
 export { union } from "./union";

package/core/schemas/builders/union/types.d.ts

@@ -1,5 +1,5 @@
-import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
-import { Discriminant } from "./discriminant";
+import type { inferParsedObject, inferRawObject, ObjectSchema } from "../object/index";
+import type { Discriminant } from "./discriminant";
 export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };

package/core/schemas/builders/union/union.d.ts

@@ -1,4 +1,4 @@
-import { ObjectLikeSchema } from "../object-like";
-import { Discriminant } from "./discriminant";
-import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
+import { type ObjectLikeSchema } from "../object-like";
+import type { Discriminant } from "./discriminant";
+import type { inferParsedUnion, inferRawUnion, UnionSubtypes } 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/core/schemas/builders/union/union.js

@@ -17,15 +17,15 @@ const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageFo
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const keys_1 = require("../../utils/keys");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const enum_1 = require("../enum");
+const index_1 = require("../enum/index");
 const object_like_1 = require("../object-like");
-const schema_utils_1 = require("../schema-utils");
+const index_2 = require("../schema-utils/index");
 function union(discriminant, union) {
     const rawDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.rawDiscriminant;
     const parsedDiscriminant = typeof discriminant === "string"
         ? discriminant
         : discriminant.parsedDiscriminant;
-    const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
+    const discriminantValueSchema = (0, index_1.enum_)((0, keys_1.keys)(union));
     const baseSchema = {
         parse: (raw, opts) => {
             return transformAndValidateUnion({
@@ -65,7 +65,7 @@ function union(discriminant, union) {
         },
         getType: () => Schema_1.SchemaType.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));
+    return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_2.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
 function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {

package/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./builders";
+export * from "./builders/index";
 export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/core/schemas/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./builders"), exports);
+__exportStar(require("./builders/index"), exports);

package/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -1,2 +1,2 @@
-import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+import type { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
 export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/core/schemas/utils/createIdentitySchemaCreator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
-const schema_utils_1 = require("../builders/schema-utils");
+const index_1 = require("../builders/schema-utils/index");
 const maybeSkipValidation_1 = require("./maybeSkipValidation");
 function createIdentitySchemaCreator(schemaType, validate) {
     return () => {
@@ -10,6 +10,6 @@ function createIdentitySchemaCreator(schemaType, validate) {
             json: validate,
             getType: () => schemaType,
         };
-        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
     };
 }

package/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-import { BaseSchema } from "../Schema";
+import type { BaseSchema } from "../Schema";
 export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/core/schemas/utils/maybeSkipValidation.js

@@ -9,7 +9,7 @@ function transformAndMaybeSkipValidation(transform) {
         const transformed = transform(value, opts);
         const { skipValidation = false } = opts !== null && opts !== void 0 ? opts : {};
         if (!transformed.ok && skipValidation) {
-            // eslint-disable-next-line no-console
+            // biome-ignore lint/suspicious/noConsole: allow console
             console.warn([
                 "Failed to validate.",
                 ...transformed.errors.map((error) => "  - " +

package/core/url/encodePathParam.d.ts

@@ -0,0 +1 @@
+export declare function encodePathParam(param: unknown): string;

package/core/url/encodePathParam.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePathParam = encodePathParam;
+function encodePathParam(param) {
+    if (param === null) {
+        return "null";
+    }
+    const typeofParam = typeof param;
+    switch (typeofParam) {
+        case "undefined":
+            return "undefined";
+        case "string":
+        case "number":
+        case "boolean":
+            break;
+        default:
+            param = String(param);
+            break;
+    }
+    return encodeURIComponent(param);
+}