webflow-api 3.1.4 → 3.2.1

package/core/schemas/builders/object/objectWithoutOptionalProperties.js

@@ -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/core/schemas/builders/object/property.js

@@ -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/core/schemas/builders/object/types.d.ts

@@ -1,9 +1,9 @@
-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)[];
@@ -16,16 +16,16 @@ export interface ObjectUtils<Raw, 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/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -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/core/schemas/builders/object-like/types.d.ts

@@ -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/core/schemas/builders/record/record.js

@@ -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 {
@@ -57,8 +56,7 @@ function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transfo
         };
     }
     return (0, entries_1.entries)(value).reduce((accPromise, [stringKey, value]) => {
-        // skip nullish keys
-        if (value == null) {
+        if (value === undefined) {
             return accPromise;
         }
         const acc = accPromise;

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

@@ -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/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,6 +1,8 @@
 import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
+    nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    optionalNullable: () => Schema<Raw | null | undefined, Parsed | null | undefined>;
     transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
     parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
     jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
@@ -13,5 +15,7 @@ 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 optionalNullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | null | undefined>;
 export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

package/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -1,12 +1,18 @@
 "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.optionalNullable = optionalNullable;
+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),
+        optionalNullable: () => optionalNullable(schema),
         transform: (transformer) => transform(schema, transformer),
         parseOrThrow: (raw, opts) => {
             const parsed = schema.parse(raw, opts);
@@ -24,10 +30,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 +87,42 @@ function optional(schema) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.optional = optional;
+function optionalNullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (raw === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (parsed === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_1.SchemaType.OPTIONAL_NULLABLE,
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
 function transform(schema, transformer) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -79,4 +143,3 @@ function transform(schema, transformer) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.transform = transform;

package/core/schemas/builders/schema-utils/stringifyValidationErrors.js

@@ -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/core/schemas/builders/set/set.js

@@ -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/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -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/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -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/core/schemas/builders/union/discriminant.js

@@ -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/core/schemas/builders/union/types.d.ts

@@ -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/core/schemas/builders/union/union.d.ts

@@ -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/core/schemas/builders/union/union.js

@@ -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/core/schemas/utils/MaybePromise.d.ts

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

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

@@ -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/core/schemas/utils/createIdentitySchemaCreator.js

@@ -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/core/schemas/utils/entries.d.ts

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

package/core/schemas/utils/entries.js

@@ -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/core/schemas/utils/filterObject.d.ts

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

package/core/schemas/utils/filterObject.js

@@ -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/core/schemas/utils/getErrorMessageForIncorrectType.js

@@ -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/core/schemas/utils/isPlainObject.js

@@ -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/core/schemas/utils/keys.d.ts

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

package/core/schemas/utils/keys.js

@@ -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/core/schemas/utils/maybeSkipValidation.js

@@ -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/core/schemas/utils/partition.js

@@ -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/Client.d.ts

@@ -22,7 +22,11 @@ import { Workspaces } from "./api/resources/workspaces/client/Client";
 export declare namespace WebflowClient {
     interface Options {
         environment?: core.Supplier<environments.WebflowEnvironment | environments.WebflowEnvironmentUrls>;
-        accessToken: core.Supplier<core.BearerToken>;
+        /** Specify a custom URL to connect the client to. */
+        baseUrl?: core.Supplier<string>;
+        accessToken?: core.Supplier<core.BearerToken | undefined>;
+        /** Additional headers to include in requests. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
     }
     interface RequestOptions {
         /** The maximum time to wait for a response in seconds. */
@@ -32,42 +36,42 @@ export declare namespace WebflowClient {
         /** A hook to abort the request. */
         abortSignal?: AbortSignal;
         /** Additional headers to include in the request. */
-        headers?: Record<string, string>;
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
     }
 }
 export declare class WebflowClient {
     protected readonly _options: WebflowClient.Options;
-    constructor(_options: WebflowClient.Options);
     protected _token: Token | undefined;
-    get token(): Token;
     protected _sites: Sites | undefined;
-    get sites(): Sites;
     protected _collections: Collections | undefined;
-    get collections(): Collections;
     protected _pages: Pages | undefined;
-    get pages(): Pages;
     protected _components: Components | undefined;
-    get components(): Components;
     protected _scripts: Scripts | undefined;
-    get scripts(): Scripts;
     protected _assets: Assets | undefined;
-    get assets(): Assets;
     protected _webhooks: Webhooks | undefined;
-    get webhooks(): Webhooks;
     protected _forms: Forms | undefined;
-    get forms(): Forms;
     protected _users: Users | undefined;
-    get users(): Users;
     protected _accessGroups: AccessGroups | undefined;
-    get accessGroups(): AccessGroups;
     protected _products: Products | undefined;
-    get products(): Products;
     protected _orders: Orders | undefined;
-    get orders(): Orders;
     protected _inventory: Inventory | undefined;
-    get inventory(): Inventory;
     protected _ecommerce: Ecommerce | undefined;
-    get ecommerce(): Ecommerce;
     protected _workspaces: Workspaces | undefined;
+    constructor(_options?: WebflowClient.Options);
+    get token(): Token;
+    get sites(): Sites;
+    get collections(): Collections;
+    get pages(): Pages;
+    get components(): Components;
+    get scripts(): Scripts;
+    get assets(): Assets;
+    get webhooks(): Webhooks;
+    get forms(): Forms;
+    get users(): Users;
+    get accessGroups(): AccessGroups;
+    get products(): Products;
+    get orders(): Orders;
+    get inventory(): Inventory;
+    get ecommerce(): Ecommerce;
     get workspaces(): Workspaces;
 }

package/dist/Client.js

@@ -2,8 +2,43 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebflowClient = void 0;
+const core = __importStar(require("./core"));
+const headers_js_1 = require("./core/headers.js");
 const Client_1 = require("./api/resources/token/client/Client");
 const Client_2 = require("./api/resources/sites/client/Client");
 const Client_3 = require("./api/resources/collections/client/Client");
@@ -21,8 +56,15 @@ const Client_14 = require("./api/resources/inventory/client/Client");
 const Client_15 = require("./api/resources/ecommerce/client/Client");
 const Client_16 = require("./api/resources/workspaces/client/Client");
 class WebflowClient {
-    constructor(_options) {
-        this._options = _options;
+    constructor(_options = {}) {
+        this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
+                "X-Fern-Language": "JavaScript",
+                "X-Fern-SDK-Name": "webflow-api",
+                "X-Fern-SDK-Version": "3.2.1",
+                "User-Agent": "webflow-api/3.2.1",
+                "X-Fern-Runtime": core.RUNTIME.type,
+                "X-Fern-Runtime-Version": core.RUNTIME.version,
+            }, _options === null || _options === void 0 ? void 0 : _options.headers) });
     }
     get token() {
         var _a;