@merkaly/api 0.1.11 → 0.2.0

package/.output/app.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.d.ts.map

package/.output/config/app.config.d.ts

@@ -0,0 +1,28 @@
+import { HttpModuleOptions } from '@nestjs/axios/dist/interfaces';
+import { ElasticsearchModuleOptions } from '@nestjs/elasticsearch';
+import { TypeOrmModuleOptions } from '@nestjs/typeorm/dist/interfaces/typeorm-options.interface';
+export declare abstract class AppConfig {
+    static get elasticsearch(): ElasticsearchModuleOptions;
+    static get axios(): HttpModuleOptions;
+    static get auth0(): {
+        domain: string;
+        audience: string;
+        client: string;
+        secret: string;
+        realm: string;
+    };
+    static get sentry(): {
+        dsn: string;
+        debug: boolean;
+        environment: string;
+    };
+    static get server(): {
+        port: string | number;
+        name: string;
+        description: string;
+        version: string;
+        tenant: string;
+    };
+    static get database(): TypeOrmModuleOptions;
+}
+//# sourceMappingURL=app.config.d.ts.map

package/.output/config/app.controller.d.ts

@@ -0,0 +1,11 @@
+import { Id, SearchResponse } from '@elastic/elasticsearch/lib/api/types';
+import { AppEntity } from './app.entity';
+import { SearchQuery } from './app.validator';
+export declare abstract class AppController<E extends AppEntity> {
+    abstract find(validator?: SearchQuery): Promise<SearchResponse<E>>;
+    abstract read(id: Id): Promise<unknown>;
+    abstract create(validator: unknown): Promise<unknown>;
+    abstract update(id: Id, validator: unknown): Promise<unknown>;
+    abstract delete(id: Id): Promise<void>;
+}
+//# sourceMappingURL=app.controller.d.ts.map

package/.output/config/app.document.d.ts

@@ -0,0 +1,12 @@
+import { EntityManager } from 'typeorm';
+import { AppEntity } from './app.entity';
+export declare abstract class AppDocument<E extends AppEntity> {
+    protected $id: string;
+    protected $updatedAt: Date;
+    protected $createdAt: Date;
+    protected $deletedAt: Date;
+    protected $manager: EntityManager;
+    serialize(entity: E): this;
+    protected abstract transform(entity: E): this;
+}
+//# sourceMappingURL=app.document.d.ts.map

package/.output/config/app.entity.d.ts

@@ -0,0 +1,9 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+export declare abstract class AppEntity {
+    constructor(id?: Id);
+    readonly id: Id;
+    readonly createdAt: Date;
+    readonly updatedAt?: Date;
+    readonly deletedAt?: Date;
+}
+//# sourceMappingURL=app.entity.d.ts.map

package/.output/config/app.exception.d.ts

@@ -0,0 +1,11 @@
+import { ArgumentsHost, ExceptionFilter, HttpException, Logger } from '@nestjs/common';
+import { Request, Response } from 'express';
+export declare abstract class AppException implements ExceptionFilter {
+    protected request: Request;
+    protected response: Response;
+    protected host: ArgumentsHost;
+    protected logger: Logger;
+    catch(exception: HttpException, host: ArgumentsHost): HttpException | Response<any, Record<string, any>>;
+    protected abstract handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=app.exception.d.ts.map

package/.output/config/app.middleware.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function LoggerMiddleware(request: Request, response: Response, next: NextFunction): Promise<void>;
+//# sourceMappingURL=app.middleware.d.ts.map

package/.output/config/app.module.d.ts

@@ -0,0 +1,6 @@
+import { MiddlewareConsumer, ModuleMetadata, NestModule } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export declare class AppModule implements NestModule {
+    configure(consumer: MiddlewareConsumer): MiddlewareConsumer;
+}
+//# sourceMappingURL=app.module.d.ts.map

package/.output/config/app.repository.d.ts

@@ -0,0 +1,24 @@
+import { GetResponse, Id } from '@elastic/elasticsearch/lib/api/types';
+import { Logger, OnModuleInit } from '@nestjs/common';
+import { ElasticsearchService } from '@nestjs/elasticsearch';
+import { Repository } from 'typeorm';
+import { AppDocument } from './app.document';
+import { AppEntity } from './app.entity';
+import { AppValidator, SearchQuery } from './app.validator';
+export declare abstract class AppRepository<E extends AppEntity, D extends AppDocument<E> = AppDocument<E>> implements OnModuleInit {
+    protected readonly $elastic: ElasticsearchService;
+    protected readonly $logger: typeof Logger;
+    protected abstract $document: D;
+    protected abstract repository: Repository<E>;
+    onModuleInit(): Promise<import("@elastic/elasticsearch/lib/api/types").IndicesResponseBase | import("@elastic/elasticsearch/lib/api/types").IndicesCreateResponse>;
+    protected get $index(): string;
+    protected get $routing(): string;
+    find(search?: SearchQuery): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<E, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    create(validator: AppValidator<any>): Promise<GetResponse<D>>;
+    read(id: Id): Promise<GetResponse<D>>;
+    update(id: Id, validator: AppValidator<any>): Promise<GetResponse<D>>;
+    delete(id: Id): Promise<void>;
+    protected $create(id: Id, document: AppDocument<AppEntity>): Promise<GetResponse<D>>;
+    protected $update(id: Id, doc: AppDocument<AppEntity>): Promise<GetResponse<D>>;
+}
+//# sourceMappingURL=app.repository.d.ts.map

package/.output/config/app.router.d.ts

@@ -0,0 +1,6 @@
+export declare class AppRouter {
+    static readonly path: string;
+    static readonly module: typeof AppRouter;
+    static readonly children?: any[];
+}
+//# sourceMappingURL=app.router.d.ts.map

package/.output/config/app.validator.d.ts

@@ -0,0 +1,7 @@
+import { SearchRequest } from '@elastic/elasticsearch/lib/api/types';
+import { AppEntity } from './app.entity';
+export declare abstract class AppValidator<E extends AppEntity> {
+    abstract toEntity(...variadic: unknown[]): E;
+}
+export declare type SearchQuery = Omit<SearchRequest, 'index' | 'routing'>;
+//# sourceMappingURL=app.validator.d.ts.map

package/.output/src/auth/auth.controller.d.ts

@@ -0,0 +1,9 @@
+import { ObjectWithId, TokenResponse, User as Auth0User } from 'auth0';
+import { AuthRepository } from './auth.repository';
+import { LoginValidator } from './auth.validator';
+export declare class AuthController {
+    protected readonly authRepository: AuthRepository;
+    login({ username, password }: LoginValidator): Promise<Partial<TokenResponse>>;
+    user(user: ObjectWithId['id']): Promise<Auth0User>;
+}
+//# sourceMappingURL=auth.controller.d.ts.map

package/.output/src/auth/auth.decorator.d.ts

@@ -0,0 +1,5 @@
+import { CustomDecorator } from '@nestjs/common';
+export declare const IS_PUBLIC_KEY = "isPublic";
+export declare const Public: () => CustomDecorator;
+export declare const User: (...dataOrPipes: unknown[]) => ParameterDecorator;
+//# sourceMappingURL=auth.decorator.d.ts.map

package/.output/src/auth/auth.guard.d.ts

@@ -0,0 +1,16 @@
+import { ExecutionContext } from '@nestjs/common';
+import { AuthRepository } from './auth.repository';
+declare module 'express' {
+    interface Request {
+        user?: string;
+    }
+}
+declare const AuthGuard_base: import("@nestjs/passport").Type<import("@nestjs/passport").IAuthGuard>;
+export declare class AuthGuard extends AuthGuard_base {
+    protected readonly authRepository: AuthRepository;
+    private reflector;
+    canActivate(context: ExecutionContext): Promise<any>;
+    handleRequest(err: Record<string, unknown>, user: string): any;
+}
+export {};
+//# sourceMappingURL=auth.guard.d.ts.map

package/.output/src/auth/auth.module.d.ts

@@ -0,0 +1,9 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../config/app.router';
+export declare const metadata: ModuleMetadata;
+export declare class AuthModule extends AppRouter {
+    static readonly path = "/auth";
+    static readonly module: typeof AuthModule;
+    static readonly children: any[];
+}
+//# sourceMappingURL=auth.module.d.ts.map

package/.output/src/auth/auth.repository.d.ts

@@ -0,0 +1,11 @@
+import { OnModuleInit } from '@nestjs/common';
+import { AuthenticationClient, ManagementClient, ObjectWithId, User } from 'auth0';
+export declare class AuthRepository implements OnModuleInit {
+    $management: ManagementClient;
+    private readonly jwtService;
+    private readonly axios;
+    get client(): AuthenticationClient;
+    onModuleInit(): Promise<ManagementClient>;
+    getUser(id: ObjectWithId['id']): Promise<User>;
+}
+//# sourceMappingURL=auth.repository.d.ts.map

package/.output/src/auth/auth.strategy.d.ts

@@ -0,0 +1,18 @@
+import { Strategy, StrategyOptions } from 'passport-jwt';
+export declare const strategy: StrategyOptions;
+interface DecodedUser {
+    iss: string;
+    sub: string;
+    aud: string[];
+    iat: number;
+    exp: number;
+    azp: string;
+    scope: string;
+}
+declare const AuthStrategy_base: new (...args: any[]) => Strategy;
+export declare class AuthStrategy extends AuthStrategy_base {
+    constructor();
+    validate({ sub }: DecodedUser): string;
+}
+export {};
+//# sourceMappingURL=auth.strategy.d.ts.map

package/.output/src/inventory/brands/brand.controller.d.ts

@@ -0,0 +1,15 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import { AppController } from '../../../config/app.controller';
+import { SearchQuery } from '../../../config/app.validator';
+import { BrandEntity } from './brand.entity';
+import { BrandRepository } from './brand.repository';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+export declare class BrandController extends AppController<BrandEntity> {
+    protected readonly repository: BrandRepository;
+    find(validator?: SearchQuery): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<BrandEntity, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    read(id: Id): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<BrandEntity>>>;
+    create(validator: CreateBrandValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<BrandEntity>>>;
+    update(id: Id, validator: UpdateBrandValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<BrandEntity>>>;
+    delete(id: Id): Promise<void>;
+}
+//# sourceMappingURL=brand.controller.d.ts.map

package/.output/src/inventory/brands/brand.document.d.ts

@@ -0,0 +1,8 @@
+import { AppDocument } from '../../../config/app.document';
+import { BrandEntity } from './brand.entity';
+export declare class BrandDocument extends AppDocument<BrandEntity> {
+    name: string;
+    description: string;
+    protected transform(entity: BrandEntity): this;
+}
+//# sourceMappingURL=brand.document.d.ts.map

package/{src → .output/src}/inventory/brands/brand.entity.d.ts

@@ -1,4 +1,4 @@
-import { AppEntity } from '@/config/app.entity';
+import { AppEntity } from '../../../config/app.entity';
 import { ProductEntity } from '../products/product.entity';
 export declare class BrandEntity extends AppEntity {
     name: string;

package/.output/src/inventory/brands/brand.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+import { AppException } from '../../../config/app.exception';
+export declare class BrandException extends AppException {
+    handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=brand.exception.d.ts.map

package/.output/src/inventory/brands/brand.module.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../../config/app.router';
+export declare const metadata: ModuleMetadata;
+export declare class BrandModule extends AppRouter {
+    static readonly path = "/brands";
+    static readonly module: typeof BrandModule;
+}
+//# sourceMappingURL=brand.module.d.ts.map

package/.output/src/inventory/brands/brand.repository.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { AppRepository } from '../../../config/app.repository';
+import { BrandDocument } from './brand.document';
+import { BrandEntity } from './brand.entity';
+export declare class BrandRepository extends AppRepository<BrandEntity> {
+    protected repository: Repository<BrandEntity>;
+    protected $document: BrandDocument;
+}
+//# sourceMappingURL=brand.repository.d.ts.map

package/.output/src/inventory/brands/brand.validator.d.ts

@@ -0,0 +1,13 @@
+import { AppValidator } from '../../../config/app.validator';
+import { BrandEntity } from './brand.entity';
+export declare class CreateBrandValidator extends AppValidator<BrandEntity> {
+    name: string;
+    description?: string;
+    toEntity(): BrandEntity;
+}
+export declare class UpdateBrandValidator extends AppValidator<BrandEntity> {
+    name?: string;
+    description?: string;
+    toEntity(entity: BrandEntity): BrandEntity;
+}
+//# sourceMappingURL=brand.validator.d.ts.map

package/.output/src/inventory/categories/category.controller.d.ts

@@ -0,0 +1,12 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import { CategoryRepository } from './category.repository';
+import { CreateCategoryValidator, FindCategoryValidator, UpdateCategoryValidator } from './category.validator';
+export declare class CategoryController {
+    protected readonly repository: CategoryRepository;
+    find(validator?: FindCategoryValidator): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<import("./category.entity").CategoryEntity, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    read(id: Id): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<import("./category.entity").CategoryEntity>>>;
+    create(validator: CreateCategoryValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<import("./category.entity").CategoryEntity>>>;
+    update(id: Id, validator: UpdateCategoryValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<import("./category.entity").CategoryEntity>>>;
+    delete(id: Id): Promise<void>;
+}
+//# sourceMappingURL=category.controller.d.ts.map

package/.output/src/inventory/categories/category.document.d.ts

@@ -0,0 +1,8 @@
+import { AppDocument } from '../../../config/app.document';
+import { CategoryEntity } from './category.entity';
+export declare class CategoryDocument extends AppDocument<CategoryEntity> {
+    name: string;
+    description: string;
+    protected transform(entity: CategoryEntity): this;
+}
+//# sourceMappingURL=category.document.d.ts.map

package/{src → .output/src}/inventory/categories/category.entity.d.ts

@@ -1,10 +1,8 @@
-import { AppEntity } from '@/config/app.entity';
+import { AppEntity } from '../../../config/app.entity';
 import { ProductEntity } from '../products/product.entity';
-import { PropertyEntity } from '../properties/property.entity';
 export declare class CategoryEntity extends AppEntity {
     name: string;
     description: string;
     products: ProductEntity[];
-    properties: PropertyEntity[];
 }
 //# sourceMappingURL=category.entity.d.ts.map

package/.output/src/inventory/categories/category.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+import { AppException } from '../../../config/app.exception';
+export declare class CategoryException extends AppException {
+    handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=category.exception.d.ts.map

package/.output/src/inventory/categories/category.module.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../../config/app.router';
+export declare const metadata: ModuleMetadata;
+export declare class CategoryModule extends AppRouter {
+    static readonly path = "/categories";
+    static readonly module: typeof CategoryModule;
+}
+//# sourceMappingURL=category.module.d.ts.map

package/.output/src/inventory/categories/category.repository.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { AppRepository } from '../../../config/app.repository';
+import { CategoryDocument } from './category.document';
+import { CategoryEntity } from './category.entity';
+export declare class CategoryRepository extends AppRepository<CategoryEntity> {
+    protected repository: Repository<CategoryEntity>;
+    protected $document: CategoryDocument;
+}
+//# sourceMappingURL=category.repository.d.ts.map

package/.output/src/inventory/categories/category.validator.d.ts

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+import { AppValidator } from '../../../config/app.validator';
+import { CategoryEntity } from './category.entity';
+export declare class FindCategoryValidator {
+}
+export declare class CreateCategoryValidator extends AppValidator<CategoryEntity> {
+    name: string;
+    description?: string;
+    toEntity(): CategoryEntity;
+}
+export declare class UpdateCategoryValidator extends AppValidator<CategoryEntity> {
+    name: string;
+    description?: string;
+    toEntity(entity: CategoryEntity): CategoryEntity;
+}
+//# sourceMappingURL=category.validator.d.ts.map

package/.output/src/inventory/inventory.module.d.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../config/app.router';
+import { BrandModule } from './brands/brand.module';
+import { CategoryModule } from './categories/category.module';
+import { MediaModule } from './media/media.module';
+import { ProductModule } from './products/product.module';
+import { VariantModule } from './variants/variant.module';
+export declare const metadata: ModuleMetadata;
+export declare class InventoryModule extends AppRouter {
+    static readonly path = "/inventory";
+    static readonly module: typeof InventoryModule;
+    static readonly children: (typeof BrandModule | typeof CategoryModule | typeof MediaModule | typeof ProductModule | typeof VariantModule)[];
+}
+//# sourceMappingURL=inventory.module.d.ts.map

package/.output/src/inventory/media/media.controller.d.ts

@@ -0,0 +1,6 @@
+import { MediaRepository } from './media.repository';
+export declare class MediaController {
+    protected readonly repository: MediaRepository;
+    find(): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<import("./media.entity").MediaEntity, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+}
+//# sourceMappingURL=media.controller.d.ts.map

package/.output/src/inventory/media/media.document.d.ts

@@ -0,0 +1,8 @@
+import { AppDocument } from '../../../config/app.document';
+import { MediaEntity } from './media.entity';
+export declare class MediaDocument extends AppDocument<MediaEntity> {
+    name: string;
+    url: string;
+    protected transform(entity: MediaEntity): this;
+}
+//# sourceMappingURL=media.document.d.ts.map

package/.output/src/inventory/media/media.entity.d.ts

@@ -0,0 +1,8 @@
+import { AppEntity } from '../../../config/app.entity';
+import { ProductEntity } from '../products/product.entity';
+export declare class MediaEntity extends AppEntity {
+    name: string;
+    url: string;
+    product?: ProductEntity;
+}
+//# sourceMappingURL=media.entity.d.ts.map

package/.output/src/inventory/media/media.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+import { AppException } from '../../../config/app.exception';
+export declare class MediaException extends AppException {
+    handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=media.exception.d.ts.map

package/.output/src/inventory/media/media.module.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../../config/app.router';
+export declare const metadata: ModuleMetadata;
+export declare class MediaModule extends AppRouter {
+    static readonly path = "/media";
+    static readonly module: typeof MediaModule;
+}
+//# sourceMappingURL=media.module.d.ts.map

package/.output/src/inventory/media/media.repository.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { AppRepository } from '../../../config/app.repository';
+import { MediaDocument } from './media.document';
+import { MediaEntity } from './media.entity';
+export declare class MediaRepository extends AppRepository<MediaEntity> {
+    protected repository: Repository<MediaEntity>;
+    protected $document: MediaDocument;
+}
+//# sourceMappingURL=media.repository.d.ts.map

package/.output/src/inventory/media/media.validator.d.ts

@@ -0,0 +1,12 @@
+import 'reflect-metadata';
+import { AppValidator } from '../../../config/app.validator';
+import { MediaEntity } from './media.entity';
+export declare class CreateMediaValidator extends AppValidator<MediaEntity> {
+    name: string;
+    toEntity(): MediaEntity;
+}
+export declare class UpdateMediaValidator extends AppValidator<MediaEntity> {
+    name: string;
+    toEntity(entity: MediaEntity): MediaEntity;
+}
+//# sourceMappingURL=media.validator.d.ts.map

package/.output/src/inventory/products/product.controller.d.ts

@@ -0,0 +1,14 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import { AppController } from '../../../config/app.controller';
+import { ProductEntity } from './product.entity';
+import { ProductRepository } from './product.repository';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+export declare class ProductController extends AppController<ProductEntity> {
+    protected readonly repository: ProductRepository;
+    find(): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<ProductEntity, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    create(validator: CreateProductValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<ProductEntity>>>;
+    read(id: Id): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<ProductEntity>>>;
+    update(id: Id, validator: UpdateProductValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<ProductEntity>>>;
+    delete(id: Id): Promise<void>;
+}
+//# sourceMappingURL=product.controller.d.ts.map

package/.output/src/inventory/products/product.document.d.ts

@@ -0,0 +1,13 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import { AppDocument } from '../../../config/app.document';
+import { ProductEntity } from './product.entity';
+export declare class ProductDocument extends AppDocument<ProductEntity> {
+    name: string;
+    description: string;
+    availableFrom: Date;
+    active: boolean;
+    category: Id;
+    brand: Id;
+    protected transform(entity: ProductEntity): this;
+}
+//# sourceMappingURL=product.document.d.ts.map

package/{src → .output/src}/inventory/products/product.entity.d.ts

@@ -1,8 +1,7 @@
-import { AppEntity } from '@/config/app.entity';
+import { AppEntity } from '../../../config/app.entity';
 import { BrandEntity } from '../brands/brand.entity';
 import { CategoryEntity } from '../categories/category.entity';
 import { MediaEntity } from '../media/media.entity';
-import { PropertyEntity } from '../properties/property.entity';
 import { VariantEntity } from '../variants/variant.entity';
 export declare class ProductEntity extends AppEntity {
     name: string;
@@ -12,7 +11,6 @@ export declare class ProductEntity extends AppEntity {
     hashtags: string[];
     category?: CategoryEntity;
     brand?: BrandEntity;
-    properties: PropertyEntity[];
     variant: VariantEntity;
     variants: VariantEntity[];
     media: MediaEntity[];

package/.output/src/inventory/products/product.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+import { AppException } from '../../../config/app.exception';
+export declare class ProductException extends AppException {
+    handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=product.exception.d.ts.map

package/.output/src/inventory/products/product.module.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { AppRouter } from '../../../config/app.router';
+export declare const metadata: ModuleMetadata;
+export declare class ProductModule extends AppRouter {
+    static readonly path = "/products";
+    static readonly module: typeof ProductModule;
+}
+//# sourceMappingURL=product.module.d.ts.map

package/.output/src/inventory/products/product.repository.d.ts

@@ -0,0 +1,11 @@
+import { Repository } from 'typeorm';
+import { AppRepository } from '../../../config/app.repository';
+import { ProductDocument } from './product.document';
+import { ProductEntity } from './product.entity';
+import { CreateProductValidator } from './product.validator';
+export declare class ProductRepository extends AppRepository<ProductEntity> {
+    protected repository: Repository<ProductEntity>;
+    protected $document: ProductDocument;
+    create(validator: CreateProductValidator): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<ProductEntity>>>;
+}
+//# sourceMappingURL=product.repository.d.ts.map

package/.output/src/inventory/products/product.validator.d.ts

@@ -0,0 +1,26 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import 'reflect-metadata';
+import { AppValidator } from '../../../config/app.validator';
+import { CreateVariantValidator } from '../variants/variant.validator';
+import { ProductEntity } from './product.entity';
+export declare class CreateProductValidator extends AppValidator<ProductEntity> {
+    name: string;
+    description?: string;
+    availableFrom: Date;
+    active: boolean;
+    category?: Id;
+    brand?: Id;
+    hashtags: string[];
+    variants: CreateVariantValidator[];
+    toEntity(): ProductEntity;
+}
+export declare class UpdateProductValidator extends AppValidator<ProductEntity> {
+    name?: string;
+    description?: string;
+    category?: Id;
+    brand?: Id;
+    hashtags?: string[];
+    active: boolean;
+    toEntity(entity: ProductEntity): ProductEntity;
+}
+//# sourceMappingURL=product.validator.d.ts.map

package/.output/src/inventory/variants/variant.controller.d.ts

@@ -0,0 +1,9 @@
+import { Id } from '@elastic/elasticsearch/lib/api/types';
+import { SearchQuery } from '../../../config/app.validator';
+import { VariantRepository } from './variant.repository';
+export declare class VariantController {
+    protected readonly repository: VariantRepository;
+    find(search?: SearchQuery): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<import("./variant.entity").VariantEntity, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    read(id: Id): Promise<import("@elastic/elasticsearch/lib/api/types").GetResponse<import("../../../config/app.document").AppDocument<import("./variant.entity").VariantEntity>>>;
+}
+//# sourceMappingURL=variant.controller.d.ts.map

package/.output/src/inventory/variants/variant.document.d.ts

@@ -0,0 +1,10 @@
+import { AppDocument } from '../../../config/app.document';
+import { VariantEntity } from './variant.entity';
+export declare class VariantDocument extends AppDocument<VariantEntity> {
+    sku: string;
+    quantity: number;
+    price: number;
+    active: boolean;
+    protected transform(entity: VariantEntity): this;
+}
+//# sourceMappingURL=variant.document.d.ts.map

package/{src → .output/src}/inventory/variants/variant.entity.d.ts

@@ -1,8 +1,8 @@
-import { AppEntity } from '@/config/app.entity';
+import { AppEntity } from '../../../config/app.entity';
 import { ProductEntity } from '../products/product.entity';
 export declare class VariantEntity extends AppEntity {
-    price: number;
     sku: string;
+    price: number;
     quantity: number;
     active: boolean;
     product: ProductEntity;

package/.output/src/inventory/variants/variant.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+import { AppException } from '../../../config/app.exception';
+export declare class VariantException extends AppException {
+    handleError(exception: HttpException): HttpException;
+}
+//# sourceMappingURL=variant.exception.d.ts.map