webflow-api 1.3.1 → 2.0.0-beta

package/dist/api/types/index.js

@@ -0,0 +1,139 @@
+"use strict";
+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 __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("./OauthScope"), exports);
+__exportStar(require("./AuthorizedUser"), exports);
+__exportStar(require("./AuthorizationAuthorizationAuthorizedTo"), exports);
+__exportStar(require("./AuthorizationAuthorization"), exports);
+__exportStar(require("./Authorization"), exports);
+__exportStar(require("./Pagination"), exports);
+__exportStar(require("./PublishStatus"), exports);
+__exportStar(require("./CustomCodeResponse"), exports);
+__exportStar(require("./RegisteredScriptList"), exports);
+__exportStar(require("./ScriptApplyList"), exports);
+__exportStar(require("./ScriptApplyLocation"), exports);
+__exportStar(require("./ScriptApply"), exports);
+__exportStar(require("./ListCustomCodeBlocks"), exports);
+__exportStar(require("./CustomCodeBlockType"), exports);
+__exportStar(require("./CustomCodeBlock"), exports);
+__exportStar(require("./PageList"), exports);
+__exportStar(require("./PageSeo"), exports);
+__exportStar(require("./PageOpenGraph"), exports);
+__exportStar(require("./Page"), exports);
+__exportStar(require("./PageCreatedWebhook"), exports);
+__exportStar(require("./PageMetadataUpdatedWebhook"), exports);
+__exportStar(require("./PageDeletedWebhook"), exports);
+__exportStar(require("./PageSeoGraphDataSeo"), exports);
+__exportStar(require("./PageSeoGraphDataOpenGraph"), exports);
+__exportStar(require("./PageSeoGraphData"), exports);
+__exportStar(require("./CollectionList"), exports);
+__exportStar(require("./CollectionListArrayItem"), exports);
+__exportStar(require("./Collection"), exports);
+__exportStar(require("./Fields"), exports);
+__exportStar(require("./FieldType"), exports);
+__exportStar(require("./Field"), exports);
+__exportStar(require("./CollectionItemFieldData"), exports);
+__exportStar(require("./CollectionItem"), exports);
+__exportStar(require("./CollectionItemListPagination"), exports);
+__exportStar(require("./CollectionItemList"), exports);
+__exportStar(require("./Webhook"), exports);
+__exportStar(require("./WebhookList"), exports);
+__exportStar(require("./TriggerType"), exports);
+__exportStar(require("./CollectionItemRemoved"), exports);
+__exportStar(require("./Sites"), exports);
+__exportStar(require("./Site"), exports);
+__exportStar(require("./Domain"), exports);
+__exportStar(require("./SitePublishPayload"), exports);
+__exportStar(require("./SitePublish"), exports);
+__exportStar(require("./SiteActivityLogResponse"), exports);
+__exportStar(require("./SiteActivityLogItemResourceOperation"), exports);
+__exportStar(require("./SiteActivityLogItem"), exports);
+__exportStar(require("./Assets"), exports);
+__exportStar(require("./Asset"), exports);
+__exportStar(require("./AssetVariant"), exports);
+__exportStar(require("./AssetUploadUploadDetails"), exports);
+__exportStar(require("./AssetUpload"), exports);
+__exportStar(require("./AssetFolder"), exports);
+__exportStar(require("./AssetFolderList"), exports);
+__exportStar(require("./FormFieldValueType"), exports);
+__exportStar(require("./FormFieldValue"), exports);
+__exportStar(require("./FormField"), exports);
+__exportStar(require("./FormResponseSettings"), exports);
+__exportStar(require("./Form"), exports);
+__exportStar(require("./FormList"), exports);
+__exportStar(require("./FormSubmission"), exports);
+__exportStar(require("./FormSubmissionList"), exports);
+__exportStar(require("./FormSubmissionTriggerPayload"), exports);
+__exportStar(require("./FormSubmissionTrigger"), exports);
+__exportStar(require("./Application"), exports);
+__exportStar(require("./PublishedSite"), exports);
+__exportStar(require("./PublishedItems"), exports);
+__exportStar(require("./RemovedItems"), exports);
+__exportStar(require("./UserStatus"), exports);
+__exportStar(require("./UserAccessGroupsItemType"), exports);
+__exportStar(require("./UserAccessGroupsItem"), exports);
+__exportStar(require("./User"), exports);
+__exportStar(require("./UserDataData"), exports);
+__exportStar(require("./UserData"), exports);
+__exportStar(require("./UserList"), exports);
+__exportStar(require("./UserWebhookPayloadTriggerType"), exports);
+__exportStar(require("./UserWebhookPayload"), exports);
+__exportStar(require("./AccessGroup"), exports);
+__exportStar(require("./AccessGroupList"), exports);
+__exportStar(require("./ErrorDetailsItem"), exports);
+__exportStar(require("./UsersNotEnabled"), exports);
+__exportStar(require("./DuplicateUserEmail"), exports);
+__exportStar(require("./UserLimitReached"), exports);
+__exportStar(require("./MissingScopes"), exports);
+__exportStar(require("./ProductFieldData"), exports);
+__exportStar(require("./Product"), exports);
+__exportStar(require("./SkuFieldDataPrice"), exports);
+__exportStar(require("./SkuFieldData"), exports);
+__exportStar(require("./Sku"), exports);
+__exportStar(require("./ProductAndSkUs"), exports);
+__exportStar(require("./ProductAndSkUsList"), exports);
+__exportStar(require("./SkuPropertyListEnumItem"), exports);
+__exportStar(require("./SkuPropertyList"), exports);
+__exportStar(require("./SkuValueList"), exports);
+__exportStar(require("./OrderStatus"), exports);
+__exportStar(require("./OrderDisputeLastStatus"), exports);
+__exportStar(require("./OrderCustomerInfo"), exports);
+__exportStar(require("./OrderMetadata"), exports);
+__exportStar(require("./OrderTotalsExtrasItemType"), exports);
+__exportStar(require("./OrderTotalsExtrasItem"), exports);
+__exportStar(require("./OrderTotals"), exports);
+__exportStar(require("./OrderDownloadFilesItem"), exports);
+__exportStar(require("./Order"), exports);
+__exportStar(require("./OrderList"), exports);
+__exportStar(require("./OrderPrice"), exports);
+__exportStar(require("./OrderAddressType"), exports);
+__exportStar(require("./OrderAddressJapanType"), exports);
+__exportStar(require("./OrderAddress"), exports);
+__exportStar(require("./OrderPurchasedItemVariantImageFileVariantsItem"), exports);
+__exportStar(require("./OrderPurchasedItemVariantImageFile"), exports);
+__exportStar(require("./OrderPurchasedItemVariantImage"), exports);
+__exportStar(require("./OrderPurchasedItem"), exports);
+__exportStar(require("./StripeDetails"), exports);
+__exportStar(require("./StripeCardBrand"), exports);
+__exportStar(require("./StripeCardExpires"), exports);
+__exportStar(require("./StripeCard"), exports);
+__exportStar(require("./PaypalDetails"), exports);
+__exportStar(require("./InventoryItemInventoryType"), exports);
+__exportStar(require("./InventoryItem"), exports);
+__exportStar(require("./EcommerceSettings"), exports);
+__exportStar(require("./Error_"), exports);
+__exportStar(require("./InvalidDomain"), exports);
+__exportStar(require("./NoDomains"), exports);

package/dist/core/auth/BasicAuth.d.ts

@@ -0,0 +1,8 @@
+export interface BasicAuth {
+    username: string;
+    password: string;
+}
+export declare const BasicAuth: {
+    toAuthorizationHeader: (basicAuth: BasicAuth | undefined) => string | undefined;
+    fromAuthorizationHeader: (header: string) => BasicAuth;
+};

package/dist/core/auth/BasicAuth.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicAuth = void 0;
+const js_base64_1 = require("js-base64");
+const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
+exports.BasicAuth = {
+    toAuthorizationHeader: (basicAuth) => {
+        if (basicAuth == null) {
+            return undefined;
+        }
+        const token = js_base64_1.Base64.encode(`${basicAuth.username}:${basicAuth.password}`);
+        return `Basic ${token}`;
+    },
+    fromAuthorizationHeader: (header) => {
+        const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
+        const decoded = js_base64_1.Base64.decode(credentials);
+        const [username, password] = decoded.split(":", 2);
+        if (username == null || password == null) {
+            throw new Error("Invalid basic auth");
+        }
+        return {
+            username,
+            password,
+        };
+    },
+};

package/dist/core/auth/BearerToken.d.ts

@@ -0,0 +1,5 @@
+export declare type BearerToken = string;
+export declare const BearerToken: {
+    toAuthorizationHeader: (token: BearerToken | undefined) => string | undefined;
+    fromAuthorizationHeader: (header: string) => BearerToken;
+};

package/dist/core/auth/BearerToken.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BearerToken = void 0;
+const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
+exports.BearerToken = {
+    toAuthorizationHeader: (token) => {
+        if (token == null) {
+            return undefined;
+        }
+        return `Bearer ${token}`;
+    },
+    fromAuthorizationHeader: (header) => {
+        return header.replace(BEARER_AUTH_HEADER_PREFIX, "").trim();
+    },
+};

package/dist/core/auth/index.d.ts

@@ -0,0 +1,2 @@
+export { BasicAuth } from "./BasicAuth";
+export { BearerToken } from "./BearerToken";

package/dist/core/auth/index.js

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

package/dist/core/fetcher/APIResponse.d.ts

@@ -0,0 +1,10 @@
+export declare type APIResponse<Success, Failure> = SuccessfulResponse<Success> | FailedResponse<Failure>;
+export interface SuccessfulResponse<T> {
+    ok: true;
+    body: T;
+    headers?: Record<string, any>;
+}
+export interface FailedResponse<T> {
+    ok: false;
+    error: T;
+}

package/dist/core/fetcher/APIResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/fetcher/Fetcher.d.ts

@@ -0,0 +1,35 @@
+import { APIResponse } from "./APIResponse";
+export declare type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
+export declare namespace Fetcher {
+    interface Args {
+        url: string;
+        method: string;
+        contentType?: string;
+        headers?: Record<string, string | undefined>;
+        queryParameters?: Record<string, string | string[]>;
+        body?: unknown;
+        timeoutMs?: number;
+        maxRetries?: number;
+        withCredentials?: boolean;
+        responseType?: "json" | "blob" | "streaming";
+    }
+    type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
+    interface FailedStatusCodeError {
+        reason: "status-code";
+        statusCode: number;
+        body: unknown;
+    }
+    interface NonJsonError {
+        reason: "non-json";
+        statusCode: number;
+        rawBody: string;
+    }
+    interface TimeoutError {
+        reason: "timeout";
+    }
+    interface UnknownError {
+        reason: "unknown";
+        errorMessage: string;
+    }
+}
+export declare const fetcher: FetchFunction;

package/dist/core/fetcher/Fetcher.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const qs_1 = __importDefault(require("qs"));
+if (typeof window === "undefined") {
+    global.fetch = require("node-fetch");
+}
+const INITIAL_RETRY_DELAY = 1;
+const MAX_RETRY_DELAY = 60;
+const DEFAULT_MAX_RETRIES = 2;
+function fetcherImpl(args) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const headers = {};
+        if (args.body !== undefined && args.contentType != null) {
+            headers["Content-Type"] = args.contentType;
+        }
+        if (args.headers != null) {
+            for (const [key, value] of Object.entries(args.headers)) {
+                if (value != null) {
+                    headers[key] = value;
+                }
+            }
+        }
+        const url = Object.keys((_a = args.queryParameters) !== null && _a !== void 0 ? _a : {}).length > 0
+            ? `${args.url}?${qs_1.default.stringify(args.queryParameters, { arrayFormat: "repeat" })}`
+            : args.url;
+        let body = undefined;
+        if (args.body instanceof form_data_1.default) {
+            // @ts-expect-error
+            body = args.body;
+        }
+        else {
+            body = JSON.stringify(args.body);
+        }
+        const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            let abortId = undefined;
+            if (args.timeoutMs != null) {
+                abortId = setTimeout(() => controller.abort(), args.timeoutMs);
+            }
+            const response = yield fetch(url, {
+                method: args.method,
+                headers,
+                body,
+                signal: controller.signal,
+                credentials: args.withCredentials ? "same-origin" : undefined,
+            });
+            if (abortId != null) {
+                clearTimeout(abortId);
+            }
+            return response;
+        });
+        try {
+            let response = yield makeRequest();
+            for (let i = 0; i < ((_b = args.maxRetries) !== null && _b !== void 0 ? _b : DEFAULT_MAX_RETRIES); ++i) {
+                if (response.status === 408 ||
+                    response.status === 409 ||
+                    response.status === 429 ||
+                    response.status >= 500) {
+                    const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(i, 2), MAX_RETRY_DELAY);
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                    response = yield makeRequest();
+                }
+                else {
+                    break;
+                }
+            }
+            let body;
+            if (response.body != null && args.responseType === "blob") {
+                body = yield response.blob();
+            }
+            else if (response.body != null && args.responseType === "streaming") {
+                body = response.body;
+            }
+            else if (response.body != null) {
+                try {
+                    body = yield response.json();
+                }
+                catch (err) {
+                    return {
+                        ok: false,
+                        error: {
+                            reason: "non-json",
+                            statusCode: response.status,
+                            rawBody: yield response.text(),
+                        },
+                    };
+                }
+            }
+            if (response.status >= 200 && response.status < 400) {
+                return {
+                    ok: true,
+                    body: body,
+                    headers: response.headers,
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "status-code",
+                        statusCode: response.status,
+                        body,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "timeout",
+                    },
+                };
+            }
+            else if (error instanceof Error) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "unknown",
+                        errorMessage: error.message,
+                    },
+                };
+            }
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: JSON.stringify(error),
+                },
+            };
+        }
+    });
+}
+exports.fetcher = fetcherImpl;

package/dist/core/fetcher/Supplier.d.ts

@@ -0,0 +1,4 @@
+export declare type Supplier<T> = T | Promise<T> | (() => T | Promise<T>);
+export declare const Supplier: {
+    get: <T>(supplier: Supplier<T>) => Promise<T>;
+};

package/dist/core/fetcher/Supplier.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Supplier = void 0;
+exports.Supplier = {
+    get: (supplier) => __awaiter(void 0, void 0, void 0, function* () {
+        if (typeof supplier === "function") {
+            return supplier();
+        }
+        else {
+            return supplier;
+        }
+    }),
+};

package/dist/core/fetcher/getHeader.d.ts

@@ -0,0 +1 @@
+export declare function getHeader(headers: Record<string, any>, header: string): string | undefined;

package/dist/core/fetcher/getHeader.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeader = void 0;
+function getHeader(headers, header) {
+    for (const [headerKey, headerValue] of Object.entries(headers)) {
+        if (headerKey.toLowerCase() === header.toLowerCase()) {
+            return headerValue;
+        }
+    }
+    return undefined;
+}
+exports.getHeader = getHeader;

package/dist/core/fetcher/index.d.ts

@@ -0,0 +1,5 @@
+export type { APIResponse } from "./APIResponse";
+export { fetcher } from "./Fetcher";
+export type { Fetcher, FetchFunction } from "./Fetcher";
+export { getHeader } from "./getHeader";
+export { Supplier } from "./Supplier";

package/dist/core/fetcher/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Supplier = exports.getHeader = exports.fetcher = void 0;
+var Fetcher_1 = require("./Fetcher");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return Fetcher_1.fetcher; } });
+var getHeader_1 = require("./getHeader");
+Object.defineProperty(exports, "getHeader", { enumerable: true, get: function () { return getHeader_1.getHeader; } });
+var Supplier_1 = require("./Supplier");
+Object.defineProperty(exports, "Supplier", { enumerable: true, get: function () { return Supplier_1.Supplier; } });

package/dist/core/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./error";
-export * from "./response";
-export * from "./webflow";
+export * from "./fetcher";
+export * from "./auth";
+export * as serialization from "./schemas";

package/dist/core/index.js

@@ -10,10 +10,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __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);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./error"), exports);
-__exportStar(require("./response"), exports);
-__exportStar(require("./webflow"), exports);
+exports.serialization = void 0;
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./auth"), exports);
+exports.serialization = __importStar(require("./schemas"));

package/dist/core/schemas/Schema.d.ts

@@ -0,0 +1,81 @@
+import { SchemaUtils } from "./builders";
+import { MaybePromise } from "./utils/MaybePromise";
+export declare type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export declare type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
+export declare type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
+export interface BaseSchema<Raw, Parsed> {
+    parse: (raw: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Parsed>>;
+    json: (parsed: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Raw>>;
+    getType: () => SchemaType | Promise<SchemaType>;
+}
+export declare const SchemaType: {
+    readonly DATE: "date";
+    readonly ENUM: "enum";
+    readonly LIST: "list";
+    readonly STRING_LITERAL: "stringLiteral";
+    readonly BOOLEAN_LITERAL: "booleanLiteral";
+    readonly OBJECT: "object";
+    readonly ANY: "any";
+    readonly BOOLEAN: "boolean";
+    readonly NUMBER: "number";
+    readonly STRING: "string";
+    readonly UNKNOWN: "unknown";
+    readonly RECORD: "record";
+    readonly SET: "set";
+    readonly UNION: "union";
+    readonly UNDISCRIMINATED_UNION: "undiscriminatedUnion";
+    readonly OPTIONAL: "optional";
+};
+export declare type SchemaType = typeof SchemaType[keyof typeof SchemaType];
+export declare type MaybeValid<T> = Valid<T> | Invalid;
+export interface Valid<T> {
+    ok: true;
+    value: T;
+}
+export interface Invalid {
+    ok: false;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    path: string[];
+    message: string;
+}
+export interface SchemaOptions {
+    /**
+     * how to handle unrecognized keys in objects
+     *
+     * @default "fail"
+     */
+    unrecognizedObjectKeys?: "fail" | "passthrough" | "strip";
+    /**
+     * whether to fail when an unrecognized discriminant value is
+     * encountered in a union
+     *
+     * @default false
+     */
+    allowUnrecognizedUnionMembers?: boolean;
+    /**
+     * whether to fail when an unrecognized enum value is encountered
+     *
+     * @default false
+     */
+    allowUnrecognizedEnumValues?: boolean;
+    /**
+     * whether to allow data that doesn't conform to the schema.
+     * invalid data is passed through without transformation.
+     *
+     * when this is enabled, .parse() and .json() will always
+     * return `ok: true`. `.parseOrThrow()` and `.jsonOrThrow()`
+     * will never fail.
+     *
+     * @default false
+     */
+    skipValidation?: boolean;
+    /**
+     * each validation failure contains a "path" property, which is
+     * the breadcrumbs to the offending node in the JSON. you can supply
+     * a prefix that is prepended to all the errors' paths. this can be
+     * helpful for zurg's internal debug logging.
+     */
+    breadcrumbsPrefix?: string[];
+}

package/dist/core/schemas/Schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaType = void 0;
+exports.SchemaType = {
+    DATE: "date",
+    ENUM: "enum",
+    LIST: "list",
+    STRING_LITERAL: "stringLiteral",
+    BOOLEAN_LITERAL: "booleanLiteral",
+    OBJECT: "object",
+    ANY: "any",
+    BOOLEAN: "boolean",
+    NUMBER: "number",
+    STRING: "string",
+    UNKNOWN: "unknown",
+    RECORD: "record",
+    SET: "set",
+    UNION: "union",
+    UNDISCRIMINATED_UNION: "undiscriminatedUnion",
+    OPTIONAL: "optional",
+};

package/dist/core/schemas/builders/date/date.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../../Schema";
+export declare function date(): Schema<string, Date>;