@livon/schema 0.27.0-rc.1

package/dist/date.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    date: ()=>date
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const date = ({ name = 'date', doc } = {})=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'date',
+        doc,
+        ast: ()=>({
+                type: 'date',
+                name
+            }),
+        validate: (input)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isDate)(input)) throw {
+                message: 'Expected Date',
+                code: 'date.type'
+            };
+            return input;
+        }
+    });
+exports.date = __webpack_exports__.date;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "date"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/date.d.ts

@@ -0,0 +1,24 @@
+import type { SchemaDoc } from './types.js';
+export interface DateFactoryInput {
+    name?: string;
+    doc?: SchemaDoc;
+}
+/**
+ * date is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/date
+ *
+ * @example
+ * // Creates a date schema and validates a Date object.
+ * const CreatedAt = date();
+ * CreatedAt.parse(new Date());
+ *
+ * @example
+ * // Extends date validation to also allow null.
+ * const MaybeCreatedAt = date().nullable();
+ * MaybeCreatedAt.parse(null);
+ */
+export declare const date: ({ name, doc }?: DateFactoryInput) => import("./schemaFactory.js").SchemaWithChain<Date, import("./schemaFactory.js").SchemaFactoryChainDefinition<Date>>;

package/dist/date.js

@@ -0,0 +1,19 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isDate } from "./typeGuards.js";
+const date = ({ name = 'date', doc } = {})=>schemaFactory({
+        name,
+        type: 'date',
+        doc,
+        ast: ()=>({
+                type: 'date',
+                name
+            }),
+        validate: (input)=>{
+            if (!isDate(input)) throw {
+                message: 'Expected Date',
+                code: 'date.type'
+            };
+            return input;
+        }
+    });
+export { date };

package/dist/date.spec.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_date_cjs_namespaceObject = require("./date.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+external_vitest_namespaceObject.vi.mock('./typeGuards.js', ()=>({
+        isDate: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isDateMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isDate);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('date()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isDateMock.mockReset();
+        isDateMock.mockReturnValue(true);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        isDateMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isDateMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when using default metadata', ()=>{
+            const result = (0, external_date_cjs_namespaceObject.date)();
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('date');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('date');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toBeUndefined();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'date',
+                name: 'date'
+            });
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'date doc'
+            };
+            (0, external_date_cjs_namespaceObject.date)({
+                name: 'CreatedAt',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('CreatedAt');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'date',
+                name: 'CreatedAt'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should validate input through isDate when input is Date', ()=>{
+            const input = new Date('2025-02-01T00:00:00.000Z');
+            (0, external_date_cjs_namespaceObject.date)();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(input, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(input);
+            (0, external_vitest_namespaceObject.expect)(isDateMock).toHaveBeenCalledWith(input);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input is not Date', ()=>{
+            isDateMock.mockReturnValue(false);
+            (0, external_date_cjs_namespaceObject.date)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('x', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected Date',
+                code: 'date.type'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/date.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/date.spec.js

@@ -0,0 +1,91 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { date } from "./date.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isDate } from "./typeGuards.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isDate: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isDateMock = vi.mocked(isDate);
+const schemaContextMock = createSchemaContextMock();
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('date()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isDateMock.mockReset();
+        isDateMock.mockReturnValue(true);
+    });
+    afterEach(()=>{
+        isDateMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isDateMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when using default metadata', ()=>{
+            const result = date();
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('date');
+            expect(factoryInput.type).toBe('date');
+            expect(factoryInput.doc).toBeUndefined();
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'date',
+                name: 'date'
+            });
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'date doc'
+            };
+            date({
+                name: 'CreatedAt',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('CreatedAt');
+            expect(factoryInput.doc).toEqual(doc);
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'date',
+                name: 'CreatedAt'
+            });
+        });
+        it('should validate input through isDate when input is Date', ()=>{
+            const input = new Date('2025-02-01T00:00:00.000Z');
+            date();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(input, schemaContextMock);
+            expect(parsed).toBe(input);
+            expect(isDateMock).toHaveBeenCalledWith(input);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input is not Date', ()=>{
+            isDateMock.mockReturnValue(false);
+            date();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected Date',
+                code: 'date.type'
+            });
+        });
+    });
+});

package/dist/doc.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mergeDoc: ()=>mergeDoc,
+    normalizeDoc: ()=>normalizeDoc
+});
+const normalizeDoc = (doc)=>{
+    if (!doc) return;
+    if ('string' == typeof doc) return {
+        description: doc
+    };
+    if ('object' == typeof doc && !Array.isArray(doc)) return doc;
+};
+const mergeDoc = (existing, next)=>{
+    if (!existing && !next) return;
+    if (!existing) return next;
+    if (!next) return existing;
+    return {
+        ...existing,
+        ...next
+    };
+};
+exports.mergeDoc = __webpack_exports__.mergeDoc;
+exports.normalizeDoc = __webpack_exports__.normalizeDoc;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeDoc",
+    "normalizeDoc"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/doc.d.ts

@@ -0,0 +1,25 @@
+import type { SchemaDoc } from './types.js';
+/**
+ * normalizeDoc is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/schema
+ *
+ * @example
+ * const result = normalizeDoc(undefined as never);
+ */
+export declare const normalizeDoc: (doc?: SchemaDoc) => Readonly<Record<string, unknown>> | undefined;
+/**
+ * mergeDoc is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/schema
+ *
+ * @example
+ * const result = mergeDoc(undefined as never);
+ */
+export declare const mergeDoc: (existing?: Readonly<Record<string, unknown>>, next?: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined;

package/dist/doc.js

@@ -0,0 +1,17 @@
+const normalizeDoc = (doc)=>{
+    if (!doc) return;
+    if ('string' == typeof doc) return {
+        description: doc
+    };
+    if ('object' == typeof doc && !Array.isArray(doc)) return doc;
+};
+const mergeDoc = (existing, next)=>{
+    if (!existing && !next) return;
+    if (!existing) return next;
+    if (!next) return existing;
+    return {
+        ...existing,
+        ...next
+    };
+};
+export { mergeDoc, normalizeDoc };

package/dist/doc.spec.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_doc_cjs_namespaceObject = require("./doc.cjs");
+(0, external_vitest_namespaceObject.describe)('doc utilities', ()=>{
+    let stringDoc;
+    let objectDoc;
+    let existingDoc;
+    let nextDoc;
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        stringDoc = 'User schema documentation';
+        objectDoc = {
+            summary: 'User',
+            details: 'Contains user payload fields'
+        };
+        existingDoc = {
+            summary: 'Existing summary',
+            stable: true
+        };
+        nextDoc = {
+            summary: 'Next summary',
+            deprecated: false
+        };
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    (0, external_vitest_namespaceObject.describe)('normalizeDoc()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)("should return description record when doc is string", ()=>{
+                const normalized = (0, external_doc_cjs_namespaceObject.normalizeDoc)(stringDoc);
+                (0, external_vitest_namespaceObject.expect)(normalized).toEqual({
+                    description: stringDoc
+                });
+            });
+            (0, external_vitest_namespaceObject.it)('should return same record when doc is object', ()=>{
+                const normalized = (0, external_doc_cjs_namespaceObject.normalizeDoc)(objectDoc);
+                (0, external_vitest_namespaceObject.expect)(normalized).toBe(objectDoc);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return undefined when doc is missing', ()=>{
+                const normalized = (0, external_doc_cjs_namespaceObject.normalizeDoc)(void 0);
+                (0, external_vitest_namespaceObject.expect)(normalized).toBeUndefined();
+            });
+            (0, external_vitest_namespaceObject.it)('should return undefined when doc is array', ()=>{
+                const normalized = (0, external_doc_cjs_namespaceObject.normalizeDoc)([
+                    'invalid'
+                ]);
+                (0, external_vitest_namespaceObject.expect)(normalized).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('mergeDoc()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should merge both records when existing and next are provided', ()=>{
+                const merged = (0, external_doc_cjs_namespaceObject.mergeDoc)(existingDoc, nextDoc);
+                (0, external_vitest_namespaceObject.expect)(merged).toEqual({
+                    summary: 'Next summary',
+                    stable: true,
+                    deprecated: false
+                });
+            });
+            (0, external_vitest_namespaceObject.it)('should return next when only next is provided', ()=>{
+                const merged = (0, external_doc_cjs_namespaceObject.mergeDoc)(void 0, nextDoc);
+                (0, external_vitest_namespaceObject.expect)(merged).toBe(nextDoc);
+            });
+            (0, external_vitest_namespaceObject.it)('should return existing when only existing is provided', ()=>{
+                const merged = (0, external_doc_cjs_namespaceObject.mergeDoc)(existingDoc, void 0);
+                (0, external_vitest_namespaceObject.expect)(merged).toBe(existingDoc);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return undefined when both values are missing', ()=>{
+                const merged = (0, external_doc_cjs_namespaceObject.mergeDoc)(void 0, void 0);
+                (0, external_vitest_namespaceObject.expect)(merged).toBeUndefined();
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/doc.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/doc.spec.js

@@ -0,0 +1,93 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { mergeDoc, normalizeDoc } from "./doc.js";
+describe('doc utilities', ()=>{
+    let stringDoc;
+    let objectDoc;
+    let existingDoc;
+    let nextDoc;
+    beforeAll(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    beforeEach(()=>{
+        stringDoc = 'User schema documentation';
+        objectDoc = {
+            summary: 'User',
+            details: 'Contains user payload fields'
+        };
+        existingDoc = {
+            summary: 'Existing summary',
+            stable: true
+        };
+        nextDoc = {
+            summary: 'Next summary',
+            deprecated: false
+        };
+    });
+    afterEach(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    afterAll(()=>{
+        stringDoc = '';
+        objectDoc = {};
+        existingDoc = {};
+        nextDoc = {};
+    });
+    describe('normalizeDoc()', ()=>{
+        describe('happy', ()=>{
+            it("should return description record when doc is string", ()=>{
+                const normalized = normalizeDoc(stringDoc);
+                expect(normalized).toEqual({
+                    description: stringDoc
+                });
+            });
+            it('should return same record when doc is object', ()=>{
+                const normalized = normalizeDoc(objectDoc);
+                expect(normalized).toBe(objectDoc);
+            });
+        });
+        describe('sad', ()=>{
+            it('should return undefined when doc is missing', ()=>{
+                const normalized = normalizeDoc(void 0);
+                expect(normalized).toBeUndefined();
+            });
+            it('should return undefined when doc is array', ()=>{
+                const normalized = normalizeDoc([
+                    'invalid'
+                ]);
+                expect(normalized).toBeUndefined();
+            });
+        });
+    });
+    describe('mergeDoc()', ()=>{
+        describe('happy', ()=>{
+            it('should merge both records when existing and next are provided', ()=>{
+                const merged = mergeDoc(existingDoc, nextDoc);
+                expect(merged).toEqual({
+                    summary: 'Next summary',
+                    stable: true,
+                    deprecated: false
+                });
+            });
+            it('should return next when only next is provided', ()=>{
+                const merged = mergeDoc(void 0, nextDoc);
+                expect(merged).toBe(nextDoc);
+            });
+            it('should return existing when only existing is provided', ()=>{
+                const merged = mergeDoc(existingDoc, void 0);
+                expect(merged).toBe(existingDoc);
+            });
+        });
+        describe('sad', ()=>{
+            it('should return undefined when both values are missing', ()=>{
+                const merged = mergeDoc(void 0, void 0);
+                expect(merged).toBeUndefined();
+            });
+        });
+    });
+});

package/dist/enumeration.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    enumeration: ()=>enumeration
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const enumeration = (name, doc)=>({
+        values: (...values)=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+                name: `enum:${name}`,
+                type: 'enum',
+                doc,
+                ast: ()=>({
+                        type: 'enum',
+                        name,
+                        constraints: {
+                            values
+                        }
+                    }),
+                validate: (input)=>{
+                    if (!values.includes(input)) throw {
+                        message: `Input "${String(input)}" is not valid for enum "${name}". Valid values: ${values.join(', ')}`,
+                        code: 'enum.value',
+                        context: {
+                            name,
+                            values
+                        }
+                    };
+                    return input;
+                },
+                chain: {
+                    literal: (data)=>(only)=>{
+                            if (data !== only) throw {
+                                message: `Input "${String(data)}" does not match literal "${String(only)}" for enum "${name}".`,
+                                code: 'enum.literal',
+                                context: {
+                                    name,
+                                    only
+                                }
+                            };
+                            return data;
+                        }
+                }
+            })
+    });
+exports.enumeration = __webpack_exports__.enumeration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "enumeration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});