@livon/schema 0.27.0-rc.1

package/dist/array.spec.cjs

@@ -0,0 +1,167 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_array_cjs_namespaceObject = require("./array.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', ()=>({
+        isArray: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isArrayMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isArray);
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const isArrayGuardSpy = external_vitest_namespaceObject.vi.fn((input)=>Array.isArray(input));
+const isArrayGuard = (input)=>isArrayGuardSpy(input);
+const buildContextMock = {
+    buildId: 'build-array',
+    builder: {
+        add: external_vitest_namespaceObject.vi.fn((node)=>node),
+        getAll: external_vitest_namespaceObject.vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)({
+    buildContext: buildContextMock
+});
+const itemSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'itemSchema',
+    parse: external_vitest_namespaceObject.vi.fn((input)=>`parsed:${String(input)}`),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'Item'
+        }))
+});
+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)('array()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isArrayMock.mockImplementation(()=>isArrayGuard);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isArrayMock.mockClear();
+        isArrayGuardSpy.mockClear();
+        external_vitest_namespaceObject.vi.mocked(itemSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(itemSchemaMock.ast).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(itemSchemaMock.parse).mockClear();
+        isArrayGuardSpy.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isArrayMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when array schema is created', ()=>{
+            const result = (0, external_array_cjs_namespaceObject.array)({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Tags');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('array<itemSchema>');
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should build ast from item schema when build context is available', ()=>{
+            (0, external_array_cjs_namespaceObject.array)({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ast).toEqual({
+                type: 'array',
+                name: 'Tags',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'Item'
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(itemSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should validate all items when input is an array', ()=>{
+            (0, external_array_cjs_namespaceObject.array)({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const result = factoryInput.validate([
+                'a',
+                'b'
+            ], schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(result).toEqual([
+                'parsed:a',
+                'parsed:b'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(isArrayMock).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(isArrayGuardSpy).toHaveBeenCalledWith([
+                'a',
+                'b'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(itemSchemaMock.parse).toHaveBeenNthCalledWith(1, 'a', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(itemSchemaMock.parse).toHaveBeenNthCalledWith(2, 'b', schemaContextMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw array.type when input is not an array', ()=>{
+            isArrayGuardSpy.mockReturnValueOnce(false);
+            (0, external_array_cjs_namespaceObject.array)({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            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 array',
+                code: 'array.type'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw array.item with index context when item parse fails', ()=>{
+            const itemFailure = {
+                message: 'item failed',
+                code: 'item.invalid'
+            };
+            external_vitest_namespaceObject.vi.mocked(itemSchemaMock.parse).mockReturnValueOnce('parsed:a').mockImplementationOnce(()=>{
+                throw itemFailure;
+            });
+            (0, external_array_cjs_namespaceObject.array)({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate([
+                    'a',
+                    'b'
+                ], schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Invalid item at index 1',
+                code: 'array.item',
+                context: {
+                    index: 1,
+                    error: itemFailure
+                }
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/array.spec.d.ts

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

package/dist/array.spec.js

@@ -0,0 +1,161 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { array } from "./array.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isArray } from "./typeGuards.js";
+import { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isArray: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isArrayMock = vi.mocked(isArray);
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const isArrayGuardSpy = vi.fn((input)=>Array.isArray(input));
+const isArrayGuard = (input)=>isArrayGuardSpy(input);
+const buildContextMock = {
+    buildId: 'build-array',
+    builder: {
+        add: vi.fn((node)=>node),
+        getAll: vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = createSchemaContextMock({
+    buildContext: buildContextMock
+});
+const itemSchemaMock = createBaseSchemaMock({
+    name: 'itemSchema',
+    parse: vi.fn((input)=>`parsed:${String(input)}`),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'Item'
+        }))
+});
+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('array()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isArrayMock.mockImplementation(()=>isArrayGuard);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isArrayMock.mockClear();
+        isArrayGuardSpy.mockClear();
+        vi.mocked(itemSchemaMock.parse).mockClear();
+        vi.mocked(itemSchemaMock.ast).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(itemSchemaMock.parse).mockClear();
+        isArrayGuardSpy.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isArrayMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when array schema is created', ()=>{
+            const result = array({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Tags');
+            expect(factoryInput.type).toBe('array<itemSchema>');
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should build ast from item schema when build context is available', ()=>{
+            array({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            expect(ast).toEqual({
+                type: 'array',
+                name: 'Tags',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'Item'
+                    }
+                ]
+            });
+            expect(itemSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        it('should validate all items when input is an array', ()=>{
+            array({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const result = factoryInput.validate([
+                'a',
+                'b'
+            ], schemaContextMock);
+            expect(result).toEqual([
+                'parsed:a',
+                'parsed:b'
+            ]);
+            expect(isArrayMock).toHaveBeenCalledTimes(1);
+            expect(isArrayGuardSpy).toHaveBeenCalledWith([
+                'a',
+                'b'
+            ]);
+            expect(itemSchemaMock.parse).toHaveBeenNthCalledWith(1, 'a', schemaContextMock);
+            expect(itemSchemaMock.parse).toHaveBeenNthCalledWith(2, 'b', schemaContextMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw array.type when input is not an array', ()=>{
+            isArrayGuardSpy.mockReturnValueOnce(false);
+            array({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected array',
+                code: 'array.type'
+            });
+        });
+        it('should throw array.item with index context when item parse fails', ()=>{
+            const itemFailure = {
+                message: 'item failed',
+                code: 'item.invalid'
+            };
+            vi.mocked(itemSchemaMock.parse).mockReturnValueOnce('parsed:a').mockImplementationOnce(()=>{
+                throw itemFailure;
+            });
+            array({
+                name: 'Tags',
+                item: itemSchemaMock
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate([
+                    'a',
+                    'b'
+                ], schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Invalid item at index 1',
+                code: 'array.item',
+                context: {
+                    index: 1,
+                    error: itemFailure
+                }
+            });
+        });
+    });
+});

package/dist/before.cjs

@@ -0,0 +1,36 @@
+"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__, {
+    before: ()=>before
+});
+const before = ({ schema, hook })=>schema.before(hook);
+exports.before = __webpack_exports__.before;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "before"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/before.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from './types.js';
+export interface BeforeInput<T> {
+    schema: Schema<T>;
+    hook: Parameters<Schema<T>['before']>[0];
+}
+/**
+ * before 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/before
+ *
+ * @example
+ * // Preprocesses string input by trimming whitespace before validation.
+ * const TrimmedName = before({
+ *   schema: string(),
+ *   hook: (input) => (typeof input === 'string' ? input.trim() : input),
+ * });
+ * TrimmedName.parse('  alice  ');
+ *
+ * @example
+ * // Extends the preprocessed schema to also allow undefined.
+ * const OptionalTrimmedName = before({
+ *   schema: string(),
+ *   hook: (input) => (typeof input === 'string' ? input.trim() : input),
+ * }).optional();
+ * OptionalTrimmedName.parse(undefined);
+ */
+export declare const before: <T>({ schema, hook }: BeforeInput<T>) => Schema<T>;

package/dist/before.js

@@ -0,0 +1,2 @@
+const before = ({ schema, hook })=>schema.before(hook);
+export { before };

package/dist/before.spec.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_before_cjs_namespaceObject = require("./before.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+const schemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)();
+const nextSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'next.before.schema'
+});
+const hookMock = external_vitest_namespaceObject.vi.fn((input)=>input);
+(0, external_vitest_namespaceObject.describe)('before()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.before).mockImplementation(()=>nextSchemaMock);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.before).mockClear();
+        hookMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.before).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.before).mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schema.before when hook is provided', ()=>{
+            const result = (0, external_before_cjs_namespaceObject.before)({
+                schema: schemaMock,
+                hook: hookMock
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaMock.before).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(schemaMock.before).toHaveBeenCalledWith(hookMock);
+            (0, external_vitest_namespaceObject.expect)(result).toBe(nextSchemaMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should rethrow error when schema.before throws', ()=>{
+            const beforeError = new Error('before hook failed');
+            external_vitest_namespaceObject.vi.mocked(schemaMock.before).mockImplementationOnce(()=>{
+                throw beforeError;
+            });
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>(0, external_before_cjs_namespaceObject.before)({
+                    schema: schemaMock,
+                    hook: hookMock
+                }));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toBe(beforeError);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/before.spec.d.ts

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

package/dist/before.spec.js

@@ -0,0 +1,48 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { before } from "./before.js";
+import { captureThrow, createBaseSchemaMock } from "./testing/mocks/index.js";
+const schemaMock = createBaseSchemaMock();
+const nextSchemaMock = createBaseSchemaMock({
+    name: 'next.before.schema'
+});
+const hookMock = vi.fn((input)=>input);
+describe('before()', ()=>{
+    beforeAll(()=>{
+        vi.mocked(schemaMock.before).mockImplementation(()=>nextSchemaMock);
+    });
+    beforeEach(()=>{
+        vi.mocked(schemaMock.before).mockClear();
+        hookMock.mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(schemaMock.before).mockClear();
+    });
+    afterAll(()=>{
+        vi.mocked(schemaMock.before).mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schema.before when hook is provided', ()=>{
+            const result = before({
+                schema: schemaMock,
+                hook: hookMock
+            });
+            expect(schemaMock.before).toHaveBeenCalledTimes(1);
+            expect(schemaMock.before).toHaveBeenCalledWith(hookMock);
+            expect(result).toBe(nextSchemaMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should rethrow error when schema.before throws', ()=>{
+            const beforeError = new Error('before hook failed');
+            vi.mocked(schemaMock.before).mockImplementationOnce(()=>{
+                throw beforeError;
+            });
+            const thrown = captureThrow(()=>before({
+                    schema: schemaMock,
+                    hook: hookMock
+                }));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toBe(beforeError);
+        });
+    });
+});

package/dist/binary.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__, {
+    binary: ()=>binary
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const binary = ({ name, doc })=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'binary',
+        doc,
+        ast: ()=>({
+                type: 'binary',
+                name
+            }),
+        validate: (input)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isUint8Array)(input)) throw {
+                message: 'Expected Uint8Array',
+                code: 'binary.type'
+            };
+            return input;
+        }
+    });
+exports.binary = __webpack_exports__.binary;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "binary"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/binary.d.ts

@@ -0,0 +1,24 @@
+import { SchemaDoc } from './types.js';
+export interface BinarySchemaInput {
+    name: string;
+    doc?: SchemaDoc;
+}
+/**
+ * binary 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/binary
+ *
+ * @example
+ * // Creates a binary schema and validates a Uint8Array payload.
+ * const Payload = binary({ name: 'payload' });
+ * Payload.parse(new Uint8Array([1, 2, 3]));
+ *
+ * @example
+ * // Extends binary validation to also allow undefined.
+ * const MaybePayload = binary({ name: 'payload' }).optional();
+ * MaybePayload.parse(undefined);
+ */
+export declare const binary: ({ name, doc }: BinarySchemaInput) => import("./schemaFactory.js").SchemaWithChain<Uint8Array<ArrayBufferLike>, import("./schemaFactory.js").SchemaFactoryChainDefinition<Uint8Array<ArrayBufferLike>>>;

package/dist/binary.js

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