@nhtio/lucid-resourceful 1.20250718.0

package/private/schema_types.d.ts

@@ -0,0 +1,157 @@
+import type { AnySchema as JoiAnySchema, StringSchema as JoiStringSchema, BinarySchema as JoiBinarySchema, NumberSchema as JoiNumberSchema, BooleanSchema as JoiBooleanSchema, ObjectSchema as JoiObjectSchema, ArraySchema as JoiArraySchema, DateSchema as JoiDateSchema, Reference, BasicType, CustomHelpers } from 'joi';
+/**
+ * Base schema type for all Joi validation schemas.
+ *
+ * This interface provides the foundation for all Joi schema types with
+ * comprehensive validation methods and options.
+ *
+ * @public
+ */
+export interface AnySchema<TSchema = any> extends Omit<JoiAnySchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal value (string, number, object, etc.)
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     *
+     * @example
+     * ```typescript
+     * const schema = joi.string().default('hello world')
+     * const schemaWithFunction = joi.number().default((parent, helpers) => parent.someOtherField * 2)
+     * ```
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for string validation.
+ *
+ * @public
+ */
+export interface StringSchema<TSchema = string> extends Omit<JoiStringSchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal string value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for binary data validation.
+ *
+ * @public
+ */
+export interface BinarySchema<TSchema = Buffer> extends Omit<JoiBinarySchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal binary value (Buffer, Uint8Array, etc.)
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for number validation.
+ *
+ * @public
+ */
+export interface NumberSchema<TSchema = number> extends Omit<JoiNumberSchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal number value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for boolean validation.
+ *
+ * @public
+ */
+export interface BooleanSchema<TSchema = boolean> extends Omit<JoiBooleanSchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal boolean value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for object validation.
+ *
+ * @public
+ */
+export interface ObjectSchema<TSchema = any> extends Omit<JoiObjectSchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal object value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     *
+     * When called without any value on an object schema type, a default value will be
+     * automatically generated based on the default values of the object keys.
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for array validation.
+ *
+ * @public
+ */
+export interface ArraySchema<TSchema = any[]> extends Omit<JoiArraySchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal array value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}
+/**
+ * Schema type for date validation.
+ *
+ * @public
+ */
+export interface DateSchema<TSchema = Date> extends Omit<JoiDateSchema<TSchema>, 'default'> {
+    /**
+     * Sets a default value if the original value is `undefined`.
+     *
+     * @param value - The default value. Can be:
+     * - A literal date value
+     * - A reference to another schema value
+     * - A function that returns the default value with signature `(parent, helpers) => value`
+     *   - `parent` - A clone of the object containing the value being validated
+     *   - `helpers` - Validation helper functions for custom validation logic
+     */
+    default(value?: Reference | BasicType | ((parent: any, helpers: CustomHelpers) => Reference | BasicType)): this;
+}

package/private/type_guards.d.ts

@@ -0,0 +1,42 @@
+import { DateTime } from 'luxon';
+import type { LucidBinaryValue } from './types';
+import type { ResourcefulModel } from './mixin';
+/**
+ * Type guard to check if a value is a Luxon DateTime instance
+ * @param value - The value to check
+ * @returns True if the value is a Luxon DateTime, false otherwise
+ */
+export declare const isLuxonDateTime: (value: unknown) => value is DateTime;
+/**
+ * Type guard to check if a value is a valid Lucid binary value (Uint8Array or Buffer)
+ * @param value - The value to check
+ * @returns True if the value is a LucidBinaryValue, false otherwise
+ */
+export declare const isLucidBinaryValue: (value: unknown) => value is LucidBinaryValue;
+/**
+ * Type guard to check if a value is a plain object (not null, not array)
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ */
+export declare const isObject: (value: unknown) => value is {
+    [key: string]: unknown;
+};
+/**
+ * Type guard to check if a value is an array
+ * @param value - The value to check
+ * @returns True if the value is an array, false otherwise
+ */
+export declare const isArray: (value: unknown) => value is unknown[];
+/**
+ * Checks if a value is an instance of a specific class.
+ * @param value - The value to check
+ * @param type - The name of the class to check against
+ * @returns true if the value is an instance of the specified class, false otherwise
+ */
+export declare const isInstanceOf: <T>(value: unknown, type: string, ctor?: new (...args: any[]) => T) => value is T;
+/**
+ * Type guard to check if a value is a ResourcefulModel
+ * @param value - The value to check
+ * @returns True if the value is a ResourcefulModel, false otherwise
+ */
+export declare const isResourcefulModel: (value: unknown) => value is ResourcefulModel;

package/private/types.d.ts

@@ -0,0 +1,102 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { ResourcefulDataType } from '@nhtio/lucid-resourceful/types';
+import type { ModelRelationTypes } from '@adonisjs/lucid/types/relations';
+import type { LucidModel, LucidRow, ModelColumnOptions, ComputedOptions } from '@adonisjs/lucid/types/model';
+import type { AnySchema, StringSchema, BinarySchema, NumberSchema, BooleanSchema, ObjectSchema, ArraySchema, DateSchema } from './schema_types';
+export type PromiseAble<T = unknown> = T | Promise<T> | PromiseLike<T>;
+export type Promised<T = unknown> = Promise<T> | PromiseLike<T>;
+export interface ResourcefulGeneralAccessControlFilter {
+    (ctx: HttpContext, app: ApplicationService): PromiseAble<boolean>;
+}
+export interface ResourcefulAccessControlFilter<ResourcefulModel extends LucidModel = LucidModel, ResourcefulModelInstance = InstanceType<ResourcefulModel>> {
+    (ctx: HttpContext, app: ApplicationService, instance?: ResourcefulModelInstance): PromiseAble<boolean>;
+}
+export interface ResourcefulResourceAccessControlFilter<ResourcefulModel extends LucidModel = LucidModel, ResourcefulModelInstance = InstanceType<ResourcefulModel>> {
+    (ctx: HttpContext, app: ApplicationService, instance: ResourcefulModelInstance): PromiseAble<boolean>;
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export interface ResourcefulPropertyDefinition {
+    propertyKey: string;
+    readAccessControlFilters: ResourcefulAccessControlFilter[];
+    writeAccessControlFilters: ResourcefulAccessControlFilter[];
+    nullable: boolean;
+    description?: string;
+    default?: any;
+    externalDocs?: ExternalDocumentationObject;
+    example?: string;
+    deprecated?: boolean;
+}
+export interface ValidationScoper<BaseSchema extends AnySchema> {
+    (schema: BaseSchema): void;
+}
+export interface LocalResourcefulPropertyDefinition<PropertyBaseSchema extends AnySchema> extends ResourcefulPropertyDefinition {
+    type: ResourcefulDataType;
+    validationScopes?: ValidationScoper<PropertyBaseSchema>[];
+}
+export interface ResourcefulColumnDefinition<ColumnBaseSchema extends AnySchema> extends LocalResourcefulPropertyDefinition<ColumnBaseSchema> {
+}
+export interface ResourcefulComputedAccessorDefinition<ComputedSetterBaseSchema extends AnySchema> extends LocalResourcefulPropertyDefinition<ComputedSetterBaseSchema> {
+    writable: boolean;
+}
+export interface ResourcefulRelationshipDefinition<Model extends LucidModel = LucidModel> extends ResourcefulPropertyDefinition {
+    relatedModel: () => Model;
+}
+export type LucidBinaryValue = Uint8Array | Buffer;
+export type LucidPlainObject = {
+    [key: string]: unknown;
+};
+export type ResourcefulPropertySchema = StringSchema | BinarySchema | NumberSchema | BooleanSchema | ObjectSchema | ArraySchema | DateSchema;
+export interface ResourcefulModelMetaSchema {
+    name: string;
+    properties: {
+        [key: string]: ResourcefulModelPropertyMetaSchema;
+    };
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    example?: string;
+}
+export interface ResourcefulModelColumnMetaSchema {
+    propertyKey: string;
+    definition: ResourcefulColumnDefinition<any>;
+    lucidDefinitions: ModelColumnOptions;
+    canRead: boolean;
+    canWrite: boolean;
+    kind: 'column';
+    validator: AnySchema;
+}
+export interface ResourcefulModelComputedAccessorMetaSchema {
+    propertyKey: string;
+    definition: ResourcefulComputedAccessorDefinition<any>;
+    lucidDefinitions: ComputedOptions;
+    canRead: boolean;
+    canWrite: boolean;
+    kind: 'computedAccessor';
+    validator: AnySchema;
+}
+export interface ResourcefulModelRelationshipMetaSchema<Model extends LucidModel = LucidModel> {
+    propertyKey: string;
+    definition: ResourcefulRelationshipDefinition;
+    lucidDefinitions: ReturnType<LucidModel['$getRelation']>;
+    canRead: boolean;
+    canWrite: boolean;
+    kind: 'relationship';
+    validator: AnySchema;
+    relatedModel: () => Model;
+}
+export type ResourcefulModelPropertyMetaSchema = ResourcefulModelColumnMetaSchema | ResourcefulModelComputedAccessorMetaSchema | ResourcefulModelRelationshipMetaSchema;
+export type ResourcefulModelOpenApiSchema = OpenAPIV3.SchemaObject;
+export type ResourcefulModelOpenApiRelatedSchema = OpenAPIV3.ReferenceObject;
+export type ResourcefulModelSerializableAttributes<Model extends LucidRow> = Model['$columns'] extends undefined ? {
+    [P in keyof Model as P extends keyof LucidRow | 'serializeExtras' ? never : Model[P] extends Function | ModelRelationTypes ? never : Model extends {
+        $columnsDefinitions: Map<infer K, infer V>;
+    } ? P extends K ? V extends {
+        serializeAs: null;
+    } ? never : V extends {
+        serializeAs: infer S;
+    } ? S extends string ? S : P : P : P : P]: Model[P];
+} : Model['$columns'];

package/private/utils.d.ts

@@ -0,0 +1,10 @@
+import { ACLOperationsEnum, CRUDOperationsEnum } from './constants';
+export declare const operationCRUDToACL: (operation: CRUDOperationsEnum) => ACLOperationsEnum | undefined;
+/**
+ * Checks if a value is a string
+ */
+export declare const isString: (value: unknown) => value is string;
+/**
+ * Checks if a value is a function
+ */
+export declare const isFunction: (value: unknown) => value is Function;

package/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.cjs.map

package/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Types utilized by @nhtio/lucid-resourceful
+ * @module @nhtio/lucid-resourceful/types
+ */
+export type { ResourcefulIndexResult, ResourcefulPayloadValidatorGetter, ResourcefulPayloadSchemaGetter, ResourcefulQueryScopeCallback, ResourcefulHooks, ResourcefulModel, AdvancedResourcefulMixinOptions, ResourcefulMixinOptions, ResourcefulScopeHooks, ResourcefulValidationHooks, ResourcefulMixinEventMap, ResourcefulErrorHandlerMethod, ResourcefulACLOperationType, } from './private/mixin';
+export type * from './private/types';
+export type { CallableNewable } from './private/data_types';
+export type { BaseInterface, BaseClass, ResourcefulStringTypeOptions, ResourcefulDateTypeOptions, ResourcefulDateTimeTypeOptions, ResourcefulBinaryTypeOptions, ResourcefulNumberTypeOptions, ResourcefulIntegerTypeOptions, ResourcefulBigintTypeOptions, ResourcefulUnsignedIntegerTypeOptions, ResourcefulBooleanTypeOptions, ResourcefulObjectTypeOptions, ResourcefulArrayTypeOptions, ResourcefulDataType, } from './private/data_types';
+export type { DateTime } from 'luxon';
+export type { RelatedModelRelationOptions, HasManyThroughRelationOptions, DataTypeColumnOptions, DataTypeComputedOptions, DateColumnOptions, } from './private/decorators';
+import type { AnySchema, StringSchema, BinarySchema, NumberSchema, BooleanSchema, ObjectSchema, ArraySchema, DateSchema } from './private/schema_types';
+export type { SchemaInternals } from 'joi';
+export type { AnySchema, StringSchema, BinarySchema, NumberSchema, BooleanSchema, ObjectSchema, ArraySchema, DateSchema, };
+/**
+ * Union type of all available Joi schema types
+ * @public
+ */
+export type Schema = AnySchema | StringSchema | BinarySchema | NumberSchema | BooleanSchema | ObjectSchema | ArraySchema | DateSchema;
+export type { LucidModel, ModelColumnOptions, ComputedOptions } from '@adonisjs/lucid/types/model';
+export type { ValidationError } from 'joi';
+export type { BaseModel } from '@adonisjs/lucid/orm';
+export type { HttpContext } from '@adonisjs/core/http';
+export type { ApplicationService } from '@adonisjs/core/types';
+export type { EventMap, Key, Listener } from '@nhtio/tiny-typed-emitter';
+export type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+export type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+export type { OpenAPIV3 } from 'openapi-types';
+export type { DatabaseQueryBuilderContract } from '@adonisjs/lucid/types/querybuilder';

package/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/utils/casters.d.ts

@@ -0,0 +1 @@
+export { castValueAsString, castValueAsDate, castValueAsDateTime, castValueAsBinary, castValueAsNumber, castValueAsInteger, castValueAsBigint, castValueAsUnsignedInt, castValueAsBoolean, castValueAsObject, castValueAsArray, } from '../private/decorator_utils';

package/utils/consumers.d.ts

@@ -0,0 +1 @@
+export { consumeString, consumeDate, consumeDateTime, consumeBinary, consumeNumber, consumeInteger, consumeBigint, consumeUnsignedint, consumeBoolean, consumeObject, consumeArray, } from '../private/decorator_utils';

package/utils/preparers.d.ts

@@ -0,0 +1 @@
+export { prepareString, prepareDate, prepareDateTime, prepareBinary, prepareNumber, prepareInteger, prepareBigint, prepareUnsignedint, prepareBoolean, prepareObject, prepareArray, } from '../private/decorator_utils';

package/utils.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const decorator_utils = require("./decorator_utils-1yWqd_Gg.cjs");
+const casters = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  castValueAsArray: decorator_utils.castValueAsArray,
+  castValueAsBigint: decorator_utils.castValueAsBigint,
+  castValueAsBinary: decorator_utils.castValueAsBinary,
+  castValueAsBoolean: decorator_utils.castValueAsBoolean,
+  castValueAsDate: decorator_utils.castValueAsDate,
+  castValueAsDateTime: decorator_utils.castValueAsDateTime,
+  castValueAsInteger: decorator_utils.castValueAsInteger,
+  castValueAsNumber: decorator_utils.castValueAsNumber,
+  castValueAsObject: decorator_utils.castValueAsObject,
+  castValueAsString: decorator_utils.castValueAsString,
+  castValueAsUnsignedInt: decorator_utils.castValueAsUnsignedInt
+}, Symbol.toStringTag, { value: "Module" }));
+const preparers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  prepareArray: decorator_utils.prepareArray,
+  prepareBigint: decorator_utils.prepareBigint,
+  prepareBinary: decorator_utils.prepareBinary,
+  prepareBoolean: decorator_utils.prepareBoolean,
+  prepareDate: decorator_utils.prepareDate,
+  prepareDateTime: decorator_utils.prepareDateTime,
+  prepareInteger: decorator_utils.prepareInteger,
+  prepareNumber: decorator_utils.prepareNumber,
+  prepareObject: decorator_utils.prepareObject,
+  prepareString: decorator_utils.prepareString,
+  prepareUnsignedint: decorator_utils.prepareUnsignedint
+}, Symbol.toStringTag, { value: "Module" }));
+const consumers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  consumeArray: decorator_utils.consumeArray,
+  consumeBigint: decorator_utils.consumeBigint,
+  consumeBinary: decorator_utils.consumeBinary,
+  consumeBoolean: decorator_utils.consumeBoolean,
+  consumeDate: decorator_utils.consumeDate,
+  consumeDateTime: decorator_utils.consumeDateTime,
+  consumeInteger: decorator_utils.consumeInteger,
+  consumeNumber: decorator_utils.consumeNumber,
+  consumeObject: decorator_utils.consumeObject,
+  consumeString: decorator_utils.consumeString,
+  consumeUnsignedint: decorator_utils.consumeUnsignedint
+}, Symbol.toStringTag, { value: "Module" }));
+exports.guards = decorator_utils.type_guards;
+exports.casters = casters;
+exports.consumers = consumers;
+exports.preparers = preparers;
+//# sourceMappingURL=utils.cjs.map

package/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Helpers and utilities used by Lucid Resourceful
+ * @module @nhtio/lucid-resourceful/utils
+ */
+/**
+ * Utilities used to cast values to specific data types
+ */
+export * as casters from './utils/casters';
+/**
+ * Type guards for Resourceful data types
+ */
+export * as guards from './private/type_guards';
+/**
+ * Utilities used to prepare values before being inserted into the database
+ */
+export * as preparers from './utils/preparers';
+/**
+ * Utilities used to consume values from the database for specific data types
+ */
+export * as consumers from './utils/consumers';

package/utils.mjs

@@ -0,0 +1,51 @@
+import { c as castValueAsArray, a as castValueAsBigint, b as castValueAsBinary, d as castValueAsBoolean, e as castValueAsDate, f as castValueAsDateTime, g as castValueAsInteger, h as castValueAsNumber, i as castValueAsObject, j as castValueAsString, k as castValueAsUnsignedInt, p as prepareArray, l as prepareBigint, m as prepareBinary, n as prepareBoolean, o as prepareDate, q as prepareDateTime, r as prepareInteger, s as prepareNumber, t as prepareObject, u as prepareString, v as prepareUnsignedint, w as consumeArray, x as consumeBigint, y as consumeBinary, z as consumeBoolean, A as consumeDate, B as consumeDateTime, C as consumeInteger, D as consumeNumber, E as consumeObject, F as consumeString, G as consumeUnsignedint } from "./decorator_utils-BUuBwQYK.js";
+import { H } from "./decorator_utils-BUuBwQYK.js";
+const casters = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  castValueAsArray,
+  castValueAsBigint,
+  castValueAsBinary,
+  castValueAsBoolean,
+  castValueAsDate,
+  castValueAsDateTime,
+  castValueAsInteger,
+  castValueAsNumber,
+  castValueAsObject,
+  castValueAsString,
+  castValueAsUnsignedInt
+}, Symbol.toStringTag, { value: "Module" }));
+const preparers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  prepareArray,
+  prepareBigint,
+  prepareBinary,
+  prepareBoolean,
+  prepareDate,
+  prepareDateTime,
+  prepareInteger,
+  prepareNumber,
+  prepareObject,
+  prepareString,
+  prepareUnsignedint
+}, Symbol.toStringTag, { value: "Module" }));
+const consumers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  consumeArray,
+  consumeBigint,
+  consumeBinary,
+  consumeBoolean,
+  consumeDate,
+  consumeDateTime,
+  consumeInteger,
+  consumeNumber,
+  consumeObject,
+  consumeString,
+  consumeUnsignedint
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  casters,
+  consumers,
+  H as guards,
+  preparers
+};
+//# sourceMappingURL=utils.mjs.map

package/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}