@zoodogood/utils 1.1.2-change.1051 → 1.1.3-change.1055

package/lib/discordjs/helpers.d.ts

@@ -0,0 +1,18 @@
+export type APIBaseButton = import("discord-api-types/v10").APIButtonComponentBase<any>;
+/**
+ * @typedef {import("discord-api-types/v10").APIButtonComponentBase} APIBaseButton
+ */
+/**
+ *
+ * @param {Partial<APIBaseButton>[]} resolable
+ */
+export function justButtonComponents(resolable: Partial<import("discord-api-types/v10").APIButtonComponentBase<any>>[]): {
+    label?: string | undefined;
+    style: any;
+    emoji?: import("discord-api-types/v10").APIMessageComponentEmoji | undefined;
+    disabled?: boolean | undefined;
+    type: import("discord-api-types/v10").ComponentType.Button | ComponentType;
+    customId: string;
+}[];
+export function justSendMessage(target: any, options: any): Promise<any>;
+import { ComponentType as ComponentType_1 } from "discord.js";

package/lib/discordjs/helpers.js

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BaseInteraction, ButtonStyle, ComponentType } from "discord.js";
+import { CreateMessage } from "./simplify.js";
+const DEFAULTS_FOR_BUTTON = {
+    type: ComponentType.Button,
+    style: ButtonStyle.Secondary,
+};
+/**
+ * @typedef {import("discord-api-types/v10").APIButtonComponentBase} APIBaseButton
+ */
+/**
+ *
+ * @param {Partial<APIBaseButton>[]} resolable
+ */
+function justButtonComponents(resolable) {
+    const buttons = resolable.map((data, i) => (Object.assign(Object.assign(Object.assign({}, DEFAULTS_FOR_BUTTON), { customId: `button.${i + 1}` }), data)));
+    return buttons;
+}
+function justSendMessage(target, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messagePayload = CreateMessage(options);
+        const message = target instanceof BaseInteraction
+            ? yield (options.edit
+                ? target.replied
+                    ? target.editReply(messagePayload)
+                    : target.update(messagePayload)
+                : target.reply(messagePayload))
+            : yield (options.edit
+                ? target.edit(messagePayload)
+                : target.send(messagePayload));
+        if (options.delete) {
+            setTimeout(() => message.delete(), options.delete);
+        }
+        if (options.reactions) {
+            options.reactions.filter(Boolean).forEach((react) => message.react(react));
+        }
+        return message;
+    });
+}
+export { justButtonComponents, justSendMessage };

package/lib/discordjs/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./helpers.js";
+export * from "./simplify.js";

package/lib/discordjs/mod.js

@@ -0,0 +1,2 @@
+export * from "./helpers.js";
+export * from "./simplify.js";

package/lib/discordjs/simplify.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Create a message object for Discord.
+ *
+ * @param {Object} params = Parameters for creating the message.
+ * @param {string} [params.content] - The message content.
+ * @param {string} [params.title] - The title of the embed.
+ * @param {string} [params.url] - The URL of the embed.
+ * @param {Object} [params.author] - The author of the embed.
+ * @param {string} [params.thumbnail] - The thumbnail URL of the embed.
+ * @param {string} [params.description] - The description of the embed.
+ * @param {string} [params.color] - The color of the embed.
+ * @param {Object[]} [params.fields] - The fields of the embed.
+ * @param {string} [params.image] - The image URL of the embed.
+ * @param {string} [params.video] - The video URL of the embed.
+ * @param {Object} [params.footer] - The footer of the embed.
+ * @param {string} [params.timestamp] - The timestamp of the embed.
+ * @param {boolean} [params.ephemeral] - Whether the message should be ephemeral.
+ * @param {boolean} [params.fetchReply] - Whether to fetch the message reply.
+ * @param {Object[] | Object} [params.components] - The message components.
+ * @param {Object[] | Object[]} [params.files] - The message files.
+ * @param {string} [params.reference] - The message reference.
+ * @returns {Object} - The message object.
+ */
+export function CreateMessage({ content, title, url, author, thumbnail, description, color, fields, image, video, footer, timestamp, ephemeral, fetchReply, components, files, reference, }: {
+    content?: string | undefined;
+    title?: string | undefined;
+    url?: string | undefined;
+    author?: Object | undefined;
+    thumbnail?: string | undefined;
+    description?: string | undefined;
+    color?: string | undefined;
+    fields?: Object[] | undefined;
+    image?: string | undefined;
+    video?: string | undefined;
+    footer?: Object | undefined;
+    timestamp?: string | undefined;
+    ephemeral?: boolean | undefined;
+    fetchReply?: boolean | undefined;
+    components?: Object | Object[] | undefined;
+    files?: Object[] | undefined;
+    reference?: string | undefined;
+}): Object;
+export function CreateModal({ title, customId, components }: {
+    title: any;
+    customId: any;
+    components: any;
+}): import("discord.js").APIModalInteractionResponseCallbackData;
+export function SimplifyComponents(data: any): any;
+/**
+ *
+ * @param {*} embed
+ * @returns {boolean}
+ */
+export function isEmptyEmbed(embed: any): boolean;

package/lib/discordjs/simplify.js

@@ -0,0 +1,116 @@
+import { EmbedBuilder, ModalBuilder, resolveColor, ActionRow, } from "discord.js";
+import { ComponentType } from "discord-api-types/v10";
+/**
+ *
+ * @param {*} embed
+ * @returns {boolean}
+ */
+function isEmptyEmbed(embed) {
+    const DEFAULT_PROPERTIES = {
+        title: undefined,
+        author: undefined,
+        thumbnail: undefined,
+        description: undefined,
+        fields: undefined,
+        image: undefined,
+        footer: undefined,
+        timestamp: undefined,
+        video: undefined,
+    };
+    // in isEmptyEmbed context is a good compare
+    const isEqualDefault = (key) => String(embed[key]) === String(DEFAULT_PROPERTIES[key]);
+    const isEveryPropertyDefault = Object.keys(DEFAULT_PROPERTIES).every(isEqualDefault);
+    return isEveryPropertyDefault;
+}
+/**
+ * Create a message object for Discord.
+ *
+ * @param {Object} params = Parameters for creating the message.
+ * @param {string} [params.content] - The message content.
+ * @param {string} [params.title] - The title of the embed.
+ * @param {string} [params.url] - The URL of the embed.
+ * @param {Object} [params.author] - The author of the embed.
+ * @param {string} [params.thumbnail] - The thumbnail URL of the embed.
+ * @param {string} [params.description] - The description of the embed.
+ * @param {string} [params.color] - The color of the embed.
+ * @param {Object[]} [params.fields] - The fields of the embed.
+ * @param {string} [params.image] - The image URL of the embed.
+ * @param {string} [params.video] - The video URL of the embed.
+ * @param {Object} [params.footer] - The footer of the embed.
+ * @param {string} [params.timestamp] - The timestamp of the embed.
+ * @param {boolean} [params.ephemeral] - Whether the message should be ephemeral.
+ * @param {boolean} [params.fetchReply] - Whether to fetch the message reply.
+ * @param {Object[] | Object} [params.components] - The message components.
+ * @param {Object[] | Object[]} [params.files] - The message files.
+ * @param {string} [params.reference] - The message reference.
+ * @returns {Object} - The message object.
+ */
+function CreateMessage({ content, title, url, author, thumbnail, description, color, fields, image, video, footer, timestamp, ephemeral, fetchReply, components, files, reference, }) {
+    const message = {};
+    thumbnail && (thumbnail = { url: thumbnail });
+    image && (image = { url: image });
+    video && (video = { url: video });
+    color = resolveColor(color !== null && color !== void 0 ? color : "Random");
+    const embed = new EmbedBuilder({
+        title,
+        url,
+        author,
+        thumbnail,
+        description,
+        color,
+        fields,
+        image,
+        video,
+        footer,
+        timestamp,
+    });
+    if (!isEmptyEmbed(embed.data)) {
+        message.embeds = [embed];
+    }
+    if (files) {
+        message.files = files;
+    }
+    if (reference)
+        message.reply = {
+            messageReference: reference,
+        };
+    message.components = components ? SimplifyComponents(components) : null;
+    message.content = content;
+    message.ephemeral = ephemeral;
+    message.fetchReply = fetchReply;
+    return message;
+}
+function CreateModal({ title, customId, components }) {
+    components = SimplifyComponents(components);
+    return new ModalBuilder({ title, customId, components }).toJSON();
+}
+function SimplifyComponents(data) {
+    if (data instanceof Array && data.length === 0)
+        return [];
+    const isComponent = (component) => "type" in component && component.type !== ComponentType.ActionRow;
+    const isActionRow = (component) => (component instanceof Array && isComponent(component.at(0))) ||
+        component instanceof ActionRow;
+    const isComponents = (component) => component instanceof Array && isActionRow(component.at(0));
+    const argumentType = [
+        isComponent(data),
+        isActionRow(data),
+        isComponents(data),
+    ].findIndex(Boolean);
+    if (argumentType === -1)
+        throw new TypeError("expected component");
+    const wrapToArray = (component) => [component];
+    const arrayToActionRow = (componentsArray) => {
+        const isActionRow = "type" in componentsArray &&
+            componentsArray.type === ComponentType.ActionRow;
+        if (isActionRow)
+            return componentsArray;
+        return { type: ComponentType.ActionRow, components: componentsArray };
+    };
+    if (argumentType <= 0)
+        data = wrapToArray(data);
+    if (argumentType <= 1)
+        data = wrapToArray(data);
+    data = data.map(arrayToActionRow);
+    return data;
+}
+export { CreateMessage, CreateModal, SimplifyComponents, isEmptyEmbed };

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './primitives/mod.js';
+export * from './objectives/mod.js';

package/lib/nodejs/getChildProcessUtils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ChildProcessWithoutNullStreams } from "child_process";
+import EventsEmitter from "events";
+interface IContext {
+    exitter: {
+        resolve: any;
+        reject: any;
+    };
+    whenEnd: Promise<unknown>;
+    child: ChildProcessWithoutNullStreams;
+    emitter: EventsEmitter;
+    outString: string;
+}
+interface IParams {
+    root: string;
+    logger?: boolean;
+}
+declare const _default: ({ root, logger }: IParams) => {
+    run: (command: string, params: string[]) => IContext;
+    info: (log: string) => void;
+    _npm: string;
+};
+export default _default;

package/lib/nodejs/getChildProcessUtils.js

@@ -0,0 +1,98 @@
+import { spawn } from "child_process";
+import EventsEmitter from "events";
+export default ({ root, logger = false }) => {
+    // Solve problem: https://stackoverflow.com/questions/43230346/error-spawn-npm-enoent
+    const _npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const EventsCallbacks = [
+        {
+            key: "stdoutError",
+            callback({ exitter }, error) {
+                logger && info(`Error: ${error.message}`);
+                exitter.reject(error);
+            },
+        },
+        {
+            key: "stderrError",
+            callback({ exitter }, error) {
+                logger && info(`Error: ${error.message}`);
+                exitter.reject(error);
+            },
+        },
+        {
+            key: "stdoutData",
+            callback(context, data) {
+                const content = String(data);
+                context.emitter.emit("data", content);
+                context.outString = context.outString.concat(content);
+                logger && console.info(content);
+            },
+        },
+        {
+            key: "stderrData",
+            callback(context, data) {
+                const content = String(data);
+                context.emitter.emit("data", content);
+                context.outString = context.outString.concat(content);
+                logger && console.info(content);
+            },
+        },
+        {
+            key: "message",
+            callback(_context, data) {
+                logger && console.info(data.toString());
+            },
+        },
+        {
+            key: "exit",
+            callback({ exitter, outString }) {
+                exitter.resolve(outString);
+            },
+        },
+        {
+            key: "error",
+            callback({ exitter }, error) {
+                logger && info(`Error: ${error.message}`);
+                exitter.reject(error);
+            },
+        },
+    ];
+    const info = (log) => console.info(`\x1b[1m${log}\x1b[22m`);
+    const run = (command, params) => {
+        const child = spawn(command, params, { cwd: root });
+        const exitter = { resolve: null, reject: null };
+        const promise = new Promise((resolve, reject) => Object.assign(exitter, { resolve, reject }));
+        const emitter = new EventsEmitter();
+        const outString = "";
+        const context = {
+            exitter,
+            whenEnd: promise,
+            child,
+            emitter,
+            outString,
+        };
+        const events = Object.fromEntries(EventsCallbacks.map(({ callback, key }) => [
+            key,
+            callback.bind(null, context),
+        ]));
+        (() => {
+            child.stdout.on("error", events.stdoutError);
+            child.stderr.on("error", events.stderrError);
+            child.stdout.on("data", events.stdoutData);
+            child.stderr.on("data", events.stderrData);
+            child.on("error", events.error);
+            child.on("message", events.message);
+            child.on("exit", events.exit);
+        })();
+        promise.finally(() => {
+            child.stdout.removeListener("error", events.stdoutError);
+            child.stderr.removeListener("error", events.stderrError);
+            child.stdout.removeListener("data", events.stdoutData);
+            child.stderr.removeListener("data", events.stderrData);
+            child.removeListener("error", events.error);
+            child.removeListener("message", events.message);
+            child.removeListener("exit", events.exit);
+        });
+        return context;
+    };
+    return { run, info, _npm };
+};

package/lib/nodejs/mod.d.ts

@@ -0,0 +1 @@
+export { default as getChildProcessUtils } from './getChildProcessUtils.js';

package/lib/nodejs/mod.js

@@ -0,0 +1 @@
+export { default as getChildProcessUtils } from './getChildProcessUtils.js';

package/lib/objectives/CustomCollector.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+interface ICustomCollectorOptions {
+    target: Required<{
+        removeListener: CallableFunction;
+        on: CallableFunction;
+    }>;
+    event: string;
+    filter?: Function;
+    time: number;
+}
+declare class CustomCollector {
+    #private;
+    timeoutId?: NodeJS.Timeout;
+    target: ICustomCollectorOptions["target"];
+    event: ICustomCollectorOptions["event"];
+    filter: ICustomCollectorOptions["filter"];
+    time: ICustomCollectorOptions["time"];
+    constructor({ target, event, filter, time }: ICustomCollectorOptions);
+    setCallback(callback: CallableFunction): void;
+    handle(handler: CallableFunction): void;
+    end(): void;
+    removeTimeout(): void;
+    setTimeout(ms: number): void;
+}
+export { CustomCollector };

package/lib/objectives/CustomCollector.js

@@ -0,0 +1,59 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CustomCollector_callback;
+class CustomCollector {
+    constructor({ target, event, filter, time = 0 }) {
+        _CustomCollector_callback.set(this, void 0);
+        if ("on" in target === false) {
+            throw new Error("Target must be similar to EventEmitter.prototype — target haven't method 'on'");
+        }
+        this.target = target;
+        this.event = event;
+        this.filter = filter;
+        this.time = time;
+    }
+    setCallback(callback) {
+        const handler = (...params) => {
+            const passed = !this.filter || this.filter(params);
+            if (!!passed === true) {
+                // @ts-ignore
+                callback.apply(this, params);
+            }
+        };
+        this.handle(handler);
+    }
+    handle(handler) {
+        this.end();
+        __classPrivateFieldSet(this, _CustomCollector_callback, handler, "f");
+        this.target.on(this.event, __classPrivateFieldGet(this, _CustomCollector_callback, "f"));
+        if (this.time > 0) {
+            this.setTimeout(this.time);
+        }
+    }
+    end() {
+        if (this.timeoutId) {
+            this.removeTimeout();
+        }
+        if (__classPrivateFieldGet(this, _CustomCollector_callback, "f")) {
+            this.target.removeListener(this.event, __classPrivateFieldGet(this, _CustomCollector_callback, "f"));
+        }
+    }
+    removeTimeout() {
+        clearTimeout(this.timeoutId);
+    }
+    setTimeout(ms) {
+        const callback = this.end.bind(this);
+        this.timeoutId = setTimeout(callback, ms);
+    }
+}
+_CustomCollector_callback = new WeakMap();
+export { CustomCollector };

package/lib/objectives/DotNotatedInterface.d.ts

@@ -0,0 +1,23 @@
+interface IMethodsOptions {
+    defaultValue?: any;
+    allowSetFunctions?: boolean;
+}
+export declare class DotNotatedInterface {
+    target: Record<string, unknown>;
+    constructor(target: DotNotatedInterface["target"]);
+    getItem<T>(key: string, options?: IMethodsOptions): T | null;
+    setItem<T>(key: string, value: CallableFunction, options?: IMethodsOptions): T;
+    hasItem(key: string, options?: IMethodsOptions): boolean;
+    removeItem(key: string, options?: IMethodsOptions): boolean;
+    getParentAndlastSegmentByNotatedKey(key: string, { needFillIfParentNotExists }: {
+        needFillIfParentNotExists?: boolean | undefined;
+    }): {
+        parent: object | null;
+        lastSegment: string;
+    };
+    fillIsNotExists({ parent, segment, }: {
+        parent: {};
+        segment: string;
+    }): string;
+}
+export {};

package/lib/objectives/DotNotatedInterface.js

@@ -0,0 +1,60 @@
+export class DotNotatedInterface {
+    constructor(target) {
+        this.target = target;
+    }
+    getItem(key, options = {}) {
+        var _a;
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (!parent || lastSegment in parent === false) {
+            return (_a = options.defaultValue) !== null && _a !== void 0 ? _a : null;
+        }
+        // @ts-ignore
+        return parent[lastSegment];
+    }
+    setItem(key, value, options = {}) {
+        if (typeof value === "function" && !options.allowSetFunctions) {
+            value = value(this.getItem(key, options));
+        }
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: true });
+        // @ts-ignore
+        return (parent[lastSegment] = value);
+    }
+    hasItem(key, options = {}) {
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (parent === null) {
+            return false;
+        }
+        return lastSegment in parent;
+    }
+    removeItem(key, options = {}) {
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (!parent) {
+            return false;
+        }
+        // @ts-ignore
+        return delete parent[lastSegment];
+    }
+    getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists = false }) {
+        const pathSegments = key.split(".");
+        if (!pathSegments.length) {
+            throw new Error("Empty path to property");
+        }
+        let parent = this.target;
+        for (let segment of pathSegments.slice(0, -1)) {
+            needFillIfParentNotExists &&
+                (segment = this.fillIsNotExists({ parent, segment }));
+            if (parent[segment] === undefined) {
+                return { parent: null, lastSegment: segment };
+            }
+            parent = parent[segment];
+        }
+        return { parent, lastSegment: pathSegments.at(-1) };
+    }
+    fillIsNotExists({ parent, segment, }) {
+        if (segment in parent === false) {
+            // @ts-ignore
+            parent[segment] = {};
+        }
+        return segment;
+    }
+}

package/lib/objectives/ExtendedEnum/BooleanWithMessage.d.ts

@@ -0,0 +1,13 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+declare class True<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+declare class False<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+export declare class BooleanWithMessage extends BaseExtendedEnum {
+    static True: typeof True;
+    static False: typeof False;
+}
+export type TBooleanWithMessage<T = unknown, E = unknown> = True<T> | False<E>;
+export {};

package/lib/objectives/ExtendedEnum/BooleanWithMessage.js

@@ -0,0 +1,11 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+class True extends BaseExtendedEnumPartial {
+}
+True.value = 1;
+class False extends BaseExtendedEnumPartial {
+}
+False.value = 0;
+export class BooleanWithMessage extends BaseExtendedEnum {
+}
+BooleanWithMessage.True = True;
+BooleanWithMessage.False = False;

package/lib/objectives/ExtendedEnum/Option.d.ts

@@ -0,0 +1,13 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+declare class Some<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+declare class None<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+export declare class Option extends BaseExtendedEnum {
+    static Some: typeof Some;
+    static None: typeof None;
+}
+export type TOption<T = unknown, E = unknown> = Some<T> | None<E>;
+export {};

package/lib/objectives/ExtendedEnum/Option.js

@@ -0,0 +1,11 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+class Some extends BaseExtendedEnumPartial {
+}
+Some.value = 1;
+class None extends BaseExtendedEnumPartial {
+}
+None.value = 0;
+export class Option extends BaseExtendedEnum {
+}
+Option.Some = Some;
+Option.None = None;

package/lib/objectives/ExtendedEnum/Result.d.ts

@@ -0,0 +1,18 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+declare class Ok<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+declare class Err<T> extends BaseExtendedEnumPartial<T> {
+    static value: number;
+}
+export declare class Result extends BaseExtendedEnum {
+    static Ok: typeof Ok;
+    static Err: typeof Err;
+    static StatusProcessing: number;
+    static StatusSuccess: number;
+    static StatusNotFound: number;
+    static StatusImTeapot: number;
+    static StatusInternalError: number;
+}
+export type TResult<T = unknown, E = unknown> = Ok<T> | Err<E>;
+export {};

package/lib/objectives/ExtendedEnum/Result.js

@@ -0,0 +1,16 @@
+import { BaseExtendedEnum, BaseExtendedEnumPartial } from "./main.js";
+class Ok extends BaseExtendedEnumPartial {
+}
+Ok.value = 1;
+class Err extends BaseExtendedEnumPartial {
+}
+Err.value = 0;
+export class Result extends BaseExtendedEnum {
+}
+Result.Ok = Ok;
+Result.Err = Err;
+Result.StatusProcessing = 102;
+Result.StatusSuccess = 200;
+Result.StatusNotFound = 404;
+Result.StatusImTeapot = 418;
+Result.StatusInternalError = 500;

package/lib/objectives/ExtendedEnum/index.d.ts

@@ -0,0 +1 @@
+export * from "./mod.js";

package/lib/objectives/ExtendedEnum/index.js

@@ -0,0 +1 @@
+export * from "./mod.js";

package/lib/objectives/ExtendedEnum/main.d.ts

@@ -0,0 +1,17 @@
+export declare class BaseExtendedEnumPartial<T = undefined> {
+    #private;
+    static value: number;
+    static from(data: object): any;
+    get props(): T | undefined;
+    set props(props: T);
+    constructor(props: T);
+    includes(props: T): boolean;
+    some(props: T): boolean;
+    is(constructor: typeof BaseExtendedEnumPartial): boolean;
+    toBoolean(): boolean;
+    unwrap(): T | undefined;
+    expect(message?: string): T | undefined;
+}
+export declare class BaseExtendedEnum {
+    static is(instance: BaseExtendedEnumPartial<unknown>, constructor: typeof BaseExtendedEnumPartial): boolean;
+}