@rulebricks/sdk 1.0.0

package/dist/core/fetcher/Fetcher.js

@@ -0,0 +1,161 @@
+"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"));
+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 fetchFn = typeof fetch == "function" ? fetch : require("node-fetch");
+        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 fetchFn(url, {
+                method: args.method,
+                headers,
+                body,
+                signal: controller.signal,
+                credentials: args.withCredentials ? "include" : 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 {
+                const text = yield response.text();
+                if (text.length > 0) {
+                    try {
+                        body = JSON.parse(text);
+                    }
+                    catch (err) {
+                        return {
+                            ok: false,
+                            error: {
+                                reason: "non-json",
+                                statusCode: response.status,
+                                rawBody: 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 var __esModule: boolean;
+export namespace Supplier {
+    function get(supplier: any): any;
+}

package/dist/core/fetcher/Supplier.js

@@ -0,0 +1,32 @@
+"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,2 @@
+export var __esModule: boolean;
+export function getHeader(headers: any, header: any): any;

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,9 @@
+export var __esModule: boolean;
+export var fetcher: Fetcher_1.FetchFunction;
+export var getHeader: typeof getHeader_1.getHeader;
+export var Supplier: {
+    get: <T>(supplier: Supplier_1.Supplier<T>) => Promise<T>;
+};
+import Fetcher_1 = require("./Fetcher");
+import getHeader_1 = require("./getHeader");
+import Supplier_1 = require("./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

@@ -0,0 +1,2 @@
+export var __esModule: boolean;
+export var serialization: any;

package/dist/core/index.js

@@ -0,0 +1,39 @@
+"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 __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 });
+exports.serialization = void 0;
+__exportStar(require("./fetcher"), exports);
+exports.serialization = __importStar(require("./schemas"));

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

@@ -0,0 +1,19 @@
+export var __esModule: boolean;
+export namespace SchemaType {
+    const DATE: string;
+    const ENUM: string;
+    const LIST: string;
+    const STRING_LITERAL: string;
+    const BOOLEAN_LITERAL: string;
+    const OBJECT: string;
+    const ANY: string;
+    const BOOLEAN: string;
+    const NUMBER: string;
+    const STRING: string;
+    const UNKNOWN: string;
+    const RECORD: string;
+    const SET: string;
+    const UNION: string;
+    const UNDISCRIMINATED_UNION: string;
+    const OPTIONAL: 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,4 @@
+export var __esModule: boolean;
+export function date(): Schema_1.BaseSchema<any, any> & schema_utils_1.SchemaUtils<string, Date>;
+import Schema_1 = require("../../Schema");
+import schema_utils_1 = require("../schema-utils");

package/dist/core/schemas/builders/date/date.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.date = void 0;
+const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const schema_utils_1 = require("../schema-utils");
+// https://stackoverflow.com/questions/12756159/regex-and-iso8601-formatted-datetime
+const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function date() {
+    const baseSchema = {
+        parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof raw !== "string") {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "string"),
+                        },
+                    ],
+                };
+            }
+            if (!ISO_8601_REGEX.test(raw)) {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "ISO 8601 date string"),
+                        },
+                    ],
+                };
+            }
+            return {
+                ok: true,
+                value: new Date(raw),
+            };
+        },
+        json: (date, { breadcrumbsPrefix = [] } = {}) => {
+            if (date instanceof Date) {
+                return {
+                    ok: true,
+                    value: date.toISOString(),
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(date, "Date object"),
+                        },
+                    ],
+                };
+            }
+        },
+        getType: () => Schema_1.SchemaType.DATE,
+    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}
+exports.date = date;

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

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var date: typeof date_1.date;
+import date_1 = require("./date");

package/dist/core/schemas/builders/date/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.date = void 0;
+var date_1 = require("./date");
+Object.defineProperty(exports, "date", { enumerable: true, get: function () { return date_1.date; } });

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

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export function enum_(values: any): Schema_1.Schema<string, string>;
+import Schema_1 = require("../../Schema");

package/dist/core/schemas/builders/enum/enum.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enum_ = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function enum_(values) {
+    const validValues = new Set(values);
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+        if (typeof value !== "string") {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "string"),
+                    },
+                ],
+            };
+        }
+        if (!validValues.has(value) && !allowUnrecognizedEnumValues) {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "enum"),
+                    },
+                ],
+            };
+        }
+        return {
+            ok: true,
+            value: value,
+        };
+    });
+    return schemaCreator();
+}
+exports.enum_ = enum_;

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

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var enum_: typeof enum_1.enum_;
+import enum_1 = require("./enum");

package/dist/core/schemas/builders/enum/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enum_ = void 0;
+var enum_1 = require("./enum");
+Object.defineProperty(exports, "enum_", { enumerable: true, get: function () { return enum_1.enum_; } });

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

@@ -0,0 +1 @@
+export var __esModule: boolean;

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

@@ -0,0 +1,33 @@
+"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("./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);

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

@@ -0,0 +1,5 @@
+export var __esModule: boolean;
+export var lazy: typeof lazy_1.lazy;
+export var lazyObject: typeof lazyObject_1.lazyObject;
+import lazy_1 = require("./lazy");
+import lazyObject_1 = require("./lazyObject");

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

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

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

@@ -0,0 +1,13 @@
+export var __esModule: boolean;
+export function lazy(getter: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => any;
+} & schema_utils_1.SchemaUtils<any, any>;
+export function constructLazyBaseSchema(getter: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => any;
+};
+export function getMemoizedSchema(getter: any): any;
+import schema_utils_1 = require("../schema-utils");

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

@@ -0,0 +1,46 @@
+"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.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
+const schema_utils_1 = require("../schema-utils");
+function lazy(getter) {
+    const baseSchema = constructLazyBaseSchema(getter);
+    return Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}
+exports.lazy = lazy;
+function constructLazyBaseSchema(getter) {
+    return {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).parse(raw, opts); }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).json(parsed, opts); }),
+        getType: () => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).getType(); }),
+    };
+}
+exports.constructLazyBaseSchema = constructLazyBaseSchema;
+function getMemoizedSchema(getter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const castedGetter = getter;
+        if (castedGetter.__zurg_memoized == null) {
+            castedGetter.__zurg_memoized = yield getter();
+        }
+        return castedGetter.__zurg_memoized;
+    });
+}
+exports.getMemoizedSchema = getMemoizedSchema;

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

@@ -0,0 +1,8 @@
+export var __esModule: boolean;
+export function lazyObject(getter: any): import("../../Schema").BaseSchema<any, any> & {
+    _getRawProperties: () => any;
+    _getParsedProperties: () => any;
+} & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & object_1.ObjectUtils<any, any>;
+import schema_utils_1 = require("../schema-utils");
+import object_like_1 = require("../object-like");
+import object_1 = require("../object");

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

@@ -0,0 +1,31 @@
+"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.lazyObject = void 0;
+const object_1 = require("../object");
+const object_like_1 = require("../object-like");
+const schema_utils_1 = require("../schema-utils");
+const lazy_1 = require("./lazy");
+function lazyObject(getter) {
+    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getRawProperties(); }), _getParsedProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (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));
+}
+exports.lazyObject = lazyObject;

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

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var list: typeof list_1.list;
+import list_1 = require("./list");

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = void 0;
+var list_1 = require("./list");
+Object.defineProperty(exports, "list", { enumerable: true, get: function () { return list_1.list; } });

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

@@ -0,0 +1,7 @@
+export var __esModule: boolean;
+export function list(schema: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => "list";
+} & schema_utils_1.SchemaUtils<any, any>;
+import schema_utils_1 = require("../schema-utils");