@nhtio/lucid-resourceful 1.20250718.0

package/joi.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./index-Cv6KC1rC.cjs");
+exports.joi = index.joi;
+//# sourceMappingURL=joi.cjs.map

package/joi.cjs.map

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

package/joi.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A modified version of the joi validation library which adds support for new custom schemas
+ * @module @nhtio/lucid-resourceful/joi
+ */
+export * from './private/joi';

package/joi.mjs

@@ -0,0 +1,5 @@
+import { j } from "./index-DDaZ2qr2.js";
+export {
+  j as joi
+};
+//# sourceMappingURL=joi.mjs.map

package/joi.mjs.map

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

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@nhtio/lucid-resourceful",
+  "version": "1.20250718.0",
+  "description": "A decorator-driven AdonisJS library that lets you annotate Lucid ORM models with metadata to automatically generate CRUD controllers, validation rules, OpenAPI schemas, and a unified query interface.",
+  "keywords": [],
+  "author": "Jak Giveon <jak@nht.io>",
+  "copyright": "© 2025-present New Horizon Technology LTD",
+  "license": "MIT",
+  "peerDependencies": {
+    "@adonisjs/core": "^6.19.0",
+    "@adonisjs/lucid": "^21.7.0",
+    "better-sqlite3": "^12.2.0",
+    "luxon": "^3.6.1",
+    "mysql": "^2.18.1",
+    "mysql2": "^3.14.2",
+    "oracledb": "^6.8.0",
+    "pg": "^8.16.3",
+    "pg-native": "^3.5.2",
+    "sqlite3": "^5.1.7",
+    "tedious": "^18.6.1"
+  },
+  "type": "module",
+  "module": "./index.mjs",
+  "main": "./index.cjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    },
+    "./definitions": {
+      "import": "./definitions.mjs",
+      "require": "./definitions.cjs",
+      "types": "./definitions.d.ts"
+    },
+    "./errors": {
+      "import": "./errors.mjs",
+      "require": "./errors.cjs",
+      "types": "./errors.d.ts"
+    },
+    "./joi": {
+      "import": "./joi.mjs",
+      "require": "./joi.cjs",
+      "types": "./joi.d.ts"
+    },
+    "./types": {
+      "import": "./types.mjs",
+      "require": "./types.cjs",
+      "types": "./types.d.ts"
+    },
+    "./utils": {
+      "import": "./utils.mjs",
+      "require": "./utils.cjs",
+      "types": "./utils.d.ts"
+    }
+  },
+  "imports": {
+    "#tests/*": "./tests/*.ts"
+  },
+  "dependencies": {
+    "joi": "^17.13.3",
+    "liqe": "^3.8.3"
+  },
+  "packageManager": "pnpm@10.8.0+sha512.0e82714d1b5b43c74610193cb20734897c1d00de89d0e18420aebc5977fa13d780a9cb05734624e81ebd81cc876cd464794850641c48b9544326b5622ca29971"
+}

package/private/constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum CRUDOperationsEnum {
+    CREATE = "create",
+    READ = "read",
+    LIST = "list",
+    UPDATE = "update",
+    DELETE = "delete"
+}
+export declare enum ACLOperationsEnum {
+    WRITE = "write",
+    READ = "read"
+}

package/private/controller_factory.d.ts

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

package/private/data_type_schemas.d.ts

@@ -0,0 +1,12 @@
+import type { ResourcefulStringTypeOptions, ResourcefulDateTypeOptions, ResourcefulDateTimeTypeOptions, ResourcefulBinaryTypeOptions, ResourcefulNumberTypeOptions, ResourcefulIntegerTypeOptions, ResourcefulBigintTypeOptions, ResourcefulUnsignedIntegerTypeOptions, ResourcefulBooleanTypeOptions, ResourcefulObjectTypeOptions, ResourcefulArrayTypeOptions } from './data_types';
+export declare const ResourcefulStringTypeSchema: () => import("joi").ObjectSchema<ResourcefulStringTypeOptions>;
+export declare const ResourcefulDateTypeSchema: () => import("joi").ObjectSchema<ResourcefulDateTypeOptions>;
+export declare const ResourcefulDateTimeTypeSchema: () => import("joi").ObjectSchema<ResourcefulDateTimeTypeOptions>;
+export declare const ResourcefulBinaryTypeSchema: () => import("joi").ObjectSchema<ResourcefulBinaryTypeOptions>;
+export declare const ResourcefulNumberTypeSchema: () => import("joi").ObjectSchema<ResourcefulNumberTypeOptions>;
+export declare const ResourcefulIntegerTypeSchema: () => import("joi").ObjectSchema<ResourcefulIntegerTypeOptions>;
+export declare const ResourcefulBigintTypeSchema: () => import("joi").ObjectSchema<ResourcefulBigintTypeOptions>;
+export declare const ResourcefulUnsignedIntegerTypeSchema: () => import("joi").ObjectSchema<ResourcefulUnsignedIntegerTypeOptions>;
+export declare const ResourcefulBooleanTypeSchema: () => import("joi").ObjectSchema<ResourcefulBooleanTypeOptions>;
+export declare const ResourcefulObjectTypeSchema: () => import("joi").ObjectSchema<ResourcefulObjectTypeOptions>;
+export declare const ResourcefulArrayTypeSchema: () => import("joi").ObjectSchema<ResourcefulArrayTypeOptions>;

package/private/data_types.d.ts

@@ -0,0 +1,437 @@
+import type { ObjectSchema } from 'joi';
+/**
+ * Base interface for all Resourceful data type options.
+ * Includes common modifier properties that apply to all data types.
+ */
+export interface BaseInterface {
+    /** Whether the value can be null */
+    nullable?: boolean;
+    /** Whether the property is read-only (not included in create/update operations) */
+    readOnly?: boolean;
+    /** Whether the property is write-only (not included in response serialization) */
+    writeOnly?: boolean;
+}
+/**
+ * Base type constraint for abstract constructor functions used in data type generation.
+ */
+export type BaseClass = abstract new (...args: any[]) => any;
+/**
+ * A hybrid type that represents a constructor function which can be called both with and without the `new` keyword.
+ * This type enables creating data type classes that work as both constructors and factory functions.
+ *
+ * @typeParam ClassConstructorOptions - The interface defining the constructor options for the class
+ * @typeParam C - The abstract constructor type constraint
+ */
+export type CallableNewable<ClassConstructorOptions extends BaseInterface, C extends BaseClass = BaseClass> = {
+    readonly schema: ObjectSchema<ClassConstructorOptions>;
+    new (...args: ConstructorParameters<C>): InstanceType<C>;
+} & {
+    (...args: ConstructorParameters<C>): InstanceType<C>;
+} & {
+    prototype: InstanceType<C>;
+};
+/**
+ * Supported string formats for ResourcefulStringType, excluding OpenAPI reserved formats.
+ * These formats provide additional validation and documentation for string fields.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export declare const ResourcefulStringFormat: readonly ["password", "byte"];
+/**
+ * Union type of supported string formats for ResourcefulStringType.
+ * Used to provide type safety when specifying string field formats.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export type ResourcefulStringFormat = (typeof ResourcefulStringFormat)[number];
+/**
+ * Configuration options for ResourcefulStringType instances.
+ * Defines validation rules and constraints for string-based fields in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulStringTypeOptions extends BaseInterface {
+    /** Minimum length constraint for the string value */
+    minLength: number;
+    /** Maximum length constraint for the string value */
+    maxLength: number;
+    /** Regular expression pattern that the string value must match */
+    pattern?: string;
+    /** String format specification, excluding OpenAPI reserved formats like date, date-time, and binary */
+    format?: ResourcefulStringFormat | Exclude<string, 'date' | 'date-time' | 'password' | 'byte' | 'binary'>;
+    /** Array of allowed string values for enumeration validation */
+    enum?: string[];
+}
+/**
+ * Callable constructor for creating validated string type instances.
+ * Supports both constructor and function call patterns for flexible usage.
+ *
+ * @example
+ * ```typescript
+ * const stringType = new ResourcefulStringType({ minLength: 1, maxLength: 100 })
+ * const stringType2 = ResourcefulStringType({ pattern: '^[a-zA-Z]+$' })
+ * ```
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export declare const ResourcefulStringType: CallableNewable<ResourcefulStringTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulStringType with validated properties.
+ * Represents a string data type with validation constraints as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulStringType extends ResourcefulStringTypeOptions {
+    type: 'string';
+}
+/**
+ * Configuration options for ResourcefulDateType instances.
+ * Represents date-only values formatted as ISO 8601 date strings.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulDateTypeOptions extends BaseInterface {
+}
+/**
+ * Callable constructor for creating validated date type instances.
+ * Automatically sets the OpenAPI format to 'date' for ISO 8601 date strings.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export declare const ResourcefulDateType: CallableNewable<ResourcefulDateTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulDateType with validated properties.
+ * Represents a date-only value formatted as ISO 8601 date string as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulDateType extends ResourcefulDateTypeOptions {
+    type: 'string';
+    format: 'date';
+}
+/**
+ * Configuration options for ResourcefulDateTimeType instances.
+ * Represents date-time values formatted as ISO 8601 date-time strings.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulDateTimeTypeOptions extends BaseInterface {
+}
+/**
+ * Callable constructor for creating validated date-time type instances.
+ * Automatically sets the OpenAPI format to 'date-time' for ISO 8601 date-time strings.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export declare const ResourcefulDateTimeType: CallableNewable<ResourcefulDateTimeTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulDateTimeType with validated properties.
+ * Represents a date-time value formatted as ISO 8601 date-time string as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulDateTimeType extends ResourcefulDateTimeTypeOptions {
+    type: 'string';
+    format: 'date-time';
+}
+/**
+ * Configuration options for ResourcefulBinaryType instances.
+ * Defines constraints for binary data represented as base64-encoded strings.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulBinaryTypeOptions extends BaseInterface {
+    /** Minimum length constraint for the base64-encoded binary data */
+    minLength: number;
+    /** Maximum length constraint for the base64-encoded binary data */
+    maxLength: number;
+}
+/**
+ * Callable constructor for creating validated binary type instances.
+ * Automatically sets the OpenAPI format to 'binary' for base64-encoded binary data.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export declare const ResourcefulBinaryType: CallableNewable<ResourcefulBinaryTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulBinaryType with validated properties.
+ * Represents binary data as base64-encoded string as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#string | OpenAPI 3.0 String Type}
+ */
+export interface ResourcefulBinaryType extends ResourcefulBinaryTypeOptions {
+    type: 'string';
+    format: 'binary';
+}
+/**
+ * Supported number formats for ResourcefulNumberType, following OpenAPI 3.0 specification.
+ * These formats provide additional precision and validation for numeric fields.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Number Type}
+ */
+export declare const ResourcefulNumberFormat: readonly ["float", "double"];
+/**
+ * Union type of supported number formats for ResourcefulNumberType.
+ * Used to provide type safety when specifying numeric field formats.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Number Type}
+ */
+export type ResourcefulNumberFormat = (typeof ResourcefulNumberFormat)[number];
+/**
+ * Configuration options for ResourcefulNumberType instances.
+ * Defines validation rules and constraints for numeric fields in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Number Type}
+ */
+export interface ResourcefulNumberTypeOptions extends BaseInterface {
+    /** Minimum value constraint for the number */
+    minimum: number;
+    /** Whether the minimum value is exclusive (value must be greater than minimum) */
+    exclusiveMinimum: boolean;
+    /** Maximum value constraint for the number */
+    maximum: number;
+    /** Whether the maximum value is exclusive (value must be less than maximum) */
+    exclusiveMaximum: boolean;
+    /** Number format specification for precision (float or double) */
+    format: ResourcefulNumberFormat;
+    /** Value must be a multiple of this number */
+    multipleOf: number;
+}
+/**
+ * Callable constructor for creating validated number type instances.
+ * Supports floating-point numbers with configurable precision and range constraints.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Number Type}
+ */
+export declare const ResourcefulNumberType: CallableNewable<ResourcefulNumberTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulNumberType with validated properties.
+ * Represents floating-point numbers as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Number Type}
+ */
+export interface ResourcefulNumberType extends ResourcefulNumberTypeOptions {
+    type: 'number';
+}
+/**
+ * Configuration options for ResourcefulIntegerType instances.
+ * Defines validation rules and constraints for 32-bit integer fields in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulIntegerTypeOptions extends BaseInterface {
+    /** Minimum value constraint for the integer */
+    minimum: number;
+    /** Whether the minimum value is exclusive (value must be greater than minimum) */
+    exclusiveMinimum: boolean;
+    /** Maximum value constraint for the integer */
+    maximum: number;
+    /** Whether the maximum value is exclusive (value must be less than maximum) */
+    exclusiveMaximum: boolean;
+    /** Value must be a multiple of this number */
+    multipleOf: number;
+}
+/**
+ * Callable constructor for creating validated integer type instances.
+ * Automatically sets the OpenAPI format to 'int32' for 32-bit signed integers.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export declare const ResourcefulIntegerType: CallableNewable<ResourcefulIntegerTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulIntegerType with validated properties.
+ * Represents 32-bit signed integers as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulIntegerType extends ResourcefulIntegerTypeOptions {
+    type: 'integer';
+    format: 'int32';
+}
+/**
+ * Configuration options for ResourcefulBigintType instances.
+ * Defines validation rules and constraints for 64-bit integer fields in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulBigintTypeOptions extends BaseInterface {
+    /** Minimum value constraint for the 64-bit integer */
+    minimum: bigint;
+    /** Whether the minimum value is exclusive (value must be greater than minimum) */
+    exclusiveMinimum: boolean;
+    /** Maximum value constraint for the 64-bit integer */
+    maximum: bigint;
+    /** Whether the maximum value is exclusive (value must be less than maximum) */
+    exclusiveMaximum: boolean;
+    /** Value must be a multiple of this number */
+    multipleOf: bigint;
+}
+/**
+ * Callable constructor for creating validated bigint type instances.
+ * Automatically sets the OpenAPI format to 'int64' for 64-bit signed integers.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export declare const ResourcefulBigintType: CallableNewable<ResourcefulBigintTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulBigintType with validated properties.
+ * Represents 64-bit signed integers as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulBigintType extends ResourcefulBigintTypeOptions {
+    type: 'integer';
+    format: 'int64';
+}
+/**
+ * Configuration options for ResourcefulUnsignedIntegerType instances.
+ * Defines validation rules and constraints for unsigned integer fields in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulUnsignedIntegerTypeOptions extends BaseInterface {
+    /** Minimum value constraint for the unsigned integer */
+    minimum: number;
+    /** Whether the minimum value is exclusive (value must be greater than minimum) */
+    exclusiveMinimum: boolean;
+    /** Maximum value constraint for the unsigned integer */
+    maximum: number;
+    /** Whether the maximum value is exclusive (value must be less than maximum) */
+    exclusiveMaximum: boolean;
+    /** Value must be a multiple of this number */
+    multipleOf: number;
+}
+/**
+ * Callable constructor for creating validated unsigned integer type instances.
+ * Represents unsigned integers without a specific OpenAPI format constraint.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export declare const ResourcefulUnsignedIntegerType: CallableNewable<ResourcefulUnsignedIntegerTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulUnsignedIntegerType with validated properties.
+ * Represents unsigned integers as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers | OpenAPI 3.0 Integer Type}
+ */
+export interface ResourcefulUnsignedIntegerType extends ResourcefulUnsignedIntegerTypeOptions {
+    type: 'integer';
+    format: never;
+}
+/**
+ * Configuration options for ResourcefulBooleanType instances.
+ * Currently has no specific configuration options as boolean types are straightforward.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#boolean | OpenAPI 3.0 Boolean Type}
+ */
+export interface ResourcefulBooleanTypeOptions extends BaseInterface {
+}
+/**
+ * Callable constructor for creating validated boolean type instances.
+ * Represents simple true/false values in OpenAPI schemas.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#boolean | OpenAPI 3.0 Boolean Type}
+ */
+export declare const ResourcefulBooleanType: CallableNewable<ResourcefulBooleanTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulBooleanType with validated properties.
+ * Represents boolean true/false values as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#boolean | OpenAPI 3.0 Boolean Type}
+ */
+export interface ResourcefulBooleanType extends ResourcefulBooleanTypeOptions {
+    type: 'boolean';
+}
+/**
+ * Configuration options for ResourcefulObjectType instances.
+ * Defines complex object schemas with typed properties and validation rules.
+ * Supports advanced OpenAPI features like oneOf, allOf, anyOf, and not operators.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#object | OpenAPI 3.0 Object Type}
+ */
+export interface ResourcefulObjectTypeOptions extends BaseInterface {
+    /** Object properties definition supporting direct data types and composition patterns */
+    properties: {
+        [key: string]: ResourcefulDataType | {
+            oneOf: Array<ResourcefulDataType>;
+        } | {
+            allOf: Array<ResourcefulDataType>;
+        } | {
+            anyOf: Array<ResourcefulDataType>;
+        } | {
+            not: Array<ResourcefulDataType>;
+        };
+    };
+    /** Array of property names that are required for object validation */
+    required?: string[];
+    /** Whether additional properties beyond those defined are allowed, or direct data type for additional properties */
+    additionalProperties?: boolean | ResourcefulDataType;
+    /** Minimum number of properties required in the object */
+    minProperties?: number;
+    /** Maximum number of properties allowed in the object */
+    maxProperties?: number;
+}
+/**
+ * Callable constructor for creating validated object type instances.
+ * Supports complex nested object schemas with property validation and constraints.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#object | OpenAPI 3.0 Object Type}
+ */
+export declare const ResourcefulObjectType: CallableNewable<ResourcefulObjectTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulObjectType with validated properties.
+ * Represents complex object schemas with typed properties as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#object | OpenAPI 3.0 Object Type}
+ */
+export interface ResourcefulObjectType extends ResourcefulObjectTypeOptions {
+    type: 'object';
+}
+/**
+ * Configuration options for ResourcefulArrayType instances.
+ * Defines array schemas with typed items and validation constraints.
+ * Supports complex item types including nested objects and arrays.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#array | OpenAPI 3.0 Array Type}
+ */
+export interface ResourcefulArrayTypeOptions extends BaseInterface {
+    /** Type specification for array items, supporting all resourceful data types and composition patterns */
+    items: ResourcefulDataType | {
+        oneOf: Array<ResourcefulDataType>;
+    } | {
+        allOf: Array<ResourcefulDataType>;
+    } | {
+        anyOf: Array<ResourcefulDataType>;
+    } | {
+        not: Array<ResourcefulDataType>;
+    };
+    /** Minimum number of items required in the array */
+    minItems?: number;
+    /** Maximum number of items allowed in the array */
+    maxItems?: number;
+    /** Whether all items in the array must be unique */
+    uniqueItems?: boolean;
+}
+/**
+ * Callable constructor for creating validated array type instances.
+ * Supports arrays with typed items and validation constraints like minimum/maximum length.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#array | OpenAPI 3.0 Array Type}
+ */
+export declare const ResourcefulArrayType: CallableNewable<ResourcefulArrayTypeOptions, BaseClass>;
+/**
+ * Instance type for ResourcefulArrayType with validated properties.
+ * Represents arrays with typed items and validation constraints as defined in the OpenAPI 3.0 specification.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/#array | OpenAPI 3.0 Array Type}
+ */
+export interface ResourcefulArrayType extends ResourcefulArrayTypeOptions {
+    type: 'array';
+}
+/**
+ * Union type representing all available resourceful data types.
+ * Provides a comprehensive type for working with any resourceful data type instance.
+ *
+ * @see {@link https://swagger.io/docs/specification/v3_0/data-models/data-types/ | OpenAPI 3.0 Data Types}
+ */
+export type ResourcefulDataType = ResourcefulStringType | ResourcefulDateType | ResourcefulDateTimeType | ResourcefulBinaryType | ResourcefulNumberType | ResourcefulIntegerType | ResourcefulBigintType | ResourcefulUnsignedIntegerType | ResourcefulBooleanType | ResourcefulObjectType | ResourcefulArrayType;

package/private/decorator_schemas.d.ts

@@ -0,0 +1,34 @@
+import type { ObjectSchema } from 'joi';
+export declare const validateNormalizeAndCastDecoratorOptions: <InputType, OutputType>(fieldName: string, decoratorName: string, schema: ObjectSchema, input: InputType) => OutputType;
+export declare const resourcefulColumnDefinitionSchema: ObjectSchema<any>;
+export declare const resourcefulColumnOptionsSchema: ObjectSchema<any>;
+export declare const dataTypeColumnOptionsSchema: ObjectSchema<any>;
+export declare const stringColumnOptionsSchema: ObjectSchema<any>;
+export declare const dateColumnOptionsSchema: ObjectSchema<any>;
+export declare const dateTimeColumnOptionsSchema: ObjectSchema<any>;
+export declare const binaryColumnOptionsSchema: ObjectSchema<any>;
+export declare const numberColumnOptionsSchema: ObjectSchema<any>;
+export declare const integerColumnOptionsSchema: ObjectSchema<any>;
+export declare const bigintColumnOptionsSchema: ObjectSchema<any>;
+export declare const unsignedIntegerColumnOptionsSchema: ObjectSchema<any>;
+export declare const booleanColumnOptionsSchema: ObjectSchema<any>;
+export declare const objectColumnOptionsSchema: ObjectSchema<any>;
+export declare const arrayColumnOptionsSchema: ObjectSchema<any>;
+export declare const resourcefulComputedDefinitionSchema: ObjectSchema<any>;
+export declare const resourcefulComputedOptionsSchema: ObjectSchema<any>;
+export declare const dataTypeComputedOptionsSchema: ObjectSchema<any>;
+export declare const stringComputedOptionsSchema: ObjectSchema<any>;
+export declare const dateComputedOptionsSchema: ObjectSchema<any>;
+export declare const dateTimeComputedOptionsSchema: ObjectSchema<any>;
+export declare const binaryComputedOptionsSchema: ObjectSchema<any>;
+export declare const numberComputedOptionsSchema: ObjectSchema<any>;
+export declare const integerComputedOptionsSchema: ObjectSchema<any>;
+export declare const bigintComputedOptionsSchema: ObjectSchema<any>;
+export declare const unsignedIntegerComputedOptionsSchema: ObjectSchema<any>;
+export declare const booleanComputedOptionsSchema: ObjectSchema<any>;
+export declare const objectComputedOptionsSchema: ObjectSchema<any>;
+export declare const arrayComputedOptionsSchema: ObjectSchema<any>;
+export declare const resourcefulRelationshipOptionsSchema: ObjectSchema<any>;
+export declare const relationOptionsSchema: ObjectSchema<any>;
+export declare const manyToManyRelationOptionsSchema: ObjectSchema<any>;
+export declare const hasManyThroughRelationOptionsSchema: ObjectSchema<any>;