@bgord/bun 0.1.0

package/dist/prerequisites/timezone-utc.d.ts

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

package/dist/prerequisites/translations.d.ts

@@ -0,0 +1,14 @@
+import { I18n, I18nConfigType } from "../i18n";
+import { PrerequisiteLabelType, PrerequisiteStrategyEnum, PrerequisiteStatusEnum, AbstractPrerequisite } from "../prerequisites";
+export type PrerequisiteTranslationsConfigType = {
+    translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
+    supportedLanguages: I18nConfigType["supportedLanguages"];
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+};
+export declare class PrerequisiteTranslations extends AbstractPrerequisite<PrerequisiteTranslationsConfigType> {
+    readonly config: PrerequisiteTranslationsConfigType;
+    readonly strategy = PrerequisiteStrategyEnum.translations;
+    constructor(config: PrerequisiteTranslationsConfigType);
+    verify(): Promise<PrerequisiteStatusEnum>;
+}

package/dist/prerequisites.d.ts

@@ -0,0 +1,44 @@
+export type PrerequisiteLabelType = string;
+export declare enum PrerequisiteStrategyEnum {
+    binary = "binary",
+    mailer = "mailer",
+    self = "self",
+    timezoneUTC = "timezoneUTC",
+    path = "path",
+    node = "node",
+    bun = "bun",
+    RAM = "RAM",
+    space = "space",
+    translations = "translations",
+    port = "port",
+    jobs = "jobs",
+    memory = "memory",
+    outsideConnectivity = "outsideConnectivity",
+    sslCertificateExpiry = "sslCertificateExpiry",
+    /** @public */
+    custom = "custom"
+}
+export declare enum PrerequisiteStatusEnum {
+    success = "success",
+    failure = "failure",
+    undetermined = "undetermined"
+}
+export type BasePrerequisiteConfig = {
+    label: PrerequisiteLabelType;
+    enabled?: boolean;
+} & Record<string, unknown>;
+export declare abstract class AbstractPrerequisite<T extends BasePrerequisiteConfig> {
+    readonly label: PrerequisiteLabelType;
+    readonly enabled: boolean;
+    abstract readonly strategy: PrerequisiteStrategyEnum;
+    abstract readonly config: T;
+    status: PrerequisiteStatusEnum;
+    constructor(config: T);
+    abstract verify(): Promise<PrerequisiteStatusEnum>;
+    protected pass(): PrerequisiteStatusEnum.success;
+    protected reject(): PrerequisiteStatusEnum.failure;
+    report(): void;
+}
+export declare class Prerequisites {
+    static check(prerequisites: AbstractPrerequisite<BasePrerequisiteConfig>[]): Promise<void>;
+}

package/dist/random.d.ts

@@ -0,0 +1,8 @@
+type RandomGenerateConfigType = {
+    min: number;
+    max: number;
+};
+export declare class Random {
+    static generate(config?: RandomGenerateConfigType): number;
+}
+export {};

package/dist/rate-limit-shield.d.ts

@@ -0,0 +1,11 @@
+import * as bg from "@bgord/node";
+import { HTTPException } from "hono/http-exception";
+declare type RateLimitShieldOptionsType = {
+    ms: bg.Schema.TimestampType;
+};
+export declare const TooManyRequestsError: HTTPException;
+export declare const rateLimitShield: (options: RateLimitShieldOptionsType) => import("hono/types").MiddlewareHandler<{
+    Bindings: any;
+    Variables: any;
+}, string, {}>;
+export {};

package/dist/rate-limiter.d.ts

@@ -0,0 +1,18 @@
+import type { TimestampType } from "./schema";
+export type RateLimiterOptionsType = {
+    ms: TimestampType;
+};
+export type RateLimiterResultSuccessType = {
+    allowed: true;
+};
+export type RateLimiterResultErrorType = {
+    allowed: false;
+    remainingMs: TimestampType;
+};
+export type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
+export declare class RateLimiter {
+    private readonly options;
+    private lastInvocationTimestampMs;
+    constructor(options: RateLimiterOptionsType);
+    verify(currentTimestampMs: TimestampType): RateLimiterResultType;
+}

package/dist/recaptcha-shield.d.ts

@@ -0,0 +1,12 @@
+import express from "express";
+import { RecaptchaSiteKeyType, RecaptchaSecretKeyType } from "./schema";
+export type RecaptchaVerifierConfigType = {
+    siteKey: RecaptchaSiteKeyType;
+    secretKey: RecaptchaSecretKeyType;
+};
+export declare class RecaptchaShield {
+    private readonly siteKey;
+    private readonly secretKey;
+    constructor(config: RecaptchaVerifierConfigType);
+    build(): (request: express.Request, _response: express.Response, next: express.NextFunction) => Promise<void>;
+}

package/dist/redirector.d.ts

@@ -0,0 +1,4 @@
+import express from "express";
+export declare class Redirector {
+    static build(path: string): (_request: express.Request, response: express.Response) => void;
+}

package/dist/reordering.d.ts

@@ -0,0 +1,49 @@
+import * as Schema from "./schema";
+export type WithReorderingPositionValue<T> = T & {
+    position: Schema.ReorderingItemPositionValueType;
+};
+export declare class ReorderingPosition {
+    readonly value: Schema.ReorderingItemPositionValueType;
+    constructor(value: Schema.ReorderingItemPositionValueType);
+    eq(another: ReorderingPosition): boolean;
+}
+declare class ReorderingItem {
+    readonly id: Schema.ReorderingItemIdType;
+    readonly position: ReorderingPosition;
+    constructor(id: Schema.ReorderingItemIdType, position: ReorderingPosition);
+    eq(anotherItemId: ReorderingItem["id"]): boolean;
+}
+declare enum ReorderingTransferDirection {
+    upwards = "upwards",
+    downwards = "downwards",
+    noop = "noop"
+}
+export declare class ReorderingTransfer {
+    readonly id: ReorderingItem["id"];
+    readonly to: ReorderingPosition;
+    constructor(config: {
+        id: ReorderingItem["id"];
+        to: Schema.ReorderingItemPositionValueType;
+    });
+    getDirection(currentPosition: ReorderingPosition): ReorderingTransferDirection;
+}
+export declare class ReorderingCalculator {
+    private dll;
+    constructor();
+    static fromArray(ids: ReorderingItem["id"][]): ReorderingCalculator;
+    add(id: ReorderingItem["id"]): ReorderingItem;
+    delete(id: ReorderingItem["id"]): void;
+    transfer(transfer: ReorderingTransfer): ReturnType<ReorderingCalculator["read"]>;
+    read(): {
+        ids: string[];
+        items: ReorderingItem[];
+    };
+    private recalculate;
+}
+export declare class ReorderingIntegrator {
+    static appendPosition(reordering: Schema.ReorderingType[]): <T extends {
+        id: Schema.ReorderingItemIdType;
+    }>(item: T) => WithReorderingPositionValue<T>;
+    static sortByPosition(): (a: WithReorderingPositionValue<unknown>, b: WithReorderingPositionValue<unknown>) => number;
+}
+export {};

package/dist/request-id.d.ts

@@ -0,0 +1,13 @@
+import express from "express";
+import * as Schema from "./schema";
+declare global {
+    namespace Express {
+        interface Request {
+            requestId: Schema.CorrelationIdType;
+        }
+    }
+}
+export declare class RequestId {
+    static CONTINUE_HEADER: string;
+    static applyTo(app: express.Application): void;
+}

package/dist/response-body-in-locals.d.ts

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

package/dist/revision.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "./schema";
+import { ETag, WeakETag } from "./etag";
+export declare class Revision {
+    readonly value: Schema.RevisionType;
+    static initial: Schema.RevisionType;
+    constructor(value: unknown);
+    matches(another: Schema.RevisionType): boolean;
+    validate(another: Schema.RevisionType): void;
+    next(): Revision;
+    static fromETag(etag: ETag | null): Revision;
+    static fromWeakETag(weakEtag: WeakETag | null): Revision;
+}

package/dist/rounding.d.ts

@@ -0,0 +1,17 @@
+export declare abstract class RoundingStrategy {
+    abstract round(value: number): number;
+}
+export declare class RoundToNearest extends RoundingStrategy {
+    round(value: number): number;
+}
+export declare class RoundUp extends RoundingStrategy {
+    round(value: number): number;
+}
+export declare class RoundDown extends RoundingStrategy {
+    round(value: number): number;
+}
+export declare class RoundToDecimal extends RoundingStrategy {
+    private readonly decimals;
+    constructor(decimals: number);
+    round(value: number): number;
+}

package/dist/schema.d.ts

@@ -0,0 +1,189 @@
+import { z } from "zod";
+/** @public */
+export declare enum NodeEnvironmentEnum {
+    local = "local",
+    test = "test",
+    staging = "staging",
+    production = "production"
+}
+export declare const NodeEnvironment: z.ZodNativeEnum<typeof NodeEnvironmentEnum>;
+export declare const Port: z.ZodNumber;
+export type PortType = z.infer<typeof Port>;
+export declare const HCaptchaSecretKey: z.ZodString;
+export declare const HCaptchaSiteKey: z.ZodString;
+export declare const HCaptchaResponseToken: z.ZodString;
+export declare const UUID: z.ZodDefault<z.ZodString>;
+export type UUIDType = z.infer<typeof UUID>;
+export declare const SmtpHost: z.ZodString;
+export type SmtpHostType = z.infer<typeof SmtpHost>;
+export declare const SmtpPort: z.ZodNumber;
+export type SmtpPortType = z.infer<typeof SmtpPort>;
+export declare const SmtpUser: z.ZodString;
+export type SmtpUserType = z.infer<typeof SmtpUser>;
+export declare const SmtpPass: z.ZodString;
+export type SmtpPassType = z.infer<typeof SmtpPass>;
+export declare const Email: z.ZodString;
+export type EmailType = z.infer<typeof Email>;
+export declare const CookieSecret: z.ZodString;
+export type CookieSecretType = z.infer<typeof CookieSecret>;
+export declare const ContentfulSpaceId: z.ZodString;
+export type ContentfulSpaceIdType = z.infer<typeof ContentfulSpaceId>;
+export declare const ContentfulAccessToken: z.ZodString;
+export type ContentfulAccessTokenType = z.infer<typeof ContentfulAccessToken>;
+export declare const UrlWithoutTrailingSlash: z.ZodEffects<z.ZodString, string, string>;
+export type UrlWithoutTrailingSlashType = z.infer<typeof UrlWithoutTrailingSlash>;
+export declare const TwitterApiBearerToken: z.ZodString;
+export type TwitterApiBearerTokenType = z.infer<typeof TwitterApiBearerToken>;
+export declare const ApiKey: z.ZodString;
+export type ApiKeyType = z.infer<typeof ApiKey>;
+export declare const TwitterAppKey: z.ZodString;
+export type TwitterAppKeyType = z.infer<typeof TwitterAppKey>;
+export declare const TwitterAppSecret: z.ZodString;
+export type TwitterAppSecretType = z.infer<typeof TwitterAppSecret>;
+export declare const TwitterAccessToken: z.ZodString;
+export type TwitterAccessTokenType = z.infer<typeof TwitterAccessToken>;
+export declare const TwitterAccessSecret: z.ZodString;
+export type TwitterAccessSecretType = z.infer<typeof TwitterAccessSecret>;
+export declare const RecaptchaSiteKey: z.ZodString;
+export type RecaptchaSiteKeyType = z.infer<typeof RecaptchaSiteKey>;
+export declare const RecaptchaSecretKey: z.ZodString;
+export type RecaptchaSecretKeyType = z.infer<typeof RecaptchaSecretKey>;
+export declare enum FeatureFlagEnum {
+    yes = "yes",
+    no = "no"
+}
+export declare const FeatureFlag: z.ZodNativeEnum<typeof FeatureFlagEnum>;
+export type FeatureFlagType = z.infer<typeof FeatureFlag>;
+export declare const Localhost: z.ZodLiteral<"127.0.0.1">;
+export type LocalhostType = z.infer<typeof Localhost>;
+export declare const AdminUsername: z.ZodString;
+export type AdminUsernameType = z.infer<typeof AdminUsername>;
+export declare const AdminPassword: z.ZodString;
+export type AdminPasswordType = z.infer<typeof AdminPassword>;
+export declare const Path: z.ZodBranded<z.ZodString, "path">;
+export type PathType = z.infer<typeof Path>;
+export declare const Timestamp: z.ZodDefault<z.ZodNumber>;
+export type TimestampType = z.infer<typeof Timestamp>;
+export declare const SizeInBytes: z.ZodBranded<z.ZodNumber, "size-in-bytes">;
+export type SizeInBytesType = z.infer<typeof SizeInBytes>;
+export declare const UploadedFile: z.ZodObject<{
+    fieldName: z.ZodString;
+    originalFilename: z.ZodString;
+    path: z.ZodBranded<z.ZodString, "path">;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    size: z.ZodBranded<z.ZodNumber, "size-in-bytes">;
+}, "strip", z.ZodTypeAny, {
+    path: string & z.BRAND<"path">;
+    fieldName: string;
+    originalFilename: string;
+    headers: Record<string, string>;
+    size: number & z.BRAND<"size-in-bytes">;
+}, {
+    path: string;
+    fieldName: string;
+    originalFilename: string;
+    headers: Record<string, string>;
+    size: number;
+}>;
+export type UploadedFileType = z.infer<typeof UploadedFile>;
+export declare const TimeZoneOffsetHeaderValue: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodUndefined]>, number, string | undefined>, number, string | undefined>;
+export type TimeZoneOffsetType = z.infer<typeof TimeZoneOffsetHeaderValue>;
+export declare const TimeZoneOffsetValue: z.ZodNumber;
+export type TimeZoneOffsetValueType = z.infer<typeof TimeZoneOffsetValue>;
+export declare const Language: z.ZodDefault<z.ZodString>;
+export type LanguageType = z.infer<typeof Language>;
+export declare const Width: z.ZodBranded<z.ZodNumber, "width">;
+export type WidthType = z.infer<typeof Width>;
+export declare const Height: z.ZodBranded<z.ZodNumber, "height">;
+export type HeightType = z.infer<typeof Height>;
+export declare const ImageCompressionQuality: z.ZodBranded<z.ZodDefault<z.ZodNumber>, "image-compression-quality">;
+export type ImageCompressionQualityType = z.infer<typeof ImageCompressionQuality>;
+export declare const OpenGraphTitleValue: z.ZodString;
+export type OpenGraphTitleValueType = z.infer<typeof OpenGraphTitleValue>;
+export declare const OpenGraphDescriptionValue: z.ZodString;
+export type OpenGraphDescriptionValueType = z.infer<typeof OpenGraphDescriptionValue>;
+export declare const OpenGraphUrlValue: z.ZodString;
+export type OpenGraphUrlValueType = z.infer<typeof OpenGraphUrlValue>;
+export declare const OpenGraphTypeValue: z.ZodUnion<[z.ZodLiteral<"website">, z.ZodLiteral<"article">]>;
+export type OpenGraphTypeValueType = z.infer<typeof OpenGraphTypeValue>;
+export declare const OpenGraphImageUrlValue: z.ZodString;
+export type OpenGraphImageUrlValueType = z.infer<typeof OpenGraphImageUrlValue>;
+export declare const OpenGraphImageTypeValue: z.ZodString;
+export type OpenGraphImageTypeValueType = z.infer<typeof OpenGraphImageTypeValue>;
+export declare const OpenGraphImageWidthValue: z.ZodEffects<z.ZodBranded<z.ZodNumber, "width">, number & z.BRAND<"width">, number>;
+export type OpenGraphImageWidthValueType = z.infer<typeof OpenGraphImageWidthValue>;
+export declare const OpenGraphImageHeightValue: z.ZodEffects<z.ZodBranded<z.ZodNumber, "height">, number & z.BRAND<"height">, number>;
+export type OpenGraphImageHeightValueType = z.infer<typeof OpenGraphImageHeightValue>;
+export declare const CorrelationId: z.ZodBranded<z.ZodDefault<z.ZodString>, "correlation-id">;
+export type CorrelationIdType = z.infer<typeof CorrelationId>;
+export declare enum LogLevelEnum {
+    /** @public */
+    silent = "silent",
+    error = "error",
+    warn = "warn",
+    info = "info",
+    http = "http",
+    verbose = "verbose"
+}
+export declare const LogLevel: z.ZodNativeEnum<typeof LogLevelEnum>;
+export declare const AuthorizationHeader: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, {
+    username: string;
+    password: string;
+}, string>;
+export type AuthorizationHeaderType = z.infer<typeof AuthorizationHeader>;
+export declare const BasicAuthUsername: z.ZodBranded<z.ZodString, "basic-auth-username">;
+export type BasicAuthUsernameType = z.infer<typeof BasicAuthUsername>;
+export declare const BasicAuthPassword: z.ZodBranded<z.ZodString, "basic-auth-password">;
+export type BasicAuthPasswordType = z.infer<typeof BasicAuthPassword>;
+export declare const EmailSubject: z.ZodBranded<z.ZodString, "email-subject">;
+export type EmailSubjectType = z.infer<typeof EmailSubject>;
+export declare const EmailContentHtml: z.ZodBranded<z.ZodString, "email-content-html">;
+export type EmailContentHtmlType = z.infer<typeof EmailContentHtml>;
+export declare const EmailTo: z.ZodBranded<z.ZodString, "email-to">;
+export type EmailToType = z.infer<typeof EmailTo>;
+export declare const EmailAttachment: z.ZodBranded<z.ZodObject<{
+    filename: z.ZodBranded<z.ZodString, "path">;
+    path: z.ZodBranded<z.ZodString, "path">;
+}, "strip", z.ZodTypeAny, {
+    path: string & z.BRAND<"path">;
+    filename: string & z.BRAND<"path">;
+}, {
+    path: string;
+    filename: string;
+}>, "email-attachment">;
+export type EmailAttachmentType = z.infer<typeof EmailAttachment>;
+export declare const hours: number[];
+export declare const Hour: z.ZodEffects<z.ZodNumber, number, number>;
+export type HourType = z.infer<typeof Hour>;
+export declare const Timezone: z.ZodEffects<z.ZodString, string, string>;
+export type TimezoneType = z.infer<typeof Timezone>;
+export declare const TimezoneUTC: z.ZodLiteral<"UTC">;
+export type TimezoneUTCType = z.infer<typeof TimezoneUTC>;
+export declare const BuildVersion: z.ZodBranded<z.ZodString, "build-version">;
+export type BuildVersionType = z.infer<typeof BuildVersion>;
+export declare const EncryptionIV: z.ZodEffects<z.ZodString, Buffer, string>;
+export type EncryptionIVType = z.infer<typeof EncryptionIV>;
+export declare const EncryptionSecret: z.ZodString;
+export type EncryptionSecretType = z.infer<typeof EncryptionSecret>;
+export declare const ReorderingItemPositionValue: z.ZodNumber;
+export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
+export declare const ReorderingCorrelationId: z.ZodString;
+export type ReorderingCorrelationIdType = z.infer<typeof ReorderingCorrelationId>;
+export declare const ReorderingItemId: z.ZodDefault<z.ZodString>;
+export type ReorderingItemIdType = z.infer<typeof ReorderingItemId>;
+export declare const Reordering: z.ZodObject<{
+    correlationId: z.ZodString;
+    id: z.ZodDefault<z.ZodString>;
+    position: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    correlationId: string;
+    id: string;
+    position: number;
+}, {
+    correlationId: string;
+    position: number;
+    id?: string | undefined;
+}>;
+export type ReorderingType = z.infer<typeof Reordering>;
+export declare const Revision: z.ZodNumber;
+export type RevisionType = z.infer<typeof Revision>;

package/dist/server-timing.d.ts

@@ -0,0 +1,7 @@
+import express from "express";
+export declare class ServerTiming {
+    static HEADER: string;
+    static MS_HEADER: string;
+    static applyTo(app: express.Application): void;
+    static handle(_request: express.Request, response: express.Response, next: express.NextFunction): Promise<void>;
+}

package/dist/simple-linear-regression.d.ts

@@ -0,0 +1,18 @@
+import { RoundingStrategy } from "./rounding";
+export type SLRPairType = {
+    x: number;
+    y: number;
+};
+export type SLRParamsType = {
+    a: number;
+    b: number;
+};
+export type SLRPredictionType = number;
+export declare class SimpleLinearRegression {
+    private readonly params;
+    private readonly rounding;
+    constructor(params: SLRParamsType, rounding?: RoundingStrategy);
+    static fromPairs(pairs: SLRPairType[], rounding?: RoundingStrategy): SimpleLinearRegression;
+    predict(x: SLRPairType["x"], strategy?: RoundingStrategy): SLRPredictionType;
+    inspect(): SimpleLinearRegression["params"];
+}

package/dist/simulated-error.d.ts

@@ -0,0 +1,4 @@
+import express from "express";
+export declare class SimulatedError {
+    static throw: (_request: express.Request, _response: express.Response, _next: express.NextFunction) => never;
+}

package/dist/sitemap.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import * as Schema from "./schema";
+export declare const SitemapLoc: z.ZodBranded<z.ZodString, "sitemap-loc">;
+export type SitemapLocType = z.infer<typeof SitemapLoc>;
+export declare const SitemapLastmod: z.ZodBranded<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>, "sitemap-lastmod">;
+export type SitemapLastmodType = z.infer<typeof SitemapLastmod>;
+export declare const SitemapChangefreq: z.ZodBranded<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"always">, z.ZodLiteral<"hourly">, z.ZodLiteral<"daily">, z.ZodLiteral<"weekly">, z.ZodLiteral<"monthly">, z.ZodLiteral<"yearly">, z.ZodLiteral<"never">]>>, "sitemap-changefreq">;
+export type SitemapChangefreqType = z.infer<typeof SitemapChangefreq>;
+export declare const SitemapPriority: z.ZodBranded<z.ZodDefault<z.ZodNumber>, "sitemap-priority">;
+export type SitemapPriorityType = z.infer<typeof SitemapPriority>;
+export declare const SitemapEntry: z.ZodBranded<z.ZodObject<{
+    loc: z.ZodBranded<z.ZodString, "sitemap-loc">;
+    lastmod: z.ZodBranded<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>, "sitemap-lastmod">;
+    changefreq: z.ZodBranded<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"always">, z.ZodLiteral<"hourly">, z.ZodLiteral<"daily">, z.ZodLiteral<"weekly">, z.ZodLiteral<"monthly">, z.ZodLiteral<"yearly">, z.ZodLiteral<"never">]>>, "sitemap-changefreq">;
+    priority: z.ZodBranded<z.ZodDefault<z.ZodNumber>, "sitemap-priority">;
+}, "strip", z.ZodTypeAny, {
+    loc: string & z.BRAND<"sitemap-loc">;
+    lastmod: string & z.BRAND<"sitemap-lastmod">;
+    changefreq: ("never" & z.BRAND<"sitemap-changefreq">) | ("always" & z.BRAND<"sitemap-changefreq">) | ("hourly" & z.BRAND<"sitemap-changefreq">) | ("daily" & z.BRAND<"sitemap-changefreq">) | ("weekly" & z.BRAND<"sitemap-changefreq">) | ("monthly" & z.BRAND<"sitemap-changefreq">) | ("yearly" & z.BRAND<"sitemap-changefreq">);
+    priority: number & z.BRAND<"sitemap-priority">;
+}, {
+    loc: string;
+    lastmod?: string | undefined;
+    changefreq?: "never" | "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | undefined;
+    priority?: number | undefined;
+}>, "sitemap-entry">;
+export type SitemapEntryType = z.infer<typeof SitemapEntry>;
+export type SitemapConfigType = {
+    path?: Schema.PathType;
+    entries: SitemapEntryType[];
+    BASE_URL: Schema.UrlWithoutTrailingSlashType;
+};
+export declare class Sitemap {
+    static DEFAULT_PATH: string & z.BRAND<"path">;
+    private static generate;
+    static save(config: SitemapConfigType): Promise<void>;
+}

package/dist/size.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import * as Schema from "./schema";
+export declare enum SizeUnit {
+    b = "b",
+    kB = "kB",
+    MB = "MB",
+    GB = "GB"
+}
+declare const SizeValue: z.ZodNumber;
+export type SizeValueType = z.infer<typeof SizeValue>;
+export type SizeConfigType = {
+    unit: SizeUnit;
+    value: SizeValueType;
+};
+export declare class Size {
+    private readonly unit;
+    private readonly value;
+    private readonly bytes;
+    private static readonly KB_MULTIPLIER;
+    private static readonly MB_MULTIPLIER;
+    private static readonly GB_MULTIPLIER;
+    constructor(config: SizeConfigType);
+    toString(): string;
+    toBytes(): Schema.SizeInBytesType;
+    isGreaterThan(another: Size): boolean;
+    format(unit: SizeUnit): string;
+    static toBytes(config: SizeConfigType): Schema.SizeInBytesType;
+    static unit: typeof SizeUnit;
+    private calculateBytes;
+}
+export {};

package/dist/sleep.d.ts

@@ -0,0 +1,3 @@
+export declare function sleep(config: {
+    ms: number;
+}): Promise<unknown>;

package/dist/slower.d.ts

@@ -0,0 +1,8 @@
+import express from "express";
+type SlowerConfigType = {
+    ms?: number;
+};
+export declare class Slower {
+    static build(config?: SlowerConfigType): (_request: express.Request, _response: express.Response, next: express.NextFunction) => Promise<void>;
+}
+export {};

package/dist/static-files.d.ts

@@ -0,0 +1,14 @@
+import express from "express";
+import expressStaticGzip from "express-static-gzip";
+import * as Schema from "./schema";
+type StaticGzipOptionsType = expressStaticGzip.ExpressStaticGzipOptions;
+export type StaticFilesConfigType = Partial<{
+    path: Schema.PathType;
+} & StaticGzipOptionsType>;
+export declare class StaticFiles {
+    private readonly path;
+    private readonly staticGzipOptions;
+    constructor(config?: StaticFilesConfigType);
+    applyTo(app: express.Application): void;
+}
+export {};

package/dist/stepper.d.ts

@@ -0,0 +1,23 @@
+type StepType = number;
+type StepperConfigType = {
+    total: StepType;
+};
+export declare class Stepper {
+    static readonly DEFAULT_CURRENT = 1;
+    private current;
+    private readonly total;
+    constructor(config: StepperConfigType);
+    continue(): Stepper;
+    read(): {
+        finished: boolean;
+        raw: {
+            current: number;
+            total: number;
+        };
+        formatted: string;
+    };
+    reset(): Stepper;
+    format(): string;
+    isFinished(): boolean;
+}
+export {};

package/dist/stopwatch.d.ts

@@ -0,0 +1,14 @@
+import { TimestampType } from "./schema";
+export declare enum StopwatchState {
+    started = "started",
+    stopped = "finished"
+}
+export type StopwatchResultType = {
+    durationMs: TimestampType;
+};
+export declare class Stopwatch {
+    private state;
+    private readonly startMs;
+    private stopMs;
+    stop(): StopwatchResultType;
+}

package/dist/streak-calculator.d.ts

@@ -0,0 +1,14 @@
+import { format } from "date-fns";
+type DateType = string;
+export type StreakType = {
+    cutoff: DateType;
+    dates: DateType[];
+    streak: number;
+};
+export declare class StreakCalculator {
+    private readonly cutoff;
+    constructor();
+    calculate(_dates: DateType[]): StreakType;
+    static format(date: Parameters<typeof format>[0]): DateType;
+}
+export {};

package/dist/sum.d.ts

@@ -0,0 +1,3 @@
+export declare class Sum {
+    static of(values: number[]): number;
+}

package/dist/thousands-separator.d.ts

@@ -0,0 +1,4 @@
+export declare class ThousandsSeparator {
+    private static DEFAULT_SEPARATOR;
+    static format(value: number, separator?: string): string;
+}

package/dist/time-zone-offset.d.ts

@@ -0,0 +1,17 @@
+import * as bg from "@bgord/node";
+export declare type TimeZoneOffsetVariables = {
+    timeZoneOffset: {
+        minutes: bg.Schema.TimeZoneOffsetValueType;
+        seconds: bg.Schema.TimeZoneOffsetValueType;
+        miliseconds: bg.Schema.TimeZoneOffsetValueType;
+    };
+};
+export declare class TimeZoneOffset {
+    static TIME_ZONE_OFFSET_HEADER_NAME: string;
+    static attach: import("hono/types").MiddlewareHandler<{
+        Bindings: any;
+        Variables: any;
+    }, string, {}>;
+    static adjustTimestamp(timestamp: bg.Schema.TimestampType, timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType): bg.Schema.TimestampType;
+    static adjustDate(timestamp: bg.Schema.TimestampType, timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType): Date;
+}