@nest-omni/core 3.1.1-9 → 3.1.1

package/.hygen/new/module/get-query.ejs.t

@@ -0,0 +1,57 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/queries/<%= h.getQueryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('GetQuery') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ GetQueryName = h.GetQueryName(name);
+ GetHandlerName = h.GetHandlerName(name);
+
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ createDtoFileName = h.createDtoFileName(name);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ TranslationRepositoryName = h.TranslationRepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ translationRepositoryName = h.changeCase.camel(TranslationRepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ TranslationEntityName = h.TranslationEntityName(name);
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ translationRepositoryFileName = h.translationRepositoryFileName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+
+%>import type { ICommand, IQueryHandler } from '@nestjs/cqrs';
+import { QueryHandler } from '@nestjs/cqrs';
+
+import { <%= RepositoryName %> } from '../<%= repositoryFileName %>';
+
+export class <%= GetQueryName %> implements ICommand {
+  constructor(
+    public readonly userId: Uuid,
+  ) {}
+}
+
+@QueryHandler(<%= GetQueryName %>)
+export class <%= GetHandlerName %> implements IQueryHandler<<%= GetQueryName %>> {
+  constructor(private <%= repositoryName %>: <%= RepositoryName %>) {}
+
+  async execute(query: <%= GetQueryName %>) {
+    return this.<%= repositoryName %>.find({
+      userId: query.userId,
+    });
+  }
+}

package/.hygen/new/module/module.ejs.t

@@ -0,0 +1,44 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.moduleFileName(name) %>.ts"
+unless_exists: true
+---
+<%
+
+ ModuleName = h.ModuleName(name);
+ fileName = h.inflection.dasherize(name);
+
+ ControllerName = h.ControllerName(name);
+ controllerFileName = h.controllerFileName(name);
+
+ ServiceName = h.ServiceName(name);
+ serviceFileName = h.serviceFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ repositoryFileName = h.repositoryFileName(name);
+
+ createCommandFileName = h.createCommandFileName(name);
+ getQueryFileName = h.getQueryFileName(name);
+
+%>import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { <%= CreateHandlerName %> } from './commands/<%= createCommandFileName %>';
+import { <%= ControllerName %> } from './<%= controllerFileName %>';
+import { <%= RepositoryName %> } from './<%= repositoryFileName %>';
+import { <%= TranslationRepositoryName %> } from './<%= translationRepositoryFileName %>';
+import { <%= ServiceName %> } from './<%= serviceFileName %>';
+import { <%= GetHandlerName %> } from './queries/<%= getQueryFileName %>';
+
+export const handlers = [
+<%= CreateHandlerName %>,
+<%= GetHandlerName %>,
+];
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([<%= RepositoryName %>, <%= TranslationRepositoryName %>]),
+  ],
+  providers: [<%= ServiceName %>, ...handlers],
+  controllers: [<%= ControllerName %>],
+})
+export class <%= ModuleName %> {}

package/.hygen/new/module/not-found.exception.ejs.t

@@ -0,0 +1,18 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/exceptions/<%= h.notFoundExceptionFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('NotFoundException') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ NotFoundExceptionName = h.NotFoundExceptionName(name);
+
+%>import { NotFoundException } from '@nestjs/common';
+
+export class <%= NotFoundExceptionName %> extends NotFoundException {
+  constructor(error?: string) {
+    super('error.<%= fieldName %>NotFound', error);
+  }
+}

package/.hygen/new/module/page-options.dto.ejs.t

@@ -0,0 +1,12 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.pageOptionsDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('PageOptionsDTO') %>
+---
+<%
+
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+
+%>import { PageOptionsDto } from '@nest-omni/core/common/dto/page-options.dto';
+
+export class <%= PageOptionsDtoName %> extends PageOptionsDto {}

package/.hygen/new/module/prompt.js

@@ -0,0 +1,104 @@
+'use strict'
+
+module.exports = {
+  prompt: ({ prompter, args }) => {
+    return prompter.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Name:',
+        validate(value) {
+          if (!value.length) {
+            return 'Module must have a name.';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'MultiSelect',
+        name: 'blocks',
+        message: 'Blocks:',
+        initial: [
+          'Controller',
+          'CreateCommand',
+          'CreateDTO',
+          'DTO',
+          'Entity',
+          'GetQuery',
+          //'Module',
+          'NotFoundException',
+          'PageOptionsDTO',
+          'Repository',
+          'Service',
+          'TranslationDTO',
+          'TranslationEntity',
+          'TranslationRepository',
+          'UpdateDTO'
+        ],
+        choices: [
+          {
+            name: 'Controller',
+            value: 'controller',
+          },
+          {
+            name: 'CreateCommand',
+            value: 'create-command',
+          },
+          {
+            name: 'CreateDTO',
+            value: 'create-dto',
+          },
+          {
+            name: 'DTO',
+            value: 'dto',
+          },
+          {
+            name: 'Entity',
+            value: 'entity',
+          },
+          {
+            name: 'GetQuery',
+            value: 'get-query',
+          },
+          {
+            name: 'NotFoundException',
+            value: 'not-found-exception',
+          },
+          {
+            name: 'PageOptionsDTO',
+            value: 'page-options-dto',
+          },
+          {
+            name: 'Repository',
+            value: 'repository',
+          },
+          {
+            name: 'Service',
+            value: 'service',
+          },
+          {
+            name: 'TranslationDTO',
+            value: 'translation-dto',
+          },
+          {
+            name: 'TranslationEntity',
+            value: 'translationEntity',
+          },
+          {
+            name: 'TranslationRepository',
+            value: 'translation-repository',
+          },
+          {
+            name: 'UpdateDTO',
+            value: 'update-dto',
+          },
+        ],
+      }
+    ])
+    .then(answer => {
+      //// For debugging
+      // console.log(answer)
+      return answer;
+    })
+  }
+}

package/.hygen/new/module/repository.ejs.t

@@ -0,0 +1,16 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.repositoryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Repository') %>
+---
+<%
+ EntityName = h.EntityName(name);
+ entityFileName = h.entityFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+%>import { EntityRepository, Repository } from 'typeorm';
+
+import { <%= EntityName %> } from './<%= entityFileName %>';
+
+@EntityRepository(<%= EntityName %>)
+export class <%= RepositoryName %> extends Repository<<%= EntityName %>> {}

package/.hygen/new/module/service.ejs.t

@@ -0,0 +1,139 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.serviceFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Service') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+
+
+ CreateCommandName = h.CreateCommandName(name);
+ createCommandFileName = h.createCommandFileName(name);
+
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ ServiceName = h.ServiceName(name);
+
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+
+ fileName = h.fileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ NotFoundExceptionName = h.NotFoundExceptionName(name);
+ notFoundExceptionFileName = h.notFoundExceptionFileName(name);
+
+ createFunctionName = 'create' + ClassName;
+ updateFunctionName = 'update' + ClassName;
+ deleteFunctionName = 'delete' + ClassName;
+ getAllFunctionName = 'getAll' + ClassName;
+ getSingleFunctionName = 'getSingle' + ClassName;
+ controllerName = moduleName + 'Controller';
+ serviceName = moduleName + 'Service';
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoFileName = h.createDtoFileName(name);
+
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+ pageOptionsDtoName = h.changeCase.camel(PageOptionsDtoName);
+ pageOptionsDtoFileName = h.pageOptionsDtoFileName(name);
+
+%>import { Injectable } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { Transactional } from 'typeorm-transactional';
+
+import type { PageDto } from '@nest-omni/core/common/dto/page.dto';
+import { ValidatorService } from '@nest-omni/core/shared/services/validator.service';
+import { <%= CreateCommandName %> } from './commands/<%= createCommandFileName %>';
+import type { <%= DtoName %> } from './dtos/<%= dtoFileName %>';
+import type { <%= PageOptionsDtoName %> } from './dtos/<%= pageOptionsDtoFileName %>';
+import { <%= NotFoundExceptionName %> } from './exceptions/<%= notFoundExceptionFileName %>';
+import type { <%= EntityName %> } from './<%= entityFileName %>';
+import { <%= RepositoryName %> } from './<%= repositoryFileName %>';
+import { <%= CreateDtoName %> } from './dtos/<%= createDtoFileName %>';
+import type { <%= UpdateDtoName %> } from './dtos/<%= updateDtoFileName %>';
+
+@Injectable()
+export class <%= ServiceName %> {
+  constructor(
+    private <%= repositoryName %>: <%= RepositoryName %>,
+    private validatorService: ValidatorService,
+    private commandBus: CommandBus,
+  ) {}
+
+  @Transactional()
+  <%= createFunctionName %>(<%= createDtoName %>: <%= CreateDtoName %>): Promise<<%= EntityName %>> {
+    return this.commandBus.execute<<%= CreateCommandName %>, <%= EntityName %>>(
+      new <%= CreateCommandName %>(<%= createDtoName %>),
+    );
+  }
+
+  async <%= getAllFunctionName %>(
+    <%= pageOptionsDtoName %>: <%= PageOptionsDtoName %>,
+  ): Promise<PageDto<<%= DtoName %>>> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .leftJoinAndSelect('<%= fieldName %>.translations', '<%= fieldName %>Translation');
+    const [items, pageMetaDto] = await queryBuilder.paginate(<%= pageOptionsDtoName %>);
+
+    return items.toPageDto(pageMetaDto);
+  }
+
+  async <%= getSingleFunctionName %>(id: Uuid): Promise<<%= EntityName %>> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    return <%= entityName %>;
+  }
+
+  async <%= updateFunctionName %>(
+    id: Uuid,
+    <%= updateDtoName %>: <%= UpdateDtoName %>,
+  ): Promise<void> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    this.<%= repositoryName %>.merge(<%= entityName %>, <%= updateDtoName %>);
+
+    await this.<%= repositoryName %>.save(<%= updateDtoName %>);
+  }
+
+  async <%= deleteFunctionName %>(id: Uuid): Promise<void> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    await this.<%= repositoryName %>.remove(<%= entityName %>);
+  }
+}

package/.hygen/new/module/translation-dto.ejs.t

@@ -0,0 +1,27 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.translationDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationDTO') %>
+---
+<%
+
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+
+%>import { AbstractTranslationDto } from '@nest-omni/core/common/dto/abstract.dto';
+import { LanguageCode } from '../../../constants';
+import { ApiEnumPropertyOptional } from '../@nest-omni/core/decorators';
+import type { <%= TranslationEntityName %> } from '../<%= translationEntityFileName %>';
+
+export class <%= TranslationDtoName %> extends AbstractTranslationDto {
+  @ApiEnumPropertyOptional(() => LanguageCode)
+  languageCode: LanguageCode;
+
+  constructor(<%= translationEntityName %>: <%= TranslationEntityName %>) {
+    super(<%= translationEntityName %>);
+
+    this.languageCode = <%= translationEntityName %>.languageCode;
+  }
+}

package/.hygen/new/module/translation-entity.ejs.t

@@ -0,0 +1,40 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.translationEntityFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationEntity') %>
+---
+<%
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+ translationDtoFileName = h.translationDtoFileName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ var_name = h.inflection.dasherize(name);
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ TranslationEntityName = h.TranslationEntityName(name);
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+%>import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+
+import { AbstractTranslationEntity } from '@nest-omni/core/common/abstract.entity';
+import { UseDto } from '@nest-omni/core/decorators';
+import { <%= TranslationDtoName %> } from './dtos/<%= translationDtoFileName %>';
+import { <%= EntityName %> } from './<%= entityFileName %>';
+
+@Entity({ name: '<%= var_name %>_translations' })
+@UseDto(<%= TranslationDtoName %>)
+export class <%= TranslationEntityName %> extends AbstractTranslationEntity<<%= TranslationDtoName %>> {
+  @Column({ type: 'uuid' })
+  <%= fieldName %>Id: Uuid;
+
+  @ManyToOne(() => <%= EntityName %>, (<%= entityName %>) => <%= entityName %>.translations, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: '<%= var_name %>_id' })
+  <%= fieldName %>: <%= EntityName %>;
+}
+

package/.hygen/new/module/translation-repository.ejs.t

@@ -0,0 +1,16 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.translationRepositoryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationRepository') %>
+---
+<%
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+
+ TranslationRepositoryName = h.TranslationRepositoryName(name);
+%>import { EntityRepository, Repository } from 'typeorm';
+
+import { <%= TranslationEntityName %> } from './<%= translationEntityFileName %>';
+
+@EntityRepository(<%= TranslationEntityName %>)
+export class <%= TranslationRepositoryName %> extends Repository<<%= TranslationEntityName %>> {}

package/.hygen/new/module/update.dto.ejs.t

@@ -0,0 +1,10 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.updateDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('UpdateDTO') %>
+---
+<%
+
+UpdateDtoName = h.UpdateDtoName(name);
+
+%>export class <%= UpdateDtoName %> {}

package/.hygen.js

@@ -0,0 +1,116 @@
+module.exports = {
+  templates: `${__dirname}/.hygen`,
+  helpers: {
+    ControllerName(name) {
+      return `${this.ClassName(name)}Controller`;
+    },
+    ServiceName(name) {
+      return `${this.ClassName(name)}Service`;
+    },
+    ModuleName(name) {
+      return `${this.ClassName(name)}Module`;
+    },
+    DtoName(name) {
+      return `${this.ClassName(name)}Dto`;
+    },
+    TranslationDtoName(name) {
+      return `${this.ClassName(name)}TranslationDto`;
+    },
+    UpdateDtoName(name) {
+      return `Update${this.DtoName(name)}`;
+    },
+    DtoOptionName(name) {
+      return `I${this.DtoName(name)}Options`;
+    },
+    CreateDtoName(name) {
+      return `Create${this.DtoName(name)}`;
+    },
+    EntityName(name) {
+      return `${this.ClassName(name)}Entity`;
+    },
+    TranslationEntityName(name) {
+      return `${this.ClassName(name)}TranslationEntity`;
+    },
+    CreateCommandName(name) {
+      return `Create${this.ClassName(name)}Command`;
+    },
+    CreateHandlerName(name) {
+      return `Create${this.ClassName(name)}Handler`;
+    },
+    GetHandlerName(name) {
+      return `Get${this.ClassName(name)}Handler`;
+    },
+    GetQueryName(name) {
+      return `Get${this.ClassName(name)}Query`;
+    },
+    PageOptionsDtoName(name) {
+      return this.ClassName(name) + 'PageOptionsDto';
+    },
+    NotFoundExceptionName(name) {
+      return this.ClassName(name) + 'NotFoundException';
+    },
+    entityFileName(name) {
+      return `${this.fileName(name)}.entity`;
+    },
+    translationEntityFileName(name) {
+      return `${this.fileName(name)}-translation.entity`;
+    },
+    translationDtoFileName(name) {
+      return `${this.fileName(name)}-translation.dto`;
+    },
+    repositoryFileName(name) {
+      return `${this.fileName(name)}.repository`;
+    },
+    translationRepositoryFileName(name) {
+      return `${this.fileName(name)}-translation.repository`;
+    },
+    createCommandFileName(name) {
+      return `create-${this.fileName(name)}.command`;
+    },
+    getQueryFileName(name) {
+      return `get-${this.fileName(name)}.query`;
+    },
+    controllerFileName(name) {
+      return `${this.fileName(name)}.controller`;
+    },
+    dtoFileName(name) {
+      return `${this.fileName(name)}.dto`;
+    },
+    notFoundExceptionFileName(name) {
+      return `${this.fileName(name)}-not-found.exception`;
+    },
+    createDtoFileName(name) {
+      return `create-${this.fileName(name)}.dto`;
+    },
+    updateDtoFileName(name) {
+      return `update-${this.fileName(name)}.dto`;
+    },
+    pageOptionsDtoFileName(name) {
+      return `${this.fileName(name)}-page-options.dto`;
+    },
+    serviceFileName(name) {
+      return `${this.fileName(name)}.service`;
+    },
+    moduleFileName(name) {
+      return `${this.fileName(name)}.module`;
+    },
+    ClassName(name) {
+      return this.changeCase.pascal(name);
+    },
+    TableName(name) {
+      return this.inflection.underscore(this.ClassName(name));
+    },
+    RepositoryName(name) {
+      return `${this.ClassName(name)}Repository`;
+    },
+    TranslationRepositoryName(name) {
+      return `${this.ClassName(name)}TranslationRepository`;
+    },
+    moduleName(name) {
+      return this.changeCase.camel(name);
+    },
+    fileName(name) {
+      return this.inflection.dasherize(name).toLowerCase();
+    },
+  },
+}

package/cache/cache-metrics.service.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter } from 'events';
+export interface CacheOperationRecord {
+    type: 'get' | 'set' | 'delete' | 'clear';
+    layer: string;
+    hit: boolean;
+    latency: number;
+    error?: string;
+    key?: string;
+    timestamp: Date;
+}
+export interface CacheMetrics {
+    totalOperations: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    avgLatency: number;
+    minLatency: number;
+    maxLatency: number;
+    p95Latency: number;
+    p99Latency: number;
+    gets: number;
+    sets: number;
+    deletes: number;
+    clears: number;
+    totalKeys: number;
+    totalSize: number;
+    errors: number;
+    errorRate: number;
+    layerMetrics: {
+        cls: {
+            hits: number;
+            misses: number;
+            avgLatency: number;
+        };
+        memory: {
+            hits: number;
+            misses: number;
+            avgLatency: number;
+            size: number;
+        };
+        redis: {
+            hits: number;
+            misses: number;
+            avgLatency: number;
+        };
+    };
+    timeWindow: {
+        start: Date;
+        end: Date;
+        duration: number;
+    };
+}
+export declare class CacheMetricsService extends EventEmitter {
+    private readonly logger;
+    private readonly operations;
+    private readonly maxOperations;
+    private readonly maxAge;
+    constructor();
+    recordOperation(type: 'get' | 'set' | 'delete' | 'clear', layer: string, hit: boolean, latency: number, error?: string, key?: string): void;
+    getMetrics(timeWindowMs?: number): CacheMetrics;
+    getSnapshot(): Partial<CacheMetrics>;
+    getSlowOperations(limit?: number): CacheOperationRecord[];
+    getMostAccessedKeys(limit?: number): {
+        key: string;
+        count: number;
+        avgLatency: number;
+    }[];
+    getErrorBreakdown(): {
+        error: string;
+        count: number;
+        lastOccurrence: Date;
+    }[];
+    resetMetrics(): void;
+    exportMetrics(format?: 'prometheus' | 'json'): string;
+    private cleanupOldRecords;
+    private createEmptyMetrics;
+    private calculateLayerMetrics;
+    private average;
+    private percentile;
+    private getUniqueKeyCount;
+    private estimateTotalSize;
+    private toPrometheusFormat;
+}