@bgord/bun 0.1.0

package/dist/image-exif.d.ts

@@ -0,0 +1,18 @@
+import sharp from "sharp";
+import path from "node:path";
+import * as Schema from "./schema";
+import { MimeRawType } from "./mime";
+export type ImageExifOutputType = {
+    width: Schema.WidthType;
+    height: Schema.HeightType;
+    name: path.ParsedPath["base"];
+    mimeType: MimeRawType;
+};
+export type ImageExifClearConfigType = {
+    input: Schema.PathType;
+    output: Schema.PathType;
+};
+export declare class ImageEXIF {
+    static read(input: Schema.PathType): Promise<ImageExifOutputType>;
+    static clear(config: ImageExifClearConfigType): Promise<sharp.OutputInfo>;
+}

package/dist/image-resizer.d.ts

@@ -0,0 +1,16 @@
+import sharp from "sharp";
+import * as Schema from "./schema";
+export type ImageResizerWidthConfigType = {
+    input: Schema.PathType;
+    output: Schema.PathType;
+    width: Schema.WidthType;
+};
+export type ImageResizerHeightConfigType = {
+    input: Schema.PathType;
+    output: Schema.PathType;
+    height: Schema.HeightType;
+};
+export declare class ImageResizer {
+    static resizeToWidth(config: ImageResizerWidthConfigType): Promise<sharp.OutputInfo>;
+    static resizeToHeight(config: ImageResizerHeightConfigType): Promise<sharp.OutputInfo>;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./graceful-shutdown";
+export * from "./api-version";
+export * from "./time-zone-offset";
+export * from "./context";
+export * from "./etag-extractor";
+export * from "./http-logger";
+export * from "./api-key-shield";
+export * from "./rate-limit-shield";
+export * from "./healthcheck";

package/dist/jobs.d.ts

@@ -0,0 +1,32 @@
+import { Cron } from "croner";
+import { Logger } from "./logger";
+export type JobNameType = string;
+export type MultipleJobsType = Record<JobNameType, Cron>;
+export declare enum UTC_DAY_OF_THE_WEEK {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+    Sunday = 0
+}
+export declare class Jobs {
+    static SCHEDULES: {
+        EVERY_MINUTE: string;
+        EVERY_HOUR: string;
+    };
+    static stopAll(jobs: MultipleJobsType): void;
+    static areAllRunning(jobs: MultipleJobsType): boolean;
+}
+export type JobProcessorType = {
+    cron: string;
+    label: JobNameType;
+    process: () => Promise<void>;
+};
+export declare class JobHandler {
+    private readonly logger;
+    constructor(logger: Logger);
+    handle(jobProcessor: JobProcessorType): () => Promise<void>;
+    protect(cron: Cron): () => Promise<void>;
+}

package/dist/leap-year-checker.d.ts

@@ -0,0 +1,4 @@
+export declare class LeapYearChecker {
+    static isLeapYear(year: number): boolean;
+    static isCurrentYearLeapYear(): boolean;
+}

package/dist/logger.d.ts

@@ -0,0 +1,53 @@
+import * as Schema from "./schema";
+type LogTimestampType = number;
+type LogAppType = string;
+type LogEnvironmentType = Schema.NodeEnvironmentEnum;
+type LogMessageType = string;
+type LogOperationType = string;
+type LogMetadataType = Record<string, any>;
+type LogCorrelationIdType = Schema.CorrelationIdType;
+type LogFullType = {
+    timestamp: LogTimestampType;
+    app: LogAppType;
+    environment: LogEnvironmentType;
+    level: Schema.LogLevelEnum;
+    message: LogMessageType;
+    operation: LogOperationType;
+    method: string;
+    url: string;
+    client: {
+        ip?: string;
+        userAgent?: string;
+    };
+    correlationId?: LogCorrelationIdType;
+    responseCode?: number;
+    durationMs?: Schema.TimestampType;
+    metadata?: LogMetadataType;
+};
+type LogErrorType = Omit<LogFullType, "app" | "client" | "environment" | "duration" | "level" | "method" | "responseCode" | "timestamp" | "url">;
+type LogWarnType = Omit<LogFullType, "app" | "client" | "environment" | "duration" | "level" | "method" | "responseCode" | "timestamp" | "url">;
+type LogInfoType = Omit<LogFullType, "app" | "client" | "environment" | "duration" | "level" | "method" | "responseCode" | "timestamp" | "url">;
+type LogHttpType = Omit<LogFullType, "app" | "environment" | "timestamp" | "level">;
+type LoggerOptionsType = {
+    app: LogAppType;
+    environment: Schema.NodeEnvironmentEnum;
+    level?: Schema.LogLevelEnum;
+};
+export declare class Logger {
+    private readonly instance;
+    private readonly app;
+    private readonly environment;
+    private readonly level;
+    constructor(options: LoggerOptionsType);
+    private getBase;
+    info(log: LogInfoType): void;
+    error(log: LogErrorType): void;
+    warn(log: LogWarnType): void;
+    http(log: LogHttpType): void;
+    formatError(_error: unknown): {
+        message: string;
+        name: string;
+        stack: string | undefined;
+    };
+}
+export {};

package/dist/mailer.d.ts

@@ -0,0 +1,16 @@
+import { SendMailOptions } from "nodemailer";
+import { SmtpHostType, SmtpPortType, SmtpUserType, SmtpPassType } from "./schema";
+type MailerConfigType = {
+    SMTP_HOST: SmtpHostType;
+    SMTP_PORT: SmtpPortType;
+    SMTP_USER: SmtpUserType;
+    SMTP_PASS: SmtpPassType;
+};
+type MailerSendOptionsType = SendMailOptions;
+export declare class Mailer {
+    private readonly transport;
+    constructor(config: MailerConfigType);
+    send(options: MailerSendOptionsType): Promise<unknown>;
+    verify(): Promise<true>;
+}
+export {};

package/dist/mean.d.ts

@@ -0,0 +1,4 @@
+import { RoundingStrategy } from "./rounding";
+export declare class Mean {
+    static calculate(values: number[], rounding?: RoundingStrategy): number;
+}

package/dist/memory-consumption.d.ts

@@ -0,0 +1,4 @@
+import { Size } from "./size";
+export declare class MemoryConsumption {
+    static get(): Size;
+}

package/dist/method-override.d.ts

@@ -0,0 +1,4 @@
+import express from "express";
+export declare class MethodOverride {
+    static applyTo(app: express.Application): void;
+}

package/dist/mime-types.d.ts

@@ -0,0 +1,2 @@
+import type { MimeRawType } from "./mime";
+export declare const MIME_TYPES: Record<string, MimeRawType[]>;

package/dist/mime.d.ts

@@ -0,0 +1,10 @@
+export type MimeRawType = string;
+export type MimeTypeType = string;
+export type MimeSubtypeType = string;
+export declare class Mime {
+    readonly raw: MimeRawType;
+    readonly type: MimeTypeType;
+    readonly subtype: MimeSubtypeType;
+    constructor(value: MimeRawType);
+    isSatisfiedBy(another: Mime): boolean;
+}

package/dist/min-max-scaler.d.ts

@@ -0,0 +1,36 @@
+import { RoundingStrategy } from "./rounding";
+type MinMaxScalerValueType = number;
+type MinMaxScalerConfigType = {
+    min: MinMaxScalerValueType;
+    max: MinMaxScalerValueType;
+    bound?: {
+        lower: MinMaxScalerValueType;
+        upper: MinMaxScalerValueType;
+    };
+    rounding?: RoundingStrategy;
+};
+export declare class MinMaxScaler {
+    private readonly min;
+    private readonly max;
+    private readonly lower;
+    private readonly upper;
+    private readonly rounding;
+    constructor(config: MinMaxScalerConfigType);
+    scale(value: MinMaxScalerValueType): {
+        original: number;
+        scaled: number;
+        isMin: boolean;
+        isMax: boolean;
+    };
+    descale(scaled: MinMaxScalerValueType): {
+        original: number;
+        scaled: number;
+        isLowerBound: boolean;
+        isUpperBound: boolean;
+    };
+    static getMinMax(values: MinMaxScalerValueType[]): {
+        min: number;
+        max: number;
+    };
+}
+export {};

package/dist/money.d.ts

@@ -0,0 +1,24 @@
+import z from "zod";
+import { RoundingStrategy } from "./rounding";
+export declare const MoneyAmount: z.ZodBranded<z.ZodNumber, "money-amount">;
+export type MoneyAmountType = z.infer<typeof MoneyAmount>;
+export declare const MoneyMultiplicationFactor: z.ZodBranded<z.ZodNumber, "money-multiplication-factor">;
+export type MoneyMultiplicationFactorType = z.infer<typeof MoneyMultiplicationFactor>;
+export declare const MoneyDivisionFactor: z.ZodBranded<z.ZodEffects<z.ZodNumber, number, number>, "money-division-factor">;
+export type MoneyDivisionFactorType = z.infer<typeof MoneyDivisionFactor>;
+export declare class Money {
+    private static readonly ZERO;
+    private readonly amount;
+    private readonly rounding;
+    constructor(value?: number, rounding?: RoundingStrategy);
+    getAmount(): MoneyAmountType;
+    add(money: Money): Money;
+    multiply(factor: MoneyMultiplicationFactorType): Money;
+    subtract(money: Money): Money;
+    divide(factor: MoneyDivisionFactorType): Money;
+    equals(another: Money): boolean;
+    isGreaterThan(another: Money): boolean;
+    isLessThan(another: Money): boolean;
+    isZero(): boolean;
+    format(): string;
+}

package/dist/noop.d.ts

@@ -0,0 +1,2 @@
+export declare function noop(): void;
+export declare function anoop(): Promise<void>;

package/dist/open-graph.d.ts

@@ -0,0 +1,91 @@
+import * as Schema from "./schema";
+declare class OpenGraphTitle {
+    private readonly value;
+    constructor(value: Schema.OpenGraphTitleValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphDescription {
+    private readonly value;
+    constructor(value: Schema.OpenGraphDescriptionValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphUrl {
+    private readonly value;
+    constructor(value: Schema.OpenGraphUrlValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphType {
+    private readonly value;
+    constructor(value: Schema.OpenGraphTypeValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphImageUrl {
+    private readonly value;
+    constructor(path: Schema.PathType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphImageType {
+    private readonly value;
+    constructor(value: Schema.OpenGraphImageTypeValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphImageWidth {
+    private readonly value;
+    constructor(value: Schema.OpenGraphImageWidthValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+declare class OpenGraphImageHeight {
+    private readonly value;
+    constructor(value: Schema.OpenGraphImageHeightValueType);
+    toMetatag(): string;
+    toMeta(): string;
+}
+export type OpenGraphImageConfigType = {
+    url: OpenGraphImageUrl;
+    width: OpenGraphImageWidth;
+    height: OpenGraphImageHeight;
+    type: OpenGraphImageType;
+};
+declare class OpenGraphImage {
+    private readonly value;
+    constructor(value: OpenGraphImageConfigType);
+    toString(): string;
+}
+declare class OpenGraphImageGenerator {
+    static generate(config: {
+        path: Schema.PathType;
+        BASE_URL: Schema.UrlWithoutTrailingSlashType;
+    }): Promise<OpenGraphImage>;
+}
+type OpenGraphConfigType = {
+    title: OpenGraphTitle;
+    description: OpenGraphDescription;
+    url: OpenGraphUrl;
+    type: OpenGraphType;
+    image?: OpenGraphImage;
+};
+declare class OpenGraphGenerator {
+    static toString(config: OpenGraphConfigType): string;
+}
+export declare const OpenGraph: {
+    generator: typeof OpenGraphGenerator;
+    title: typeof OpenGraphTitle;
+    description: typeof OpenGraphDescription;
+    url: typeof OpenGraphUrl;
+    type: typeof OpenGraphType;
+    image: {
+        generator: typeof OpenGraphImageGenerator;
+        url: typeof OpenGraphImageUrl;
+        width: typeof OpenGraphImageWidth;
+        height: typeof OpenGraphImageHeight;
+        type: typeof OpenGraphImageType;
+    };
+};
+export {};

package/dist/outlier-detector.d.ts

@@ -0,0 +1,6 @@
+export declare class OutlierDetector {
+    private readonly zScore;
+    private readonly threshold;
+    constructor(values: number[], threshold: number);
+    check(value: number): boolean;
+}

package/dist/package-version.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+type MajorType = number;
+type MinorType = number;
+type PatchType = number;
+export declare const PackageVersionSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, {
+    major: number;
+    minor: number;
+    patch: number;
+}, string>;
+export type PackageVersionSchemaType = z.infer<typeof PackageVersionSchema>;
+export declare class PackageVersion {
+    readonly major: MajorType;
+    readonly minor: MinorType;
+    readonly patch: PatchType;
+    constructor(major: MajorType, minor: MinorType, patch: PatchType);
+    isGreaterThanOrEqual(another: PackageVersion): boolean;
+    static fromStringWithV(value: string): PackageVersion;
+    static fromString(value: string): PackageVersion;
+}
+export {};

package/dist/pagination.d.ts

@@ -0,0 +1,58 @@
+import * as z from "zod";
+declare const Take: z.ZodNumber;
+type TakeType = z.infer<typeof Take>;
+declare const Skip: z.ZodNumber;
+type SkipType = z.infer<typeof Skip>;
+declare const Page: z.ZodDefault<z.ZodNumber>;
+export type PageType = z.infer<typeof Page>;
+export type PaginationType = {
+    values: {
+        take: TakeType;
+        skip: SkipType;
+    };
+    page: PageType;
+};
+export type PaginationValuesType = Record<string, unknown>;
+export type TotalType = number;
+export type ExhaustedType = boolean;
+export type PaginationExhaustedConfig = {
+    total: TotalType;
+    pagination: PaginationType;
+};
+export type PaginationPrepareConfigType<T> = {
+    total: TotalType;
+    pagination: PaginationType;
+    result: T[];
+};
+export declare class Pagination {
+    static parse(values: PaginationValuesType, _take: TakeType): PaginationType;
+    static prepare<T>(config: PaginationPrepareConfigType<T>): Paged<T>;
+    static isExhausted(config: PaginationExhaustedConfig): ExhaustedType;
+    private static getLastPage;
+    static empty: {
+        result: never[];
+        meta: {
+            exhausted: boolean;
+            currentPage: number;
+            previousPage: undefined;
+            nextPage: undefined;
+            lastPage: number;
+            total: number;
+        };
+    };
+    static getFirstPage({ take }: {
+        take: TakeType;
+    }): PaginationType;
+}
+export type Paged<T> = {
+    result: T[];
+    meta: {
+        exhausted: ExhaustedType;
+        currentPage: PageType;
+        previousPage: PageType | undefined;
+        nextPage: PageType | undefined;
+        lastPage: PageType;
+        total: TotalType;
+    };
+};
+export {};

package/dist/percentage.d.ts

@@ -0,0 +1,4 @@
+import { RoundingStrategy } from "./rounding";
+export declare class Percentage {
+    static of(numerator: number, denominator: number, rounding?: RoundingStrategy): number;
+}

package/dist/policy.d.ts

@@ -0,0 +1,11 @@
+import * as ts from "./ts-utils";
+type BasePolicyConfig = Record<string, unknown>;
+export declare abstract class Policy<T extends BasePolicyConfig> {
+    abstract fails(config: T): Promise<boolean> | boolean;
+    abstract error: ts.Constructor<Error>;
+    abstract message: string;
+    throw(): void;
+    perform(config: T): Promise<void>;
+    passes(config: T): Promise<boolean>;
+}
+export {};

package/dist/population-standard-deviation.d.ts

@@ -0,0 +1,4 @@
+import { RoundingStrategy } from "./rounding";
+export declare class PopulationStandardDeviation {
+    static calculate(values: number[], rounding?: RoundingStrategy): number;
+}

package/dist/prerequisites/binary.d.ts

@@ -0,0 +1,16 @@
+import z from "zod";
+import { PrerequisiteLabelType, PrerequisiteStatusEnum, PrerequisiteStrategyEnum, AbstractPrerequisite } from "../prerequisites";
+declare const PrerequisiteBinaryValue: z.ZodEffects<z.ZodString, string, string>;
+type PrerequisiteBinaryValueType = z.infer<typeof PrerequisiteBinaryValue>;
+type PrerequisiteBinaryConfigType = {
+    binary: PrerequisiteBinaryValueType;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteBinary extends AbstractPrerequisite<PrerequisiteBinaryConfigType> {
+    readonly config: PrerequisiteBinaryConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.binary;
+    constructor(config: PrerequisiteBinaryConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}
+export {};

package/dist/prerequisites/bun.d.ts

@@ -0,0 +1,13 @@
+import { PackageVersion } from "../package-version";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteBunConfigType = {
+    version: PackageVersion;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteBun extends AbstractPrerequisite<PrerequisiteBunConfigType> {
+    readonly config: PrerequisiteBunConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.bun;
+    constructor(config: PrerequisiteBunConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/jobs.d.ts

@@ -0,0 +1,13 @@
+import { MultipleJobsType } from "../jobs";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteJobsConfigType = {
+    jobs: MultipleJobsType;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteJobs extends AbstractPrerequisite<PrerequisiteJobsConfigType> {
+    readonly config: PrerequisiteJobsConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.jobs;
+    constructor(config: PrerequisiteJobsConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/mailer.d.ts

@@ -0,0 +1,13 @@
+import { Mailer } from "../mailer";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteMailerConfigType = {
+    mailer: Mailer;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteMailer extends AbstractPrerequisite<PrerequisiteMailerConfigType> {
+    readonly config: PrerequisiteMailerConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.mailer;
+    constructor(config: PrerequisiteMailerConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/memory.d.ts

@@ -0,0 +1,13 @@
+import { Size } from "../size";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteMemoryConfigType = {
+    maximum: Size;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteMemory extends AbstractPrerequisite<PrerequisiteMemoryConfigType> {
+    readonly config: PrerequisiteMemoryConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.memory;
+    constructor(config: PrerequisiteMemoryConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/node.d.ts

@@ -0,0 +1,13 @@
+import { PackageVersion } from "../package-version";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteNodeConfigType = {
+    version: PackageVersion;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteNode extends AbstractPrerequisite<PrerequisiteNodeConfigType> {
+    readonly config: PrerequisiteNodeConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.node;
+    constructor(config: PrerequisiteNodeConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/outside-connectivity.d.ts

@@ -0,0 +1,11 @@
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteOutsideConnectivityConfigType = {
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteOutsideConnectivity extends AbstractPrerequisite<PrerequisiteOutsideConnectivityConfigType> {
+    readonly config: PrerequisiteOutsideConnectivityConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.outsideConnectivity;
+    constructor(config: PrerequisiteOutsideConnectivityConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/path.d.ts

@@ -0,0 +1,16 @@
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisitePathConfigType = {
+    path: string;
+    access?: {
+        write?: boolean;
+        execute?: boolean;
+    };
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisitePath extends AbstractPrerequisite<PrerequisitePathConfigType> {
+    readonly config: PrerequisitePathConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.path;
+    constructor(config: PrerequisitePathConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/port.d.ts

@@ -0,0 +1,13 @@
+import * as Schema from "../schema";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisitePortConfigType = {
+    port: Schema.PortType;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisitePort extends AbstractPrerequisite<PrerequisitePortConfigType> {
+    readonly config: PrerequisitePortConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.port;
+    constructor(config: PrerequisitePortConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/ram.d.ts

@@ -0,0 +1,13 @@
+import { Size } from "../size";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteRAMConfigType = {
+    minimum: Size;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteRAM extends AbstractPrerequisite<PrerequisiteRAMConfigType> {
+    readonly config: PrerequisiteRAMConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.RAM;
+    constructor(config: PrerequisiteRAMConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/self.d.ts

@@ -0,0 +1,11 @@
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteSelfConfigType = {
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteSelf extends AbstractPrerequisite<PrerequisiteSelfConfigType> {
+    readonly config: PrerequisiteSelfConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.self;
+    constructor(config: PrerequisiteSelfConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/space.d.ts

@@ -0,0 +1,13 @@
+import { Size } from "../size";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteSpaceConfigType = {
+    minimum: Size;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteSpace extends AbstractPrerequisite<PrerequisiteSpaceConfigType> {
+    readonly config: PrerequisiteSpaceConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.space;
+    constructor(config: PrerequisiteSpaceConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites/ssl-certificate-expiry.d.ts

@@ -0,0 +1,13 @@
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteSSLCertificateExpiryConfigType = {
+    host: string;
+    validDaysMinimum: number;
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteSSLCertificateExpiry extends AbstractPrerequisite<PrerequisiteSSLCertificateExpiryConfigType> {
+    readonly config: PrerequisiteSSLCertificateExpiryConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.sslCertificateExpiry;
+    constructor(config: PrerequisiteSSLCertificateExpiryConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}