@bgord/bun 0.1.0

package/dist/clock.d.ts

@@ -0,0 +1,49 @@
+export type HourFormatter = (value: Hour["value"]) => string;
+export declare const HourFormatters: Record<string, HourFormatter>;
+export declare class Hour {
+    private readonly value;
+    private readonly formatter;
+    static readonly ZERO: Hour;
+    static readonly MAX: Hour;
+    constructor(candidate: number, formatter?: HourFormatter);
+    get(formatter?: HourFormatter): {
+        raw: number;
+        formatted: string;
+    };
+    equals(another: Hour): boolean;
+    isAfter(another: Hour): boolean;
+    isBefore(another: Hour): boolean;
+    static list(formatter?: HourFormatter): Hour[];
+}
+export declare class Minute {
+    private readonly value;
+    static readonly ZERO: Minute;
+    static readonly MAX: Minute;
+    constructor(candidate: number);
+    get(): {
+        raw: number;
+        formatted: string;
+    };
+    equals(another: Minute): boolean;
+    isAfter(another: Minute): boolean;
+    isBefore(another: Minute): boolean;
+    static list(): Minute[];
+}
+export type ClockFormatter = (hour: Hour, minute: Minute) => string;
+export declare const ClockFormatters: Record<string, ClockFormatter>;
+export declare class Clock {
+    private readonly hour;
+    private readonly minute;
+    private readonly formatter;
+    constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
+    get(formatter?: ClockFormatter): {
+        raw: {
+            hour: number;
+            minute: number;
+        };
+        formatted: string;
+    };
+    equals(another: Clock): boolean;
+    isAfter(another: Clock): boolean;
+    isBefore(another: Clock): boolean;
+}

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+import * as bg from "@bgord/node";
+import { TimeZoneOffsetVariables } from "./time-zone-offset";
+export declare type ContextVariables = {
+    context: bg.ContextType;
+    requestId: string;
+} & TimeZoneOffsetVariables;
+export declare class Context {
+    static attach: import("hono/types").MiddlewareHandler<{
+        Bindings: any;
+        Variables: any;
+    }, string, {}>;
+}

package/dist/credentials.d.ts

@@ -0,0 +1,28 @@
+import z from "zod";
+export type IdType = string;
+export type PasswordType = string;
+type UsernameType = string;
+type HashedPasswordType = string;
+export declare class Username {
+    private readonly schema;
+    private readonly value;
+    constructor(value: UsernameType, schema?: z.ZodSchema);
+    read(): UsernameType;
+}
+export declare class Password {
+    private schema;
+    private value;
+    constructor(value: PasswordType, schema?: z.ZodSchema);
+    hash(): Promise<HashedPassword>;
+    read(): PasswordType;
+}
+export declare class HashedPassword {
+    private value;
+    private constructor();
+    static fromPassword(password: Password): Promise<HashedPassword>;
+    static fromHash(value: HashedPasswordType): Promise<HashedPassword>;
+    read(): HashedPasswordType;
+    matches(password: Password): Promise<boolean>;
+    matchesOrThrow(password: Password): Promise<true>;
+}
+export {};

package/dist/dates.d.ts

@@ -0,0 +1,37 @@
+import { format } from "date-fns";
+import * as Schema from "./schema";
+import { Falsy } from "./ts-utils";
+export type FormattedDateType = string;
+export type DateFormattersInputType = Parameters<typeof format>[0];
+export declare class DateFormatters {
+    static datetime(date: DateFormattersInputType): FormattedDateType;
+    static date(date: DateFormattersInputType): FormattedDateType;
+    static monthDay(date: DateFormattersInputType): FormattedDateType;
+    static relative(date: DateFormattersInputType): string;
+}
+export type RelativeDateType = {
+    raw: Schema.TimestampType;
+    relative: string;
+};
+export declare class RelativeDate {
+    static truthy(timestampMs: Schema.TimestampType): RelativeDateType;
+    static falsy(timestampMs: Falsy<Schema.TimestampType>): RelativeDateType | null;
+    private static _format;
+}
+export declare enum DayOfTheWeekEnum {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+    Sunday = 0
+}
+type GetStartOfDayTsInTzConfigType = {
+    now: Schema.TimestampType;
+    timeZoneOffsetMs: Schema.TimeZoneOffsetValueType;
+};
+export declare class DateCalculator {
+    static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): number;
+}
+export {};

package/dist/decorators.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from "./logger";
+export declare class Decorators {
+    private readonly logger;
+    private readonly rounding;
+    constructor(logger: Logger);
+    duration(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    inspector(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+}

package/dist/deep-merge.d.ts

@@ -0,0 +1,7 @@
+type NonArrayObject = {
+    [key: string]: any;
+} & {
+    length?: never;
+};
+export declare function deepMerge(a: NonArrayObject | undefined, b: NonArrayObject | undefined): Object;
+export {};

package/dist/dll.d.ts

@@ -0,0 +1,29 @@
+export declare class Node<T> {
+    data: T;
+    prev: Node<T> | null;
+    next: Node<T> | null;
+    constructor(data: Node<T>["data"]);
+    forward(n: number): Node<T> | null;
+    backward(n: number): Node<T> | null;
+}
+export declare class DoublyLinkedList<T> {
+    static EMPTY_SIZE: number;
+    private size;
+    private head;
+    private tail;
+    getSize(): DoublyLinkedList<T>["size"];
+    isEmpty(): boolean;
+    getHead(): DoublyLinkedList<T>["head"];
+    getTail(): DoublyLinkedList<T>["tail"];
+    append(node: Node<T>): void;
+    prepend(node: Node<T>): void;
+    clear(): void;
+    remove(node: Node<T>): void;
+    insertAfter(node: Node<T>, target: Node<T>): void;
+    insertBefore(node: Node<T>, target: Node<T>): void;
+    find(callback: (node: Node<T>) => boolean): Node<T> | null;
+    reverse(): void;
+    toArray(): Node<T>[];
+    static fromArray<T>(array: T[]): DoublyLinkedList<T>;
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+}

package/dist/download-file.d.ts

@@ -0,0 +1,10 @@
+import express from "express";
+import fs from "node:fs";
+import { Mime } from "./mime";
+export type DownloadFileConfigType = {
+    filename: fs.PathLike;
+    mime: Mime;
+};
+export declare class DownloadFile {
+    static attach(response: express.Response, config: DownloadFileConfigType): void;
+}

package/dist/email-censor.d.ts

@@ -0,0 +1,4 @@
+import * as Schema from "./schema";
+export declare class EmailCensor {
+    static censor(email: Schema.EmailType): Schema.EmailType;
+}

package/dist/encryption.d.ts

@@ -0,0 +1,20 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as Schema from "./schema";
+export type EncryptionConfig = {
+    secret: Schema.EncryptionSecretType;
+    iv: Schema.EncryptionIVType;
+};
+export type EncryptionOperationConfig = {
+    input: fs.PathLike;
+    output: fs.PathLike;
+};
+export declare class Encryption {
+    private readonly config;
+    private readonly algorithm;
+    constructor(config: EncryptionConfig);
+    createEncrypt(): Promise<crypto.Cipher>;
+    createDecrypt(): Promise<crypto.Decipher>;
+    encrypt(config: EncryptionOperationConfig): Promise<void>;
+    decrypt(config: EncryptionOperationConfig): Promise<void>;
+}

package/dist/environment-validator.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod";
+import { NodeEnvironment } from "./schema";
+type NodeEnvironmentEnumType = z.infer<typeof NodeEnvironment>;
+type AnyZodSchema = z.ZodSchema<any, any>;
+type QuietType = boolean;
+type QuitType = boolean;
+type EnvironmentValidatorConfig = {
+    type: unknown;
+    schema: AnyZodSchema;
+    quiet?: QuietType;
+    quit?: QuitType;
+};
+export declare class EnvironmentValidator<SchemaType> {
+    type: NodeEnvironmentEnumType;
+    schema: z.Schema<SchemaType>;
+    quiet: QuietType;
+    quit: QuitType;
+    constructor(config: EnvironmentValidatorConfig);
+    load(): SchemaType & {
+        type: NodeEnvironmentEnumType;
+    };
+}
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,49 @@
+import { MimeRawType } from "./mime";
+import { TimestampType } from "./schema";
+export declare enum AccessDeniedErrorReasonType {
+    hcaptcha = "hcaptcha",
+    /** @public */
+    csrf = "csrf",
+    "api-key" = "api-key",
+    recaptcha = "recaptcha",
+    auth = "auth",
+    /** @public */
+    "basic-auth" = "basic-auth"
+}
+export type AccessDeniedErrorConfigType = {
+    reason: AccessDeniedErrorReasonType;
+};
+export declare class AccessDeniedError extends Error {
+    reason: AccessDeniedErrorConfigType["reason"];
+    constructor(config: AccessDeniedErrorConfigType);
+}
+export declare class InvalidCredentialsError extends Error {
+    constructor();
+}
+export declare class FileNotFoundError extends Error {
+    constructor();
+}
+export declare class InvalidMimeError extends Error {
+    constructor();
+}
+export declare class NotAcceptedMimeError extends Error {
+    mime: MimeRawType;
+    constructor(mime: MimeRawType);
+}
+export declare class TooManyRequestsError extends Error {
+    remainingMs: number;
+    constructor(remainingMs: number);
+}
+export type RequestTimerErrorConfigType = {
+    ms: TimestampType;
+};
+export declare class RequestTimeoutError extends Error {
+    ms: RequestTimerErrorConfigType["ms"];
+    constructor(config: RequestTimerErrorConfigType);
+}
+export declare class InvalidRevisionError extends Error {
+    constructor();
+}
+export declare class RevisionMismatchError extends Error {
+    constructor();
+}

package/dist/etag-extractor.d.ts

@@ -0,0 +1,17 @@
+import * as bg from "@bgord/node";
+export declare type EtagVariables = {
+    ETag: bg.ETag | null;
+    WeakETag: bg.WeakETag | null;
+};
+export declare class ETagExtractor {
+    static attach: import("hono/types").MiddlewareHandler<{
+        Bindings: any;
+        Variables: EtagVariables;
+    }, string, {}>;
+}
+export declare class WeakETagExtractor {
+    static attach: import("hono/types").MiddlewareHandler<{
+        Bindings: any;
+        Variables: EtagVariables;
+    }, string, {}>;
+}

package/dist/etag.d.ts

@@ -0,0 +1,19 @@
+import { RevisionType } from "./schema";
+export type ETagValueType = string;
+export declare class ETag {
+    readonly revision: RevisionType;
+    static HEADER_NAME: string;
+    static IF_MATCH_HEADER_NAME: string;
+    readonly value: ETagValueType;
+    private constructor();
+    static fromHeader(value?: ETagValueType): ETag | null;
+}
+export type WeakETagValueType = string;
+export declare class WeakETag {
+    readonly revision: RevisionType;
+    static HEADER_NAME: string;
+    static IF_MATCH_HEADER_NAME: string;
+    readonly value: WeakETagValueType;
+    private constructor();
+    static fromHeader(value?: WeakETagValueType): WeakETag | null;
+}

package/dist/event.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { Logger } from "./logger";
+export declare const Event: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodDate;
+    stream: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    payload: z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodAny>, Record<string, any>, Record<string, any>>, string, Record<string, any>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    stream: string;
+    name: string;
+    version: number;
+    payload: string;
+}, {
+    createdAt: Date;
+    stream: string;
+    name: string;
+    version: number;
+    payload: Record<string, any>;
+    id?: string | undefined;
+}>;
+export declare const ParsedEvent: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodDate;
+    stream: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    stream: string;
+    name: string;
+    version: number;
+    payload: Record<string, any>;
+}, {
+    createdAt: Date;
+    stream: string;
+    name: string;
+    version: number;
+    payload: Record<string, any>;
+    id?: string | undefined;
+}>;
+export type EventType = z.infer<typeof Event>;
+export type ParsedEventType = z.infer<typeof ParsedEvent>;
+export declare class EventHandler {
+    private readonly logger;
+    constructor(logger: Logger);
+    handle<T extends Pick<EventType, "name">>(fn: (event: T) => Promise<void>): (event: T) => Promise<void>;
+}
+export declare class EventLogger {
+    private readonly logger;
+    constructor(logger: Logger);
+    private _handle;
+    handle: (type: string, _debugName: string, eventName: string | undefined, eventData: Record<string, any> | undefined) => void;
+}

package/dist/express-essentials.d.ts

@@ -0,0 +1,35 @@
+import "./polyfills";
+import express from "express";
+import bodyparser from "body-parser";
+import helmet from "helmet";
+import cors from "cors";
+import { StaticFilesConfigType } from "./static-files";
+import { Stopwatch } from "./stopwatch";
+export type ExpressEssentialsConfig = Partial<{
+    helmet: Parameters<typeof helmet>[0];
+    json: bodyparser.OptionsJson;
+    urlencoded: bodyparser.OptionsUrlencoded;
+    cors: cors.CorsOptions;
+    staticFiles: StaticFilesConfigType;
+}>;
+declare global {
+    namespace Express {
+        interface Locals {
+            startup: Stopwatch;
+        }
+    }
+}
+export declare const DEFAULT_HELMET_CONFIG: {
+    contentSecurityPolicy: {
+        useDefaults: boolean;
+        directives: {
+            "script-src": string[];
+            "script-src-attr": null;
+            "style-src": string[];
+            "frame-src": string[];
+            "connect-src": string[];
+            "img-src": string[];
+        };
+    };
+};
+export declare function addExpressEssentials(app: express.Express, config?: ExpressEssentialsConfig): void;

package/dist/feature-flag.d.ts

@@ -0,0 +1,5 @@
+import * as Schema from "./schema";
+export declare class FeatureFlag {
+    static isEnabled(flag: Schema.FeatureFlagType): boolean;
+    static isDisabled(flag: Schema.FeatureFlagType): boolean;
+}

package/dist/file-location.d.ts

@@ -0,0 +1,31 @@
+import * as Schema from "./schema";
+type FileLocationBasenameType = string;
+type FileLocationExtensionType = string;
+type FileLocationParentType = string;
+export type FileLocationConfigType = {
+    parent: FileLocationParentType;
+    basename: FileLocationBasenameType;
+    extension: FileLocationExtensionType;
+};
+export declare class FileLocation {
+    readonly parent: Schema.PathType;
+    private basename;
+    private extension;
+    constructor(config: FileLocationConfigType);
+    getBasename(): FileLocationBasenameType;
+    getExtension(): FileLocationExtensionType;
+    getFilename(extension?: FileLocationExtensionType): Schema.PathType;
+    getPath(extension?: FileLocationExtensionType): Schema.PathType;
+    getGzippedPath(): Schema.PathType;
+    summary(): {
+        parent: string & import("zod").BRAND<"path">;
+        basename: string;
+        extension: string;
+        filename: string & import("zod").BRAND<"path">;
+        path: string & import("zod").BRAND<"path">;
+        gzipped: string & import("zod").BRAND<"path">;
+    };
+    setBasename(basename: FileLocationBasenameType): FileLocation;
+    delete(): Promise<void>;
+}
+export {};

package/dist/file-uploader.d.ts

@@ -0,0 +1,12 @@
+import express from "express";
+import files from "express-form-data";
+type FileUploaderConfigType = files.FormDataOptions & {
+    mimeTypes: string[];
+};
+export declare class FileUploader {
+    static defaultConfig: FileUploaderConfigType;
+    static applyTo(app: express.Application, _config: FileUploaderConfigType): void;
+    static handle(_config?: FileUploaderConfigType): ((request: express.Request, _response: express.Response, next: express.NextFunction) => void)[];
+    private static validate;
+}
+export {};

package/dist/file.d.ts

@@ -0,0 +1,4 @@
+import * as Schema from "./schema";
+export declare class File {
+    static getSizeInBytes(path: Schema.PathType): Promise<Schema.SizeInBytesType>;
+}

package/dist/filter.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export type DefaultFilterSchemaType = z.ZodRawShape;
+export type FilterValuesType = Record<string, unknown>;
+export type FilterSchemaType<T extends DefaultFilterSchemaType> = z.ZodObject<T>;
+export type FilterParseConfigType<T extends DefaultFilterSchemaType> = {
+    schema: FilterSchemaType<T>;
+    values: FilterValuesType;
+};
+export declare class Filter<T extends DefaultFilterSchemaType> {
+    private readonly schema;
+    constructor(schema: FilterSchemaType<T>);
+    parse(values: FilterValuesType): (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]>[k]; } : never) | undefined;
+    default(): (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]>[k]; } : never) | undefined;
+    static parse<T extends DefaultFilterSchemaType>(config: FilterParseConfigType<T>): (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]>[k]; } : never) | undefined;
+    static default<T extends DefaultFilterSchemaType>(config: Omit<FilterParseConfigType<T>, "values">): (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, { [k_1 in keyof z.baseObjectOutputType<T>]: undefined extends z.baseObjectOutputType<T>[k_1] ? never : k_1; }[keyof T]>[k]; } : never) | undefined;
+    private static _parse;
+}

package/dist/graceful-shutdown.d.ts

@@ -0,0 +1,6 @@
+declare type ServerType = ReturnType<typeof Bun.serve>;
+export declare class GracefulShutdown {
+    private static shutdown;
+    static applyTo(server: ServerType, callback?: () => any): void;
+}
+export {};

package/dist/gzip.d.ts

@@ -0,0 +1,12 @@
+import { PathLike } from "node:fs";
+type GzipCompressConfigType = {
+    input: PathLike;
+    output: PathLike;
+};
+export declare class Gzip {
+    static createCompress(): import("zlib").Gzip;
+    static createDecompress(): import("zlib").Gunzip;
+    static compress(config: GzipCompressConfigType): Promise<void>;
+    static uncompress(config: GzipCompressConfigType): Promise<void>;
+}
+export {};

package/dist/handlebars.d.ts

@@ -0,0 +1,10 @@
+import express from "express";
+import handlebars from "express-handlebars";
+import * as Schema from "./schema";
+export type HandlebarsConfigType = handlebars.ExpressHandlebars["config"] & {
+    path: Schema.PathType;
+};
+export declare class Handlebars {
+    static handlebarsDefaultConfig: HandlebarsConfigType;
+    static applyTo(app: express.Application, _config?: HandlebarsConfigType): void;
+}

package/dist/hcaptcha-shield.d.ts

@@ -0,0 +1,24 @@
+import express from "express";
+import { z } from "zod";
+import { HCaptchaSecretKey } from "./schema";
+type HCaptchaSecretKeyType = z.infer<typeof HCaptchaSecretKey>;
+type HCaptchaVerifierModeType = "local" | "production";
+export type HCaptchaVerifierConfigType = {
+    secretKey: HCaptchaSecretKeyType;
+    mode: HCaptchaVerifierModeType;
+};
+export declare class HCaptchaShield {
+    private readonly secretKey;
+    private readonly mode;
+    private readonly LOCAL_HCAPTCHA_RESPONSE_PLACEHOLDER;
+    constructor(config: HCaptchaVerifierConfigType);
+    private _verify;
+    verify: (request: express.Request, _response: express.Response, next: express.NextFunction) => Promise<void>;
+    static helmetCspConfig: {
+        "script-src": string[];
+        "frame-src": string[];
+        "style-src": string[];
+        "connect-src": string[];
+    };
+}
+export {};

package/dist/healthcheck.d.ts

@@ -0,0 +1,20 @@
+import * as bg from "@bgord/node";
+export declare class Healthcheck {
+    static build: (prerequisites: bg.AbstractPrerequisite<bg.BasePrerequisiteConfig>[]) => [import("hono/types").H<any, any, {}, Promise<Response & import("hono/types").TypedResponse<{
+        ok: bg.PrerequisiteStatusEnum;
+        version: string & import("zod").BRAND<"build-version">;
+        details: {
+            label: string;
+            status: bg.PrerequisiteStatusEnum;
+        }[];
+        uptime: {
+            seconds: number;
+            formatted: string;
+        };
+        memory: {
+            bytes: any;
+            formatted: string;
+        };
+        durationMs: number;
+    }, 200 | 424, "json">>>];
+}

package/dist/http-logger.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="handlebars" />
+import * as bg from "@bgord/node";
+export declare class HttpLogger {
+    private static simplify;
+    private static uninformativeHeaders;
+    static build: (logger: bg.Logger) => import("hono/types").MiddlewareHandler<{
+        Bindings: any;
+        Variables: any;
+    }, string, {}>;
+}

package/dist/i18n.d.ts

@@ -0,0 +1,31 @@
+import express from "express";
+import * as Schema from "./schema";
+export type TranslationsKeyType = string;
+export type TranslationsValueType = string;
+export type TranslationsType = Record<TranslationsKeyType, TranslationsValueType>;
+export type TranslationPlaceholderType = string;
+export type TranslationPlaceholderValueType = string | number;
+export type TranslationVariableType = Record<TranslationPlaceholderType, TranslationPlaceholderValueType>;
+export type I18nConfigType = {
+    translationsPath?: Schema.PathType;
+    defaultLanguage?: Schema.LanguageType;
+    supportedLanguages: Record<string, Schema.LanguageType>;
+};
+declare global {
+    namespace Express {
+        interface Request {
+            language: Schema.LanguageType;
+            supportedLanguages: Schema.LanguageType[];
+            translationsPath: Schema.PathType;
+        }
+    }
+}
+export declare class I18n {
+    static LANGUAGE_COOKIE_NAME: string;
+    static DEFAULT_TRANSLATIONS_PATH: string & import("zod").BRAND<"path">;
+    static FALLBACK_LANGUAGE: string;
+    static applyTo(app: express.Application, config: I18nConfigType): void;
+    static getTranslations(language: Schema.LanguageType, translationsPath: Schema.PathType): Promise<TranslationsType>;
+    static useTranslations(translations: TranslationsType): (key: TranslationsKeyType, variables?: TranslationVariableType) => string;
+    static getTranslationPathForLanguage(language: Schema.LanguageType, translationsPath?: string & import("zod").BRAND<"path">): Schema.PathType;
+}

package/dist/image-compressor.d.ts

@@ -0,0 +1,10 @@
+import sharp from "sharp";
+import * as Schema from "./schema";
+export type ImageCompressorConfigType = {
+    input: Schema.PathType;
+    output: Schema.PathType;
+    quality?: Schema.ImageCompressionQualityType;
+};
+export declare class ImageCompressor {
+    static compress(config: ImageCompressorConfigType): Promise<sharp.OutputInfo>;
+}

package/dist/image-converter.d.ts

@@ -0,0 +1,11 @@
+import sharp from "sharp";
+import * as Schema from "./schema";
+export type ImageConverterType = keyof sharp.FormatEnum;
+export type ImageConverterConfigType = {
+    format: ImageConverterType;
+    input: Schema.PathType;
+    output: Schema.PathType;
+};
+export declare class ImageConverter {
+    static convert(config: ImageConverterConfigType): Promise<sharp.OutputInfo>;
+}