@alba-cars/common-modules 1.2.7 → 1.2.9

package/dist/features/vehicle/data/dto/MediaDTO.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/features/vehicle/data/dto/VehicleCategoryDTO.d.ts

@@ -0,0 +1,39 @@
+import { BaseCreateDTO, BaseUpdateDTO } from "./BaseDTO";
+import { VehicleCategoryFilter, VehicleCategoryOptions, VehicleCategoryUniqueFilter } from "./VehicleFilterDTO";
+export declare class VehicleCategoryGetDTO {
+    filter?: VehicleCategoryFilter;
+    options?: VehicleCategoryOptions;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryGetDTO;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleCategoryGetUniqueDTO {
+    filter?: VehicleCategoryUniqueFilter;
+    options?: Omit<VehicleCategoryOptions, 'page' | 'limit' | 'sort'>;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryGetUniqueDTO;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleCategoryCreateDTO extends BaseCreateDTO {
+    name: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryCreateDTO;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleCategoryUpdateDTO extends BaseUpdateDTO {
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryUpdateDTO;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class DynamicVehicleCategoryDTO {
+    constructor(payload: {
+        existingId?: string;
+        new?: VehicleCategoryCreateDTO;
+    });
+    existingId?: string;
+    new?: VehicleCategoryCreateDTO;
+    validate(): void;
+    static fromPlain(plain: Record<string, unknown>): DynamicVehicleCategoryDTO;
+    static toPlain(entity: any): Record<string, unknown>;
+}

package/dist/features/vehicle/data/dto/VehicleCategoryDTO.js

@@ -0,0 +1,114 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicVehicleCategoryDTO = exports.VehicleCategoryUpdateDTO = exports.VehicleCategoryCreateDTO = exports.VehicleCategoryGetUniqueDTO = exports.VehicleCategoryGetDTO = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const BaseDTO_1 = require("./BaseDTO");
+class VehicleCategoryGetDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(VehicleCategoryGetDTO, plain);
+    }
+    static toPlain(entity) {
+        return (0, class_transformer_1.instanceToPlain)(entity);
+    }
+}
+exports.VehicleCategoryGetDTO = VehicleCategoryGetDTO;
+// Use this to get a unique vehicle make by unique fields
+class VehicleCategoryGetUniqueDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(VehicleCategoryGetUniqueDTO, plain);
+    }
+    static toPlain(entity) {
+        return (0, class_transformer_1.instanceToPlain)(entity);
+    }
+}
+exports.VehicleCategoryGetUniqueDTO = VehicleCategoryGetUniqueDTO;
+class VehicleCategoryCreateDTO extends BaseDTO_1.BaseCreateDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(VehicleCategoryCreateDTO, plain);
+    }
+    static toPlain(entity) {
+        return (0, class_transformer_1.instanceToPlain)(entity);
+    }
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsDefined)(),
+    (0, class_validator_1.Matches)(/^[a-zA-Z0-9\s\-\_]*$/, {
+        message: 'Name can only contain letters, numbers, spaces, hyphens, and underscores.',
+    }),
+    __metadata("design:type", String)
+], VehicleCategoryCreateDTO.prototype, "name", void 0);
+exports.VehicleCategoryCreateDTO = VehicleCategoryCreateDTO;
+class VehicleCategoryUpdateDTO extends BaseDTO_1.BaseUpdateDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(VehicleCategoryUpdateDTO, plain);
+    }
+    static toPlain(entity) {
+        return (0, class_transformer_1.instanceToPlain)(entity);
+    }
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Matches)(/^[a-zA-Z0-9\s\-\_]*$/, {
+        message: 'Name can only contain letters, numbers, spaces, hyphens, and underscores.',
+    }),
+    __metadata("design:type", String)
+], VehicleCategoryUpdateDTO.prototype, "name", void 0);
+exports.VehicleCategoryUpdateDTO = VehicleCategoryUpdateDTO;
+class DynamicVehicleCategoryDTO {
+    constructor(payload) {
+        this.existingId = payload.existingId;
+        this.new = payload.new;
+    }
+    validate() {
+        if (!this.existingId && !this.new) {
+            throw new Error('Either existingId or new details must be provided.');
+        }
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(DynamicVehicleCategoryDTO, plain);
+    }
+    static toPlain(entity) {
+        return (0, class_transformer_1.instanceToPlain)(entity);
+    }
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], DynamicVehicleCategoryDTO.prototype, "existingId", void 0);
+__decorate([
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => VehicleCategoryCreateDTO),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", VehicleCategoryCreateDTO)
+], DynamicVehicleCategoryDTO.prototype, "new", void 0);
+exports.DynamicVehicleCategoryDTO = DynamicVehicleCategoryDTO;

package/dist/features/vehicle/data/dto/VehicleDTO.d.ts

@@ -1,20 +1,20 @@
-import { VehicleFilter, VehicleOptions, VehicleUniqueFilter } from '../utilities';
-import { BaseCreateDTO, BaseUpdateDTO } from './BaseDTO';
-import { DynamicMakeDTO } from './VehicleMakeDTO';
-import { DynamicModelDTO } from './VehicleModelDTO';
-import { DynamicVehicleBodyTypeDTO } from './VehicleTypeDTO';
-import { VehicleMediaCreateDTO, VehicleMediaUpdateDTO } from './VehicleMedia';
+import { VehicleFilter, VehicleOptions, VehicleUniqueFilter } from "../utilities";
+import { BaseCreateDTO, BaseUpdateDTO } from "./BaseDTO";
+import { DynamicMakeDTO } from "./VehicleMakeDTO";
+import { DynamicModelDTO } from "./VehicleModelDTO";
+import { DynamicVehicleBodyTypeDTO } from "./VehicleTypeDTO";
+import { VehicleMediaCreateDTO, VehicleMediaUpdateDTO } from "./VehicleMedia";
 export declare class VehicleGetDTO {
     filter?: VehicleFilter;
     options?: VehicleOptions;
     validate?: (shouldValidate?: boolean) => string[];
     constructor(shouldIncludeValidate?: boolean);
     static fromPlain(plain: Record<string, unknown>): VehicleGetDTO;
-    static toPlain(entity: any): Record<string, unknown>;
+    toPlain(): Record<string, unknown>;
 }
 export declare class VehicleGetUniqueDTO {
     filter?: VehicleUniqueFilter;
-    options?: Omit<VehicleOptions, 'page' | 'limit' | 'sort'>;
+    options?: Omit<VehicleOptions, "page" | "limit" | "sort">;
     validate(): string[];
     static fromPlain(plain: Record<string, unknown>): VehicleGetUniqueDTO;
     static toPlain(entity: any): Record<string, unknown>;
@@ -24,6 +24,7 @@ export declare class VehicleMetaDataDTO {
     metaDescription?: string;
     metaKeywords?: string;
     vehicleDescription: string;
+    vehicleId: string;
     others?: Record<string, string>;
     validate(): string[];
     static fromPlain(plain: Record<string, unknown>): VehicleMetaDataDTO;
@@ -34,8 +35,10 @@ export declare class VehicleCreateDTO extends BaseCreateDTO {
     model: DynamicModelDTO;
     bodyType: DynamicVehicleBodyTypeDTO;
     vin: string;
+    vehicleSpec: string;
     chassisNumber: string;
     mileage: number;
+    odometer: number;
     fuelType: string;
     color: string;
     engineCapacity: string;
@@ -55,6 +58,8 @@ export declare class VehicleCreateDTO extends BaseCreateDTO {
     status: string;
     features?: string[];
     metaData?: VehicleMetaDataDTO;
+    isDraft?: boolean;
+    pageNo?: number;
     validate(): string[];
     static fromPlain(plain: Record<string, unknown>): VehicleCreateDTO;
     static toPlain(entity: any): Record<string, unknown>;
@@ -82,6 +87,7 @@ export declare class VehicleUpdateDTO extends BaseUpdateDTO {
     doors: number;
     seats: number;
     keys: number;
+    odometer: number;
     wheelsType: string;
     airbags: number;
     transmission: string;
@@ -91,6 +97,8 @@ export declare class VehicleUpdateDTO extends BaseUpdateDTO {
     year: number;
     price: number;
     status: string;
+    isDraft?: boolean;
+    pageNo?: number;
     features: VehicleFeaturesUpdateDTO;
     metaData: VehicleMetaDataDTO;
     validate(): string[];

package/dist/features/vehicle/data/dto/VehicleDTO.js

@@ -26,22 +26,24 @@ class VehicleGetDTO {
                     return [];
                 }
                 const errors = (0, class_validator_1.validateSync)(this);
-                return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+                return errors
+                    .map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); })
+                    .flat();
             };
         }
     }
     static fromPlain(plain) {
         return (0, class_transformer_1.plainToClass)(VehicleGetDTO, plain);
     }
-    static toPlain(entity) {
-        return (0, class_transformer_1.instanceToPlain)(entity);
+    toPlain() {
+        return (0, class_transformer_1.instanceToPlain)(this);
     }
 }
 exports.VehicleGetDTO = VehicleGetDTO;
 class VehicleGetUniqueDTO {
     validate() {
         const errors = (0, class_validator_1.validateSync)(this);
-        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
     }
     static fromPlain(plain) {
         return (0, class_transformer_1.plainToClass)(VehicleGetUniqueDTO, plain);
@@ -54,7 +56,7 @@ exports.VehicleGetUniqueDTO = VehicleGetUniqueDTO;
 class VehicleMetaDataDTO {
     validate() {
         const errors = (0, class_validator_1.validateSync)(this);
-        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
     }
     static fromPlain(plain) {
         return (0, class_transformer_1.plainToClass)(VehicleMetaDataDTO, plain);
@@ -83,6 +85,10 @@ __decorate([
     (0, class_validator_1.IsString)(),
     __metadata("design:type", String)
 ], VehicleMetaDataDTO.prototype, "vehicleDescription", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], VehicleMetaDataDTO.prototype, "vehicleId", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsArray)(),
@@ -127,6 +133,11 @@ __decorate([
     (0, class_validator_1.IsString)(),
     __metadata("design:type", String)
 ], VehicleCreateDTO.prototype, "vin", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], VehicleCreateDTO.prototype, "vehicleSpec", void 0);
 __decorate([
     (0, class_validator_1.IsNotEmpty)(),
     (0, class_validator_1.IsString)(),
@@ -137,6 +148,11 @@ __decorate([
     (0, class_validator_1.IsNumber)(),
     __metadata("design:type", Number)
 ], VehicleCreateDTO.prototype, "mileage", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], VehicleCreateDTO.prototype, "odometer", void 0);
 __decorate([
     (0, class_validator_1.IsNotEmpty)(),
     (0, class_validator_1.IsString)(),
@@ -236,11 +252,19 @@ __decorate([
     (0, class_transformer_1.Type)(() => VehicleMetaDataDTO),
     __metadata("design:type", VehicleMetaDataDTO)
 ], VehicleCreateDTO.prototype, "metaData", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Boolean)
+], VehicleCreateDTO.prototype, "isDraft", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Number)
+], VehicleCreateDTO.prototype, "pageNo", void 0);
 exports.VehicleCreateDTO = VehicleCreateDTO;
 class VehicleFeaturesUpdateDTO {
     validate() {
         const errors = (0, class_validator_1.validateSync)(this);
-        return errors.map(error => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
     }
     static fromPlain(plain) {
         return (0, class_transformer_1.plainToClass)(VehicleFeaturesUpdateDTO, plain);
@@ -351,6 +375,11 @@ __decorate([
     (0, class_validator_1.IsNumber)(),
     __metadata("design:type", Number)
 ], VehicleUpdateDTO.prototype, "keys", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], VehicleUpdateDTO.prototype, "odometer", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsString)(),
@@ -398,6 +427,14 @@ __decorate([
     (0, class_validator_1.IsString)(),
     __metadata("design:type", String)
 ], VehicleUpdateDTO.prototype, "status", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Boolean)
+], VehicleUpdateDTO.prototype, "isDraft", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Number)
+], VehicleUpdateDTO.prototype, "pageNo", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.ValidateNested)(),

package/dist/features/vehicle/data/dto/VehicleFilterDTO.d.ts

@@ -0,0 +1,230 @@
+import { BaseFilter, PaginationOptions, NumberRange } from "../../../../global";
+import { VehicleMake, VehicleModel, Vehicle, VehicleBodyType, VehicleFeature, VehicleFeatureCategory, VehicleMetaData } from "../models";
+import { VehicleCategory } from "../models/VehicleCategory";
+export type VehicleMakeSelectFields = keyof VehicleMake;
+export type VehicleModelSelectFields = keyof VehicleModel;
+export type VehicleSelectFields = keyof Vehicle;
+export type VehicleBodyTypeSelectFields = keyof VehicleBodyType;
+export type VehicleFeatureSelectFields = keyof VehicleFeature;
+export type VehicleCategorySelectFields = keyof VehicleCategory;
+export type VehicleFeatureCategorySelectFields = keyof VehicleFeatureCategory;
+export type VehicleMetaDataSelectFields = keyof VehicleMetaData;
+export declare class VehicleMakeFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    metaKeywords?: string;
+    models?: string | string[];
+    vehicles?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleMakeFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleMakeUniqueFilter extends BaseFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleMakeFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export type VehicleMakeSort = Record<keyof Pick<VehicleMake, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleMakeOptions extends PaginationOptions {
+    sort?: VehicleMakeSort;
+    withModels?: boolean;
+    withVehicles?: boolean;
+    select?: (VehicleMakeSelectFields | `models.${VehicleModelSelectFields}` | `vehicles.${VehicleSelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleMakeOptions;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleModelFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    metaKeywords?: string;
+    makes?: string | string[];
+    vehicles?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleModelUniqueFilter extends BaseFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelUniqueFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export type VehicleModelSort = Record<keyof Pick<VehicleModel, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleModelOptions extends PaginationOptions {
+    sort?: VehicleModelSort;
+    withVehicles?: boolean;
+    withMake?: boolean;
+    select?: (VehicleModelSelectFields | `vehicles.${VehicleSelectFields}` | `make.${VehicleMakeSelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelOptions;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleBodyTypeFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    vehicles?: string | string[];
+    models?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleBodyTypeUniqueFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export type VehicleBodyTypeSort = Record<keyof Pick<VehicleBodyType, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleBodyTypeOptions extends PaginationOptions {
+    sort?: VehicleBodyTypeSort;
+    withVehicles?: boolean;
+    select?: (VehicleBodyTypeSelectFields | `vehicles.${VehicleSelectFields}` | `models.${VehicleModelSelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelOptions;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleFeatureFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    categories?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleFeatureUniqueFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleModelFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export type VehicleFeatureSort = Record<keyof Pick<VehicleFeature, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleFeatureOptions extends PaginationOptions {
+    sort?: VehicleFeatureSort;
+    withCategories?: boolean;
+    select?: (VehicleFeatureSelectFields | `categories.${VehicleCategorySelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFeatureOptions;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleFeatureCategoryFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    features?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFeatureCategoryFilter;
+    static toPlain(entity: VehicleFeatureCategoryFilter): Record<string, unknown>;
+}
+export declare class VehicleFeatureCategoryUniqueFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFeatureCategoryUniqueFilter;
+    static toPlain(entity: VehicleFeatureCategoryUniqueFilter): Record<string, unknown>;
+}
+export type VehicleFeatureCategorySort = Record<keyof Pick<VehicleFeatureCategory, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleFeatureCategoryOptions extends PaginationOptions {
+    sort?: VehicleFeatureCategorySort;
+    withFeatures?: boolean;
+    select?: (VehicleFeatureCategorySelectFields | `features.${VehicleFeatureSelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFeatureCategoryOptions;
+    static toPlain(entity: VehicleFeatureCategoryOptions): Record<string, unknown>;
+}
+export declare class VehicleCategoryFilter extends BaseFilter {
+    id?: string | string[];
+    slug?: string | string[];
+    name?: string;
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryFilter;
+    static toPlain(entity: VehicleCategoryFilter): Record<string, unknown>;
+}
+export declare class VehicleCategoryUniqueFilter {
+    id?: string;
+    slug?: string;
+    name?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleCategoryUniqueFilter;
+    static toPlain(entity: VehicleCategoryUniqueFilter): Record<string, unknown>;
+}
+export type VehicleCategorySort = Record<keyof Pick<VehicleCategory, "name" | "isActive" | "createdAt" | "updatedAt">, "asc" | "desc">;
+export declare class VehicleCategoryOptions extends PaginationOptions {
+    sort?: VehicleCategorySort;
+    select?: (VehicleCategorySelectFields | `features.${VehicleFeatureSelectFields}`)[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFeatureOptions;
+    static toPlain(entity: VehicleCategoryOptions): Record<string, unknown>;
+}
+export declare class VehicleFilter extends BaseFilter {
+    referenceNumber?: string | string[];
+    make?: string | string[];
+    model?: string | string[];
+    bodyType?: string | string[];
+    vin?: string | string[];
+    chassisNumber?: string | string[];
+    mileage?: NumberRange;
+    fuelType?: string | string[];
+    color?: string | string[];
+    engineCapacity?: string | string[];
+    numberOfCylinders?: NumberRange;
+    cylinderCapacity?: NumberRange;
+    doors?: NumberRange;
+    seats?: NumberRange;
+    keys?: NumberRange;
+    wheelsType?: string | string[];
+    airbags?: NumberRange;
+    transmission?: string | string[];
+    driveType?: string | string[];
+    emissions?: string | string[];
+    year?: NumberRange;
+    price?: NumberRange;
+    status?: string | string[];
+    features?: string | string[];
+    search?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export declare class VehicleUniqueFilter {
+    id?: string;
+    referenceNumber?: string;
+    vin?: string;
+    chassisNumber?: string;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleUniqueFilter;
+    static toPlain(entity: any): Record<string, unknown>;
+}
+export type VehicleSort = Record<keyof Pick<Vehicle, "referenceNumber" | "mileage" | "year" | "createdAt" | "updatedAt" | "engineCapacity" | "doors" | "seats" | "keys" | "transmission" | "driveType" | "price" | "status">, "asc" | "desc">;
+export declare class VehicleOptions extends PaginationOptions {
+    sort?: VehicleSort;
+    select?: (VehicleSelectFields | `make.${VehicleMakeSelectFields}` | `model.${VehicleModelSelectFields}` | `bodyType.${VehicleBodyTypeSelectFields}` | `features.${VehicleFeatureSelectFields}` | `metaData.${VehicleMetaDataSelectFields}`)[];
+    withMake?: boolean;
+    withModel?: boolean;
+    withBodyType?: boolean;
+    withFeatures?: boolean;
+    withMetaData?: boolean;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): VehicleOptions;
+    static toPlain(entity: any): Record<string, unknown>;
+}