nesoi 3.2.9 → 3.3.1

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

@@ -9,6 +9,7 @@ const promise_1 = __importDefault(require("../../../../engine/util/promise"));
 const error_1 = require("../../../../engine/data/error");
 const tree_1 = require("../../../../engine/data/tree");
 const daemon_1 = require("../../../../engine/daemon");
+const dependency_1 = require("../../../../engine/dependency");
 class ViewValue {
     constructor() {
         this.value = undefined;
@@ -24,12 +25,15 @@ class BucketView {
         this.schema = schema;
     }
     async parse(trx, raw) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
+        const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
         const parsed = {};
         if ('__raw' in this.schema.fields) {
             Object.assign(parsed, raw);
         }
         let layer = Object.values(this.schema.fields).map(field => ({
-            bucket: this.bucket,
+            bucket: meta,
             field,
             data: [{
                     raw,
@@ -48,6 +52,9 @@ class BucketView {
         };
     }
     async parseMany(trx, raws) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
+        const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
         const parseds = [];
         for (const raw of raws) {
             const parsed = {};
@@ -57,7 +64,7 @@ class BucketView {
             parseds.push(parsed);
         }
         let layer = Object.values(this.schema.fields).map(field => ({
-            bucket: this.bucket,
+            bucket: meta,
             field,
             data: raws.map((raw, i) => ({
                 raw,
@@ -159,77 +166,85 @@ class BucketView {
     }
     doParseModelProp(node, initAs, rawChild) {
         const modelpath = node.field.meta.model.path;
-        const paths = modelpath.split('.');
+        const isValueModel = modelpath === '.';
         const name = node.field.name;
         let poll = node.data.map(d => ({
             ...d,
-            value: d.raw,
+            value: isValueModel ? d.value : d.raw,
             key: name
         }));
-        for (const path of paths) {
-            // *
-            if (path === '*') {
-                // Expand each value of the poll (assumed to be a dict or list)
-                poll = poll.map(item => {
-                    if (typeof item.value !== 'object') {
-                        throw new Error(`Failed to parse ${paths}, intermediate value ${item.value} is not a list or object`);
-                    }
-                    if (Array.isArray(item.value)) {
-                        item.target[item.key] = initAs === 'value'
-                            ? [...item.value]
-                            : item.value.map(() => ({}));
-                        return item.value.map((v, i) => ({
-                            index: [...item.index, i],
-                            raw: item.raw,
-                            value: v,
-                            target: item.target[item.key],
-                            key: i
-                        }));
-                    }
-                    else {
-                        item.target[item.key] = initAs === 'value'
-                            ? { ...item.value }
-                            : Object.fromEntries(Object.entries(item.value).map(([k]) => [k, {}]));
-                        return Object.entries(item.value).map(([k, v]) => ({
-                            index: [...item.index, k],
-                            raw: item.raw,
-                            value: v,
-                            target: item.target[item.key],
-                            key: k
-                        }));
-                    }
-                }).flat(1);
-                continue;
+        if (isValueModel) {
+            for (const data of poll) {
+                data.target[data.key] = data.value;
             }
-            // $1, $2.. or string|number
-            else {
-                // Walk each node
-                const next = [];
-                for (const item of poll) {
-                    // $0, $1.. -> string
-                    const idx = path.match(/^\$(\d+)/)?.[1];
-                    let _path = path;
-                    if (idx !== undefined) {
-                        // Replace by index key
-                        _path = item.index[parseInt(idx)];
-                    }
-                    const n = typeof item.value === 'object'
-                        ? item.value[_path]
-                        : undefined;
-                    item.target[item.key] = initAs === 'value'
-                        ? n
-                        : {};
-                    if (n !== undefined) {
-                        next.push({
-                            index: item.index,
-                            raw: item.raw,
-                            value: n,
-                            target: item.target,
-                            key: item.key
-                        });
+        }
+        else {
+            const paths = modelpath.split('.');
+            for (const path of paths) {
+                // *
+                if (path === '*') {
+                    // Expand each value of the poll (assumed to be a dict or list)
+                    poll = poll.map(item => {
+                        if (typeof item.value !== 'object') {
+                            throw new Error(`Failed to parse ${paths}, intermediate value ${item.value} is not a list or object`);
+                        }
+                        if (Array.isArray(item.value)) {
+                            item.target[item.key] = initAs === 'value'
+                                ? [...item.value]
+                                : item.value.map(() => ({}));
+                            return item.value.map((v, i) => ({
+                                index: [...item.index, i],
+                                raw: item.raw,
+                                value: v,
+                                target: item.target[item.key],
+                                key: i
+                            }));
+                        }
+                        else {
+                            item.target[item.key] = initAs === 'value'
+                                ? { ...item.value }
+                                : Object.fromEntries(Object.entries(item.value).map(([k]) => [k, {}]));
+                            return Object.entries(item.value).map(([k, v]) => ({
+                                index: [...item.index, k],
+                                raw: item.raw,
+                                value: v,
+                                target: item.target[item.key],
+                                key: k
+                            }));
+                        }
+                    }).flat(1);
+                    continue;
+                }
+                // $1, $2.. or string|number
+                else {
+                    // Walk each node
+                    const next = [];
+                    for (const item of poll) {
+                        // $0, $1.. -> string
+                        const idx = path.match(/^\$(\d+)/)?.[1];
+                        let _path = path;
+                        if (idx !== undefined) {
+                            // Replace by index key
+                            _path = item.index[parseInt(idx)];
+                        }
+                        const n = typeof item.value === 'object'
+                            ? item.value[_path]
+                            : undefined;
+                        item.target[item.key] = initAs === 'value'
+                            ? n
+                            : {};
+                        if (n !== undefined) {
+                            next.push({
+                                index: item.index,
+                                raw: item.raw,
+                                value: n,
+                                target: item.target,
+                                key: item.key
+                            });
+                        }
                     }
+                    poll = next;
                 }
-                poll = next;
             }
         }
         // For each leaf, if it's an object (not an array),
@@ -264,7 +279,17 @@ class BucketView {
      */
     async parseGraphProp(trx, node) {
         const meta = node.field.meta.graph;
-        const links = await node.bucket.graph.readManyLinks(trx, node.data.map(entry => entry.raw), meta.link, { silent: true });
+        let links;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        // External
+        if (node.bucket.tag.module !== module.name) {
+            links = await trx.bucket(node.bucket.tag.short).readManyLinks(node.data.map(entry => entry.raw.id), meta.link);
+        }
+        // Internal
+        else {
+            const bucket = module.buckets[node.bucket.tag.name];
+            links = await bucket.graph.readManyLinks(trx, node.data.map(entry => entry.raw), meta.link, { silent: true });
+        }
         for (let i = 0; i < links.length; i++) {
             if (meta.view) {
                 const link = node.bucket.schema.graph.links[meta.link];
@@ -282,8 +307,8 @@ class BucketView {
             const otherBucketDep = schema.graph.links[meta.link].bucket;
             const module = trx_node_1.TrxNode.getModule(trx);
             const daemon = module.daemon;
-            const otherBucket = await daemon_1.Daemon.getSchema(daemon, otherBucketDep);
-            const view = otherBucket.views[meta.view];
+            const otherBucket = await daemon_1.Daemon.getBucketMetadata(daemon, otherBucketDep);
+            const view = otherBucket.schema.views[meta.view];
             const { __raw, ...v } = view.fields;
             const link = node.bucket.schema.graph.links[meta.link];
             let nextData;
@@ -314,16 +339,21 @@ class BucketView {
                     });
                 }
             }
-            next = Object.values(v).map(field => ({
-                bucket: module.buckets[otherBucketDep.refName],
-                field,
-                data: nextData.map($ => ({
-                    raw: $.value,
-                    value: $.value,
-                    index: [],
-                    target: $.target
-                }))
-            }));
+            // TODODO: support external bucket on transitive graph
+            next = [];
+            for (const field of Object.values(v)) {
+                const bucket = await daemon_1.Daemon.getBucketMetadata(module.daemon, otherBucketDep);
+                next.push({
+                    bucket,
+                    field,
+                    data: nextData.map($ => ({
+                        raw: $.value,
+                        value: $.value,
+                        index: [],
+                        target: $.target
+                    }))
+                });
+            }
         }
         return next;
     }
@@ -331,7 +361,9 @@ class BucketView {
      * [drive]
      */
     async parseDriveProp(trx, node) {
-        if (!node.bucket.drive) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const drive = await daemon_1.Daemon.getBucketDrive(module.daemon, node.bucket.tag);
+        if (!drive) {
             throw error_1.NesoiError.Bucket.Drive.NoAdapter({ bucket: node.bucket.schema.alias });
         }
         const meta = node.field.meta.drive;
@@ -340,12 +372,12 @@ class BucketView {
             if (Array.isArray(value)) {
                 const public_urls = [];
                 for (const obj of value) {
-                    public_urls.push(await node.bucket.drive.public(obj));
+                    public_urls.push(await drive.public(obj));
                 }
                 entry.target[node.field.name] = public_urls;
             }
             else {
-                entry.target[node.field.name] = await node.bucket.drive.public(value);
+                entry.target[node.field.name] = await drive.public(value);
             }
         }
     }

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

@@ -19,17 +19,18 @@ type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> =
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     private _view;
     protected scope: $BucketViewField['scope'];
-    protected value: $BucketViewField['meta'];
+    protected meta: $BucketViewField['meta'];
     constructor(_view: BucketViewBuilder<any, any, any>);
     raw(): {
         [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Bucket['#data'][K], 'model'>;
     };
-    model<K extends keyof Bucket['#modelpath'], SubModel extends BucketViewFieldBuilderTree>(path: K, submodel?: SubModel): BucketViewFieldBuilder<Bucket["#modelpath"][K], "model", never>;
+    model<K extends keyof Bucket['#modelpath'], SubModel extends BucketViewFieldBuilders>(path: K, submodel?: SubModel): BucketViewFieldBuilder<Bucket["#modelpath"][K], "model", never>;
+    value(): BucketViewFieldBuilder<any, "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}`>;
     drive<F extends DriveFieldpath<Bucket>>(path: F): BucketViewFieldBuilder<string, "drive", never>;
     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;
+    extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilders>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
     static group(name: string, children: $BucketViewFields): $BucketViewField;
 }
 /**
@@ -39,15 +40,15 @@ export declare class BucketViewFieldFactory<Space extends $Space, Module extends
 export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
     protected scope: $BucketViewField['scope'];
     protected meta: $BucketViewFieldMeta;
-    protected submodel?: BucketViewFieldBuilderTree | undefined;
+    protected submodel?: BucketViewFieldBuilders | undefined;
     $b: "view.field";
     protected _chain?: BucketViewFieldBuilder<any, any, any>;
-    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, submodel?: BucketViewFieldBuilderTree | undefined);
+    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, submodel?: BucketViewFieldBuilders | undefined);
     chain<Fn extends $BucketViewFieldFn<any, any>>(fn: Fn): void;
     static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number): $BucketViewField;
-    static buildFields(fields: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number): $BucketViewFields;
+    static buildFields(fields: BucketViewFieldBuilders, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number): $BucketViewFields;
 }
-export type BucketViewFieldBuilderTree = {
-    [x: string]: BucketViewFieldBuilder<any, any, any> | BucketViewFieldBuilderTree;
+export type BucketViewFieldBuilders = {
+    [x: string]: BucketViewFieldBuilder<any, any, any>;
 };
 export {};

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

@@ -27,6 +27,13 @@ class BucketViewFieldFactory {
             }
         }, submodel);
     }
+    value() {
+        return new BucketViewFieldBuilder('model', {
+            model: {
+                path: '.'
+            }
+        });
+    }
     computed(fn) {
         return new BucketViewFieldBuilder('computed', {
             computed: {
@@ -150,16 +157,7 @@ class BucketViewFieldBuilder {
                 schema['__raw'] = {};
             }
             const field = fields[f];
-            // Normal fields are built here
-            if (field instanceof BucketViewFieldBuilder) {
-                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes);
-            }
-            // 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, n_indexes);
-                schema[f] = BucketViewFieldFactory.group(f, children);
-            }
+            schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes);
         }
         return schema;
     }

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

@@ -9,7 +9,7 @@ export declare class ConstantValueBuilder {
     private key?;
     private value?;
     constructor(scope: string, key?: string | undefined, value?: any | undefined);
-    static build(key: string, builder: ConstantValueBuilder): $ConstantValue;
+    static build(module: string, name: string, builder: ConstantValueBuilder): $ConstantValue;
 }
 /**
  * @category Builders
@@ -46,7 +46,7 @@ export declare class ConstantEnumBuilder {
     name: string;
     options: ConstantEnumOptionBuilders;
     constructor(name: string, options: ConstantEnumOptionBuilders);
-    static build(builder: ConstantEnumBuilder): $ConstantEnum;
+    static build(module: string, builder: ConstantEnumBuilder): $ConstantEnum;
     private static buildOptions;
 }
 /**
@@ -65,7 +65,7 @@ export declare class ConstantsBuilder {
     static merge(to: ConstantsBuilder, from: ConstantsBuilder): void;
     static build(node: ConstantsBuilderNode): $Constants;
 }
-export type ConstantsBuilderNode = ResolvedBuilderNode & {
+export type ConstantsBuilderNode = Omit<ResolvedBuilderNode, 'schema'> & {
     builder: ConstantsBuilder;
     schema?: $Constants;
 };

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

@@ -13,8 +13,8 @@ class ConstantValueBuilder {
         this.value = value;
     }
     // Build
-    static build(key, builder) {
-        return new constants_schema_1.$ConstantValue(builder.scope, builder.key || key, builder.value);
+    static build(module, name, builder) {
+        return new constants_schema_1.$ConstantValue(module, name, builder.scope, builder.key, builder.value);
     }
 }
 exports.ConstantValueBuilder = ConstantValueBuilder;
@@ -65,8 +65,8 @@ class ConstantEnumBuilder {
         this.options = options;
     }
     // Build
-    static build(builder) {
-        return new constants_schema_1.$ConstantEnum(builder.name, this.buildOptions(builder.options));
+    static build(module, builder) {
+        return new constants_schema_1.$ConstantEnum(module, builder.name, this.buildOptions(builder.options));
     }
     static buildOptions(builders) {
         const options = {};
@@ -109,22 +109,22 @@ class ConstantsBuilder {
         const values = {};
         const enums = {};
         for (const k in node.builder._values) {
-            values[k] = ConstantValueBuilder.build(k, node.builder._values[k]);
+            values[k] = ConstantValueBuilder.build(node.tag.module, k, node.builder._values[k]);
         }
         for (const k in node.builder.enums) {
-            enums[k] = ConstantEnumBuilder.build(node.builder.enums[k]);
+            enums[k] = ConstantEnumBuilder.build(node.tag.module, 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, {}));
+                    enums[parent] ?? (enums[parent] = new constants_schema_1.$ConstantEnum(node.tag.module, parent, {}));
                     Object.assign(enums[parent].options, enums[k].options);
                 }
             }
         }
-        node.schema = new constants_schema_1.$Constants(node.module, values, enums);
+        node.schema = new constants_schema_1.$Constants(node.tag.module, values, enums);
         return node.schema;
     }
 }

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

@@ -6,10 +6,13 @@ import { MergeUnion } from "../../../engine/util/type";
  * @subcategory Entity
  * */
 export declare class $ConstantValue {
+    module: string;
+    name: string;
     scope: string;
-    key: string;
+    key?: string | undefined;
     value?: any | undefined;
-    constructor(scope: string, key: string, value?: any | undefined);
+    $t: "constants.value";
+    constructor(module: string, name: string, scope: string, key?: string | undefined, value?: any | undefined);
 }
 /**
  * @category Schemas
@@ -25,10 +28,12 @@ export declare class $ConstantEnumOption {
  * @subcategory Entity
  * */
 export declare class $ConstantEnum {
+    module: string;
     name: string;
     options: Record<string, $ConstantEnumOption>;
+    $t: "constants.enum";
     '#data': any;
-    constructor(name: string, options: Record<string, $ConstantEnumOption>);
+    constructor(module: string, name: string, options: Record<string, $ConstantEnumOption>);
     static keys(schema: $ConstantEnum): string[];
     static get(schema: $ConstantEnum, key: string): unknown;
 }

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

@@ -6,10 +6,13 @@ exports.$Constants = exports.$ConstantEnum = exports.$ConstantEnumOption = expor
  * @subcategory Entity
  * */
 class $ConstantValue {
-    constructor(scope, key, value) {
+    constructor(module, name, scope, key, value) {
+        this.module = module;
+        this.name = name;
         this.scope = scope;
         this.key = key;
         this.value = value;
+        this.$t = 'constants.value';
     }
 }
 exports.$ConstantValue = $ConstantValue;
@@ -29,9 +32,11 @@ exports.$ConstantEnumOption = $ConstantEnumOption;
  * @subcategory Entity
  * */
 class $ConstantEnum {
-    constructor(name, options) {
+    constructor(module, name, options) {
+        this.module = module;
         this.name = name;
         this.options = options;
+        this.$t = 'constants.enum';
     }
     static keys(schema) {
         return Object.keys(schema.options);

package/lib/elements/entities/message/message.infer.d.ts

@@ -31,9 +31,5 @@ export interface $MessageInferFromData<Name extends string, Data> extends $Messa
     } & Data;
 }
 export type $MessageTemplateBuilderInfer<Module extends $Module, Message extends $Message, Input, Output> = {
-    [K in Exclude<keyof Output, '$'>]: MessageTemplateFieldBuilder<Module, Message, {
-        '': Input[K & keyof Input];
-    }, {
-        '': Output[(K extends `${infer X}_id` ? X : K) & keyof Output];
-    }, {}>;
+    [K in Exclude<keyof Output, '$'>]: MessageTemplateFieldBuilder<Module, Message, Input[K & keyof Input], Output[(K extends `${infer X}_id` ? X : K) & keyof Output], {}>;
 };

package/lib/elements/entities/message/message.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Message = void 0;
-const crypto_1 = __importDefault(require("crypto"));
+const crypto_1 = require("../../../engine/util/crypto");
 /**
  * @category Elements
  * @subcategory Entity
@@ -36,9 +33,7 @@ class Message {
             return str;
         }
         const text = atob(dump(data));
-        return crypto_1.default.createHmac('sha1', sigKey)
-            .update(text)
-            .digest('hex');
+        return crypto_1.NesoiCrypto.createHmac(text, sigKey);
     }
     getData() {
         const { $, __meta__, ...data } = this;

package/lib/elements/entities/message/message.schema.js

@@ -23,7 +23,7 @@ class $Message {
                 const field = _fields[key];
                 str += `${'  '.repeat(d)}- ${(0, string_1.colored)(key, 'green')}${field.required ? '' : '?'}: ${field.type}`;
                 if (field.type === 'id') {
-                    str += `(${field.meta.id.bucket.refName})`;
+                    str += `(${field.meta.id.bucket.short})`;
                 }
                 else if (field.type === 'enum') {
                     const options = field.meta.enum.options;

package/lib/elements/entities/message/template/message_template.schema.d.ts

@@ -1,6 +1,6 @@
 import { $Message } from "../../..";
 import { $BucketModelFieldType } from "../../bucket/model/bucket_model.schema";
-import { $Dependency } from "../../../../engine/dependency";
+import { Tag } from "../../../../engine/dependency";
 export type $MessageTemplateRule = (def: {
     field: $MessageTemplateField;
     path: string;
@@ -21,19 +21,21 @@ export type $MessageTemplateFieldMeta = {
         right?: number;
     };
     enum?: {
-        options: string | string[] | Record<string, any>;
-        dep?: $Dependency;
+        enumpath?: [string, string];
+        options: Record<string, any>;
     };
     file?: {
         maxsize?: number;
         extnames?: string[];
     };
     id?: {
-        bucket: $Dependency;
+        bucket: Tag;
         type?: 'int' | 'string';
         view?: string;
     };
-    msg?: $Dependency;
+    msg?: {
+        tag: Tag;
+    };
 };
 export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_number' | 'id' | 'msg';
 /**

package/lib/elements/entities/message/template/message_template_field.builder.d.ts

@@ -4,6 +4,7 @@ import { $MessageInputInfer, $MessageOutputInfer, $MessageTemplateBuilderInfer }
 import { NesoiDate } from "../../../../engine/data/date";
 import { $Message } from '../message.schema';
 import { ModuleTree } from "../../../../engine/tree";
+import { Dependency } from "../../../../engine/dependency";
 import { MessageEnumpath } from '../../constants/constants.schema';
 import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
@@ -46,7 +47,7 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
     union<Builders extends AnyMessageTemplateFieldBuilder[]>(...children: Builders): MessageTemplateFieldBuilder<Module, Message, Builders[number]["#input"], Builders[number]["#output"], {
         [x: number]: Builders[number];
     }, [false, false], "">;
-    msg<MessageName extends keyof Module['messages'], Message extends Module['messages'][MessageName], Builders extends MessageTemplateFieldBuilders>(msg: MessageName, extra?: Builders): MessageTemplateFieldBuilder<Module, Message, Omit<Message["#raw"], "$"> & {
+    msg<MessageName extends keyof Module['messages'], Message extends Module['messages'][MessageName], Builders extends MessageTemplateFieldBuilders>(msg: MessageName, extra?: Builders): MessageTemplateFieldBuilder<Module, NoInfer<Message>, Omit<Message["#raw"], "$"> & {
         $: any;
     } & { [K in keyof Builders as Builders[K]["#optional"][0] extends true ? never : `${K & string}${Builders[K]["#input_suffix"]}`]: Builders[K]["#input"]; } & { [K_1 in keyof Builders as Builders[K_1]["#optional"][0] extends true ? `${K_1 & string}${Builders[K_1]["#input_suffix"]}` : never]?: Builders[K_1]["#input"] | undefined; }, Omit<Message["#parsed"], "$"> & {
         $: any;
@@ -59,7 +60,7 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
  * */
 export declare class MessageTemplateFieldBuilder<Module extends $Module, Message extends $Message, Input, Output, Children extends MessageTemplateFieldBuilders, Optional = [false, false], InputSuffix extends string = ''> {
     private type;
-    private value;
+    private meta;
     private alias?;
     private children?;
     '#input': Input;
@@ -70,7 +71,21 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     private _defaultValue?;
     private _nullable;
     private _rules;
-    constructor(type: $MessageTemplateFieldType, value: $MessageTemplateFieldMeta, alias?: string | undefined, children?: Children | undefined);
+    constructor(type: $MessageTemplateFieldType, meta: Omit<$MessageTemplateFieldMeta, 'enum' | 'msg' | 'id'> & {
+        enum?: {
+            options: Record<string, any>;
+        } | {
+            dep: Dependency;
+        } | {
+            enumpath: [string, string];
+        };
+        msg?: Dependency;
+        id?: {
+            bucket: Dependency;
+            type?: 'int' | 'string';
+            view?: string;
+        };
+    }, alias?: string | undefined, children?: Children | undefined);
     as(alias: string): this;
     get optional(): MessageTemplateFieldBuilder<Module, Message, Input | undefined, Output | undefined, Children, [
         true,