nesoi 3.0.0

package/lib/elements/entities/bucket/view/bucket_view.builder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketViewBuilder = void 0;
+const bucket_view_schema_1 = require("./bucket_view.schema");
+const bucket_view_field_builder_1 = require("./bucket_view_field.builder");
+class BucketViewBuilder {
+    constructor(name) {
+        this.name = name;
+        this._fields = {};
+    }
+    fields($) {
+        const fieldBuilder = new bucket_view_field_builder_1.BucketViewFieldFactory(this);
+        this._fields = $(fieldBuilder);
+        return this;
+    }
+    // Build
+    static build(builder, model, graph, views) {
+        const fields = bucket_view_field_builder_1.BucketViewFieldBuilder.buildFields(builder._fields, model, graph, views);
+        const schema = new bucket_view_schema_1.$BucketView(builder.name, fields);
+        schema.fields.id = new bucket_view_schema_1.$BucketViewField('id', 'model', 'id', 'id', false, true, { model: { key: 'id' } });
+        return schema;
+    }
+}
+exports.BucketViewBuilder = BucketViewBuilder;

package/lib/elements/entities/bucket/view/bucket_view.d.ts

@@ -0,0 +1,10 @@
+import { NesoiObj } from "../../../../engine/data/obj";
+import { Bucket } from '../bucket';
+import { $BucketView } from './bucket_view.schema';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+export declare class BucketView<$ extends $BucketView> {
+    private bucket;
+    schema: $;
+    constructor(bucket: Bucket<any, any>, schema: $);
+    parse<Obj extends NesoiObj>(trx: AnyTrxNode, raw: Obj): Promise<$['#data']>;
+}

package/lib/elements/entities/bucket/view/bucket_view.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketView = void 0;
+const promise_1 = __importDefault(require("../../../../engine/util/promise"));
+const tree_1 = require("../../../../engine/data/tree");
+class BucketView {
+    constructor(bucket, schema) {
+        this.bucket = bucket;
+        this.schema = schema;
+    }
+    async parse(trx, raw) {
+        const bucket = this.bucket;
+        const doParse = async (schema, index) => {
+            const parsedObj = {};
+            // Model props
+            for (const k in schema) {
+                const prop = schema[k];
+                if (prop.scope !== 'model') {
+                    continue;
+                }
+                const value = prop.value.model;
+                const rawValue = tree_1.Tree.get(raw, value.key, index);
+                if (prop.children) {
+                    if (prop.array) {
+                        if (!Array.isArray(rawValue)) {
+                            continue;
+                        }
+                        const parsedArray = [];
+                        for (let i = 0; i < rawValue.length; i++) {
+                            const child = await doParse(prop.children, [...(index || []), i]);
+                            parsedArray.push(child);
+                        }
+                        parsedObj[k] = parsedArray;
+                        continue;
+                    }
+                    else if (prop.type === 'dict') {
+                        if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+                            continue;
+                        }
+                        const parsedArray = [];
+                        for (const k in rawValue) {
+                            const child = await doParse(prop.children, [...(index || []), k]);
+                            parsedArray.push(child);
+                        }
+                        parsedObj[k] = parsedArray;
+                        continue;
+                    }
+                    else {
+                        parsedObj[k] = await doParse(prop.children, index || []);
+                        continue;
+                    }
+                }
+                parsedObj[k] = rawValue;
+            }
+            // Computed props
+            for (const k in schema) {
+                const prop = schema[k];
+                if (prop.$t !== 'bucket.view.field') {
+                    continue;
+                }
+                if (prop.scope !== 'computed') {
+                    continue;
+                }
+                const value = prop.value.computed;
+                parsedObj[k] = await promise_1.default.solve(value.fn({ trx, raw, bucket: bucket.schema }));
+            }
+            // Graph props
+            for (const k in schema) {
+                const prop = schema[k];
+                if (prop.$t !== 'bucket.view.field') {
+                    continue;
+                }
+                if (prop.scope !== 'graph') {
+                    continue;
+                }
+                const value = prop.value.graph;
+                parsedObj[k] = await promise_1.default.solve(bucket.graph.readLink(trx, value.link, raw, value.view, index || []));
+            }
+            // Group props
+            for (const k in schema) {
+                const prop = schema[k];
+                if (prop.$t !== 'bucket.view.field') {
+                    continue;
+                }
+                if (prop.scope !== 'group') {
+                    continue;
+                }
+                parsedObj[k] = await doParse(prop.children || {}, index);
+            }
+            return parsedObj;
+        };
+        const parsedObj = await doParse(this.schema.fields, null);
+        return {
+            id: raw.id,
+            ...parsedObj
+        };
+    }
+}
+exports.BucketView = BucketView;

package/lib/elements/entities/bucket/view/bucket_view.schema.d.ts

@@ -0,0 +1,55 @@
+import { $BucketModelFieldType } from '../model/bucket_model.schema';
+import { $Bucket } from '../bucket.schema';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket> = (ctx: {
+    trx: TrxNode;
+    raw: B['#data'];
+    bucket: $Bucket;
+}) => any | Promise<any>;
+export type $BucketViewFieldValue = {
+    model?: {
+        key: string;
+        enumOptions?: string | string[];
+    };
+    graph?: {
+        link: string;
+        view?: string;
+    };
+    computed?: {
+        fn: $BucketViewFieldFn<any, any>;
+    };
+    view?: {
+        view: string;
+    };
+    group?: {};
+};
+export declare class $BucketViewField {
+    name: string;
+    scope: 'model' | 'graph' | 'computed' | 'group' | 'view';
+    type: $BucketModelFieldType | 'id';
+    alias: string;
+    array: boolean | 'unknown';
+    required: boolean;
+    value: $BucketViewFieldValue;
+    children?: $BucketViewFields | undefined;
+    $t: string;
+    '#data': unknown;
+    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view', type: $BucketModelFieldType | 'id', alias: string, array: boolean | 'unknown', required: boolean, value: $BucketViewFieldValue, children?: $BucketViewFields | undefined);
+}
+export type $BucketViewFields = {
+    [x: string]: $BucketViewField;
+};
+export type $BucketViewFieldTree = {
+    [x: string]: $BucketViewField | $BucketViewFieldTree;
+};
+export declare class $BucketView {
+    name: string;
+    fields: $BucketViewFields;
+    $t: string;
+    '#data': unknown;
+    constructor(name: string, fields?: $BucketViewFields);
+    static getField(schema: $BucketView, path: string): $BucketViewField | undefined;
+}
+export type $BucketViews = {
+    [x: string]: $BucketView;
+};

package/lib/elements/entities/bucket/view/bucket_view.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$BucketView = exports.$BucketViewField = void 0;
+class $BucketViewField {
+    constructor(name, scope, type, alias, array, required, value, children) {
+        this.name = name;
+        this.scope = scope;
+        this.type = type;
+        this.alias = alias;
+        this.array = array;
+        this.required = required;
+        this.value = value;
+        this.children = children;
+        this.$t = 'bucket.view.field';
+    }
+}
+exports.$BucketViewField = $BucketViewField;
+class $BucketView {
+    constructor(name, fields = {}) {
+        this.name = name;
+        this.fields = fields;
+        this.$t = 'bucket.view';
+    }
+    static getField(schema, path) {
+        const find = (fields, path) => {
+            const term = path[0];
+            if (term in fields) {
+                const field = fields[term];
+                if (path.length === 1) {
+                    return field;
+                }
+                if (!field.children) {
+                    return undefined;
+                }
+                return find(field.children, path.slice(1));
+            }
+            return undefined;
+        };
+        return find(schema.fields, path.split('.'));
+    }
+}
+exports.$BucketView = $BucketView;

package/lib/elements/entities/bucket/view/bucket_view_field.builder.d.ts

@@ -0,0 +1,37 @@
+import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldValue, $BucketViewFields, $BucketViews } from './bucket_view.schema';
+import { $Module, $Space, ViewObj } from "../../../../schema";
+import { $BucketModel } from '../model/bucket_model.schema';
+import { $BucketGraph } from '../graph/bucket_graph.schema';
+import { BucketViewBuilder } from './bucket_view.builder';
+import { $Bucket } from '../bucket.schema';
+import { $BucketViewFieldBuilderInfer } from '../bucket.infer';
+import { TrxNode } from "../../../../engine/transaction/trx_node";
+type GraphLinkBucket<Bucket extends $Bucket, L extends keyof Bucket['graph']['links']> = Bucket['graph']['links'][L]['#bucket'];
+type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> = R extends Promise<infer X> ? X : R;
+export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
+    private _view;
+    protected scope: $BucketViewField['scope'];
+    protected type: $BucketViewField['type'];
+    protected value: $BucketViewField['value'];
+    constructor(_view: BucketViewBuilder<any, any, any>);
+    model<K extends keyof Bucket['#fieldpath'], Extra extends BucketViewFieldBuilderTree>(key: K, extra?: Extra): BucketViewFieldBuilder<Bucket["#fieldpath"][K], "model", never>;
+    computed<Fn extends $BucketViewFieldFn<TrxNode<Space, Module, Space['authnUsers']>, Bucket>>(fn: Fn): BucketViewFieldBuilder<ComputedData<Fn, ReturnType<Fn>>, "computed", never>;
+    graph<L extends keyof Bucket['graph']['links'], LinkBucket extends GraphLinkBucket<Bucket, L>, V extends (keyof LinkBucket['views']) | undefined>(link: L, view?: V): BucketViewFieldBuilder<undefined extends V ? LinkBucket["#data"] : ViewObj<LinkBucket, NonNullable<V>>, "graph", `${LinkBucket["name"]}.${V & string}`>;
+    view<ViewName extends keyof Bucket['views'], View extends Bucket['views'][ViewName]>(view: ViewName): BucketViewFieldBuilder<View["#data"], "view", never>;
+    extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilderTree>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
+    static group(name: string, children: $BucketViewFields): $BucketViewField;
+}
+export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
+    protected scope: $BucketViewField['scope'];
+    protected value: $BucketViewFieldValue;
+    protected refKey?: string | undefined;
+    protected extra?: BucketViewFieldBuilderTree | undefined;
+    protected type: $BucketViewField['type'];
+    constructor(scope: $BucketViewField['scope'], value: $BucketViewFieldValue, refKey?: string | undefined, extra?: BucketViewFieldBuilderTree | undefined);
+    static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string): $BucketViewField;
+    static buildFields(fields: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews): $BucketViewFields;
+}
+export type BucketViewFieldBuilderTree = {
+    [x: string]: BucketViewFieldBuilder<any, any, any> | BucketViewFieldBuilderTree;
+};
+export {};

package/lib/elements/entities/bucket/view/bucket_view_field.builder.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketViewFieldBuilder = exports.BucketViewFieldFactory = void 0;
+const error_1 = require("../../../../engine/data/error");
+const bucket_view_schema_1 = require("./bucket_view.schema");
+const bucket_model_schema_1 = require("../model/bucket_model.schema");
+const bucket_model_convert_1 = require("../model/bucket_model.convert");
+/*
+    Factory
+*/
+class BucketViewFieldFactory {
+    constructor(_view) {
+        this._view = _view;
+    }
+    model(key, extra) {
+        return new BucketViewFieldBuilder('model', {
+            model: {
+                key: key
+            }
+        }, key, extra);
+    }
+    computed(fn) {
+        return new BucketViewFieldBuilder('computed', {
+            computed: {
+                fn: fn
+            }
+        });
+    }
+    graph(link, view) {
+        return new BucketViewFieldBuilder('graph', {
+            graph: {
+                link: link,
+                view: view
+            }
+        }, link);
+    }
+    view(view) {
+        return new BucketViewFieldBuilder('view', {
+            view: {
+                view: view
+            }
+        }, view);
+    }
+    extend(view, fields) {
+        return {
+            __ext: view,
+            ...fields
+        };
+    }
+    static group(name, children) {
+        return new bucket_view_schema_1.$BucketViewField(name, 'group', 'obj', name, false, true, { group: {} }, children);
+    }
+}
+exports.BucketViewFieldFactory = BucketViewFieldFactory;
+/*
+    Builder
+*/
+class BucketViewFieldBuilder {
+    constructor(scope, value, refKey, extra) {
+        this.scope = scope;
+        this.value = value;
+        this.refKey = refKey;
+        this.extra = extra;
+        this.type = 'unknown';
+        this.type = 'unknown';
+    }
+    // Build
+    static build(builder, model, graph, views, name) {
+        let type = 'unknown';
+        let array = 'unknown';
+        let required = true;
+        let children = undefined;
+        if (builder.scope === 'model') {
+            const modelField = bucket_model_schema_1.$BucketModel.get(model, builder.refKey);
+            if (!modelField) {
+                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.refKey);
+            }
+            type = modelField.type;
+            array = builder.refKey?.includes('.*') || modelField.array;
+            required = modelField.required;
+            if (modelField._enum) {
+                builder.value.model.enumOptions = modelField._enum.options;
+            }
+            if (modelField.children) {
+                const path = builder.refKey + ((modelField.array || modelField.type === 'dict') ? '.*' : '');
+                const fromModel = (0, bucket_model_convert_1.convertToView)(model, '', modelField.children, path).fields;
+                children = Object.assign({}, fromModel);
+            }
+            if (builder.extra) {
+                const extra = this.buildFields(builder.extra, model, graph, views);
+                children = Object.assign({}, children, extra);
+            }
+        }
+        else if (builder.scope === 'graph') {
+            const graphLink = builder.refKey ? graph.links[builder.refKey] : undefined;
+            if (!graphLink) {
+                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.refKey || '');
+            }
+            array = graphLink.many;
+        }
+        else if (builder.scope === 'view') {
+            const view = builder.refKey ? views[builder.refKey] : undefined;
+            if (!view) {
+                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.refKey || '');
+            }
+            type = 'obj';
+            array = false;
+            children = view.fields;
+        }
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, type, name, array, required, builder.value, children);
+    }
+    static buildFields(fields, model, graph, views) {
+        const schema = {};
+        // Extended fields inherit from other views
+        if ('__ext' in fields) {
+            const ext = views[fields.__ext];
+            Object.assign(schema, ext.fields);
+        }
+        for (const f in fields) {
+            if (f === '__ext') {
+                continue;
+            }
+            const field = fields[f];
+            // Normal fields are built here
+            if (field instanceof BucketViewFieldBuilder) {
+                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f);
+            }
+            // Builders are allowed to implicitly declare nested fields.
+            // The code below transforms these groups into fields of the scope 'group'.
+            else {
+                const children = BucketViewFieldBuilder.buildFields(field, model, graph, views);
+                schema[f] = BucketViewFieldFactory.group(f, children);
+            }
+        }
+        return schema;
+    }
+}
+exports.BucketViewFieldBuilder = BucketViewFieldBuilder;

package/lib/elements/entities/constants/constants.builder.d.ts

@@ -0,0 +1,57 @@
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { $ConstantEnum, $ConstantEnumOption, $ConstantValue, $Constants } from './constants.schema';
+/**
+ * Value
+ */
+export declare class ConstantValueBuilder {
+    private scope;
+    private key?;
+    private value?;
+    constructor(scope: string, key?: string | undefined, value?: any | undefined);
+    static build(key: string, builder: ConstantValueBuilder): $ConstantValue;
+}
+export declare class ConstantValueFactory {
+    static<T>(value: T): ConstantValueBuilder;
+    app<T>(key?: string): ConstantValueBuilder;
+}
+type ConstantValueDef = ($: ConstantValueFactory) => Record<string, ConstantValueBuilder>;
+/**
+ * Enum
+ */
+export declare class ConstantEnumOptionBuilder {
+    private value;
+    constructor(value: any);
+    static build(key: string, builder: ConstantEnumOptionBuilder): $ConstantEnumOption;
+}
+export declare class ConstantEnumOptionFactory<T> {
+    opt(value: T): ConstantEnumOptionBuilder;
+}
+type ConstantEnumOptionBuilders = Record<string, ConstantEnumOptionBuilder>;
+type ConstantEnumOptionDef<T> = ($: ConstantEnumOptionFactory<T>) => ConstantEnumOptionBuilders;
+export declare class ConstantEnumBuilder {
+    name: string;
+    options: ConstantEnumOptionBuilders;
+    constructor(name: string, options: ConstantEnumOptionBuilders);
+    static build(builder: ConstantEnumBuilder): $ConstantEnum;
+    private static buildOptions;
+}
+/**
+ * Constants
+ */
+export declare class ConstantsBuilder {
+    private module;
+    $b: "constants";
+    name: string;
+    private _values;
+    private enums;
+    constructor(module: string);
+    values($: ConstantValueDef): this;
+    enum<T>(name: string, $: ConstantEnumOptionDef<T>): this;
+    static merge(to: ConstantsBuilder, from: ConstantsBuilder): void;
+    static build(node: ConstantsBuilderNode): $Constants;
+}
+export type ConstantsBuilderNode = ResolvedBuilderNode & {
+    builder: ConstantsBuilder;
+    schema?: $Constants;
+};
+export {};

package/lib/elements/entities/constants/constants.builder.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantsBuilder = exports.ConstantEnumBuilder = exports.ConstantEnumOptionFactory = exports.ConstantEnumOptionBuilder = exports.ConstantValueFactory = exports.ConstantValueBuilder = void 0;
+const constants_schema_1 = require("./constants.schema");
+/**
+ * Value
+ */
+class ConstantValueBuilder {
+    constructor(scope, key, value) {
+        this.scope = scope;
+        this.key = key;
+        this.value = value;
+    }
+    // Build
+    static build(key, builder) {
+        return new constants_schema_1.$ConstantValue(builder.scope, builder.key || key, builder.value);
+    }
+}
+exports.ConstantValueBuilder = ConstantValueBuilder;
+class ConstantValueFactory {
+    static(value) {
+        return new ConstantValueBuilder('static', undefined, value);
+    }
+    app(key) {
+        return new ConstantValueBuilder('app', key);
+    }
+}
+exports.ConstantValueFactory = ConstantValueFactory;
+/**
+ * Enum
+ */
+class ConstantEnumOptionBuilder {
+    constructor(value) {
+        this.value = value;
+    }
+    // Build
+    static build(key, builder) {
+        return new constants_schema_1.$ConstantEnumOption(key, builder.value);
+    }
+}
+exports.ConstantEnumOptionBuilder = ConstantEnumOptionBuilder;
+class ConstantEnumOptionFactory {
+    opt(value) {
+        return new ConstantEnumOptionBuilder(value);
+    }
+}
+exports.ConstantEnumOptionFactory = ConstantEnumOptionFactory;
+class ConstantEnumBuilder {
+    constructor(name, options) {
+        this.name = name;
+        this.options = options;
+    }
+    // Build
+    static build(builder) {
+        return new constants_schema_1.$ConstantEnum(builder.name, this.buildOptions(builder.options));
+    }
+    static buildOptions(builders) {
+        const options = {};
+        for (const k in builders) {
+            options[k] = ConstantEnumOptionBuilder.build(k, builders[k]);
+        }
+        return options;
+    }
+}
+exports.ConstantEnumBuilder = ConstantEnumBuilder;
+/**
+ * Constants
+ */
+class ConstantsBuilder {
+    constructor(module) {
+        this.module = module;
+        this.$b = 'constants';
+        this.name = '*';
+        this._values = {};
+        this.enums = {};
+    }
+    values($) {
+        const factory = new ConstantValueFactory();
+        this._values = $(factory);
+        return this;
+    }
+    enum(name, $) {
+        const factory = new ConstantEnumOptionFactory();
+        const options = $(factory);
+        this.enums[name] = new ConstantEnumBuilder(name, options);
+        return this;
+    }
+    static merge(to, from) {
+        Object.assign(to._values, from._values);
+        Object.assign(to.enums, from.enums);
+    }
+    // Build
+    static build(node) {
+        const values = {};
+        const enums = {};
+        for (const k in node.builder._values) {
+            values[k] = ConstantValueBuilder.build(k, node.builder._values[k]);
+        }
+        for (const k in node.builder.enums) {
+            enums[k] = ConstantEnumBuilder.build(node.builder.enums[k]);
+            // Spread enum into multiple enums if it has one or more "." on it's name
+            const split = k.split('.');
+            if (split.length > 1) {
+                let parent = '';
+                for (let i = 0; i < split.length - 1; i++) {
+                    parent = parent.length ? (`${parent}.${split[i]}`) : split[i];
+                    enums[parent] ?? (enums[parent] = new constants_schema_1.$ConstantEnum(parent, {}));
+                    Object.assign(enums[parent].options, enums[k].options);
+                }
+            }
+        }
+        node.schema = new constants_schema_1.$Constants(node.module, values, enums);
+        return node.schema;
+    }
+}
+exports.ConstantsBuilder = ConstantsBuilder;

package/lib/elements/entities/constants/constants.d.ts

@@ -0,0 +1,7 @@
+import { $ConstantEnum } from './constants.schema';
+export declare class Enum<$ extends $ConstantEnum> {
+    private schema;
+    constructor(schema: $);
+    keys<K extends keyof $['options']>(): K[];
+    get<K extends keyof $['options']>(key: K): $['options'][K]['value'];
+}

package/lib/elements/entities/constants/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+class Enum {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    keys() {
+        return Object.keys(this.schema.options);
+    }
+    get(key) {
+        return this.schema.options[key].value;
+    }
+}
+exports.Enum = Enum;

package/lib/elements/entities/constants/constants.schema.d.ts

@@ -0,0 +1,51 @@
+import { $Module, $Space } from "../../../schema";
+import { $Message } from '../message/message.schema';
+import { MergeUnion } from "../../../engine/util/type";
+export declare class $ConstantValue {
+    scope: string;
+    key: string;
+    value?: any | undefined;
+    constructor(scope: string, key: string, value?: any | undefined);
+}
+export declare class $ConstantEnumOption {
+    key: string;
+    value: unknown;
+    constructor(key: string, value: unknown);
+}
+export declare class $ConstantEnum {
+    name: string;
+    options: Record<string, $ConstantEnumOption>;
+    '#data': any;
+    constructor(name: string, options: Record<string, $ConstantEnumOption>);
+    static keys(schema: $ConstantEnum): string[];
+    static get(schema: $ConstantEnum, key: string): unknown;
+}
+export declare class $Constants {
+    name: string;
+    values: Record<string, $ConstantValue>;
+    enums: Record<string, $ConstantEnum>;
+    $t: "constants";
+    '#enumpath': Record<string, {
+        _enum: $ConstantEnum;
+        _subs: string;
+    }>;
+    module: string;
+    constructor(name: string, values?: Record<string, $ConstantValue>, enums?: Record<string, $ConstantEnum>);
+    static merge(to: $Constants, from: $Constants): void;
+}
+type CompatibleMessageKey<Data, Subs extends string> = {
+    [K in keyof Data]: Data[K] extends Subs ? K : never;
+}[keyof Data];
+type ParseMessageEnumpath<Message extends $Message, Path extends string, Subs extends string> = Path extends `${infer X}.*` ? `${X}.{${CompatibleMessageKey<Message['#parsed'], Subs> & string}}` : Path;
+export type MessageEnumpath<Module extends $Module, Message extends $Message, Modules extends Record<string, $Module>> = MergeUnion<{
+    [M in keyof Modules]: {
+        [K in keyof Modules[M]['constants']['#enumpath'] as M extends Module['name'] ? ParseMessageEnumpath<Message, K & string, Modules[M]['constants']['#enumpath'][K]['_subs']> : `${M & string}::${ParseMessageEnumpath<Message, K & string, Modules[M]['constants']['#enumpath'][K]['_subs']>}`]: Modules[M]['constants']['#enumpath'][K]['_enum'];
+    };
+}[keyof Modules]>;
+export type EnumName<Space extends $Space> = MergeUnion<{
+    [M in keyof Space['modules']]: {
+        [K in keyof Space['modules'][M]['constants']['enums'] as `${M & string}::${K & string}`]: Space['modules'][M]['constants']['enums'][K];
+    };
+}[keyof Space['modules']]>;
+export type EnumFromName<Space extends $Space, Name, ModuleName extends keyof Space['modules'] = Name extends `${infer X}::${string}` ? X : never, Module extends $Module = Space['modules'][ModuleName], Enums = Module['constants']['enums'], EnumName = Name extends `${string}::${infer X}` ? X : never> = Enums[EnumName & keyof Enums];
+export {};