@epsilon-asi/foundation 0.0.1-testing

package/.npm/_logs/2026-05-02T22_04_53_277Z-debug-0.log

@@ -0,0 +1,22 @@
+0 verbose cli /usr/local/bin/node /usr/local/bin/npm
+1 info using npm@10.9.2
+2 info using node@v22.17.1
+3 silly config load:file:/usr/local/lib/node_modules/npm/npmrc
+4 silly config load:file:/builds/epsilon-asi/foundations/packages/foundation/.npmrc
+5 silly config load:file:/root/.npmrc
+6 silly config load:file:/usr/local/etc/npmrc
+7 verbose title npm ci
+8 verbose argv "ci"
+9 verbose logfile logs-max:10 dir:/builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_53_277Z-
+10 verbose logfile /builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_53_277Z-debug-0.log
+11 silly logfile done cleaning log files
+12 silly packumentCache heap:2197815296 maxSize:549453824 maxEntrySize:274726912
+13 silly idealTree buildDeps
+14 silly reify moves {}
+15 silly audit report null
+16 verbose cwd /builds/epsilon-asi/foundations/packages/foundation
+17 verbose os Linux 5.15.154+
+18 verbose node v22.17.1
+19 verbose npm  v10.9.2
+20 verbose exit 0
+21 info ok

package/.npm/_logs/2026-05-02T22_04_53_601Z-debug-0.log

@@ -0,0 +1,18 @@
+0 verbose cli /usr/local/bin/node /usr/local/bin/npm
+1 info using npm@10.9.2
+2 info using node@v22.17.1
+3 silly config load:file:/usr/local/lib/node_modules/npm/npmrc
+4 silly config load:file:/builds/epsilon-asi/foundations/packages/foundation/.npmrc
+5 silly config load:file:/root/.npmrc
+6 silly config load:file:/usr/local/etc/npmrc
+7 verbose title npm run test
+8 verbose argv "run" "test"
+9 verbose logfile logs-max:10 dir:/builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_53_601Z-
+10 verbose logfile /builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_53_601Z-debug-0.log
+11 silly logfile done cleaning log files
+12 verbose cwd /builds/epsilon-asi/foundations/packages/foundation
+13 verbose os Linux 5.15.154+
+14 verbose node v22.17.1
+15 verbose npm  v10.9.2
+16 verbose exit 0
+17 info ok

package/.npm/_logs/2026-05-02T22_04_58_522Z-debug-0.log

@@ -0,0 +1,18 @@
+0 verbose cli /usr/local/bin/node /usr/local/bin/npm
+1 info using npm@10.9.2
+2 info using node@v22.17.1
+3 silly config load:file:/usr/local/lib/node_modules/npm/npmrc
+4 silly config load:file:/builds/epsilon-asi/foundations/packages/foundation/.npmrc
+5 silly config load:file:/root/.npmrc
+6 silly config load:file:/usr/local/etc/npmrc
+7 verbose title npm run build
+8 verbose argv "run" "build"
+9 verbose logfile logs-max:10 dir:/builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_58_522Z-
+10 verbose logfile /builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_04_58_522Z-debug-0.log
+11 silly logfile done cleaning log files
+12 verbose cwd /builds/epsilon-asi/foundations/packages/foundation
+13 verbose os Linux 5.15.154+
+14 verbose node v22.17.1
+15 verbose npm  v10.9.2
+16 verbose exit 0
+17 info ok

package/.npm/_logs/2026-05-02T22_05_00_812Z-debug-0.log

@@ -0,0 +1,19 @@
+0 verbose cli /usr/local/bin/node /usr/local/bin/npm
+1 info using npm@10.9.2
+2 info using node@v22.17.1
+3 silly config load:file:/usr/local/lib/node_modules/npm/npmrc
+4 silly config load:file:/builds/epsilon-asi/foundations/packages/foundation/.npmrc
+5 silly config load:file:/root/.npmrc
+6 silly config load:file:/usr/local/etc/npmrc
+7 verbose title npm version 0.0.1-testing
+8 verbose argv "version" "0.0.1-testing" "--no-git-tag-version"
+9 verbose logfile logs-max:10 dir:/builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_05_00_812Z-
+10 verbose logfile /builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_05_00_812Z-debug-0.log
+11 silly logfile done cleaning log files
+12 verbose version Not tagging: not in a git repo or no git cmd
+13 verbose cwd /builds/epsilon-asi/foundations/packages/foundation
+14 verbose os Linux 5.15.154+
+15 verbose node v22.17.1
+16 verbose npm  v10.9.2
+17 verbose exit 0
+18 info ok

package/.npm/_logs/2026-05-02T22_05_00_961Z-debug-0.log

@@ -0,0 +1,14 @@
+0 verbose cli /usr/local/bin/node /usr/local/bin/npm
+1 info using npm@10.9.2
+2 info using node@v22.17.1
+3 silly config load:file:/usr/local/lib/node_modules/npm/npmrc
+4 silly config load:file:/builds/epsilon-asi/foundations/packages/foundation/.npmrc
+5 silly config load:file:/root/.npmrc
+6 silly config load:file:/usr/local/etc/npmrc
+7 verbose title npm publish
+8 verbose argv "publish"
+9 verbose logfile logs-max:10 dir:/builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_05_00_961Z-
+10 verbose logfile /builds/epsilon-asi/foundations/packages/foundation/.npm/_logs/2026-05-02T22_05_00_961Z-debug-0.log
+11 silly logfile done cleaning log files
+12 verbose publish [ '.' ]
+13 silly packumentCache heap:2197815296 maxSize:549453824 maxEntrySize:274726912

package/build/decorators/factory/clone.d.ts

@@ -0,0 +1,3 @@
+export declare function cloneDeep<T>(value: T, seen?: WeakMap<object, unknown>): T;
+export declare function deepFreeze<T>(value: T, seen?: WeakSet<object>): T;
+export declare function immutableClone<T>(value: T): T;

package/build/decorators/factory/clone.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeep = cloneDeep;
+exports.deepFreeze = deepFreeze;
+exports.immutableClone = immutableClone;
+function isObjectLike(value) {
+    return (typeof value === 'object' && value !== null) || typeof value === 'function';
+}
+function cloneDeep(value, seen = new WeakMap()) {
+    if (!isObjectLike(value))
+        return value;
+    if (typeof value === 'function')
+        return value;
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    if (value instanceof Map) {
+        const cloned = new Map();
+        seen.set(value, cloned);
+        for (const [key, mapValue] of value.entries()) {
+            cloned.set(cloneDeep(key, seen), cloneDeep(mapValue, seen));
+        }
+        return cloned;
+    }
+    if (value instanceof Set) {
+        const cloned = new Set();
+        seen.set(value, cloned);
+        for (const setValue of value.values()) {
+            cloned.add(cloneDeep(setValue, seen));
+        }
+        return cloned;
+    }
+    if (Array.isArray(value)) {
+        const cloned = [];
+        seen.set(value, cloned);
+        for (const item of value)
+            cloned.push(cloneDeep(item, seen));
+        return cloned;
+    }
+    const cloned = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, cloned);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined)
+            continue;
+        if ('value' in descriptor) {
+            descriptor.value = cloneDeep(descriptor.value, seen);
+        }
+        Object.defineProperty(cloned, key, descriptor);
+    }
+    return cloned;
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (!isObjectLike(value))
+        return value;
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    if (value instanceof Map) {
+        for (const [key, mapValue] of value.entries()) {
+            deepFreeze(key, seen);
+            deepFreeze(mapValue, seen);
+        }
+    }
+    else if (value instanceof Set) {
+        for (const setValue of value.values()) {
+            deepFreeze(setValue, seen);
+        }
+    }
+    else {
+        for (const key of Reflect.ownKeys(value)) {
+            deepFreeze(value[key], seen);
+        }
+    }
+    return Object.freeze(value);
+}
+function immutableClone(value) {
+    return deepFreeze(cloneDeep(value));
+}

package/build/decorators/factory/decoratorRegistry.d.ts

@@ -0,0 +1,2 @@
+import type { CreateDecoratorRegistryOptions, DecoratorRegistry, DecoratorSchema } from './types';
+export declare function createDecoratorRegistry<TSchema extends DecoratorSchema>(options?: CreateDecoratorRegistryOptions): DecoratorRegistry<TSchema>;

package/build/decorators/factory/decoratorRegistry.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoratorRegistry = createDecoratorRegistry;
+const clone_1 = require("./clone");
+const snapshot_1 = require("./snapshot");
+const symbolMetadata_1 = require("./symbolMetadata");
+function isPropertyKey(value) {
+    return typeof value === 'string' || typeof value === 'symbol';
+}
+function assertPropertyKey(value, decoratorName) {
+    if (isPropertyKey(value))
+        return value;
+    throw new TypeError(`Decorator "${decoratorName}" expected a string or symbol member key, but received ${typeof value}.`);
+}
+function parseDirectArgs(args, decoratorName) {
+    if (args.length === 0) {
+        return { metadata: undefined };
+    }
+    if (args.length === 1) {
+        return { metadata: args[0] };
+    }
+    return {
+        key: assertPropertyKey(args[0], decoratorName),
+        metadata: args[1],
+    };
+}
+function parseOnArgs(args, decoratorName) {
+    if (args.length === 0) {
+        throw new TypeError(`Decorator "${decoratorName}.on" requires a member key.`);
+    }
+    return {
+        key: assertPropertyKey(args[0], `${decoratorName}.on`),
+        metadata: args.length > 1 ? args[1] : undefined,
+    };
+}
+function assertContextKind(expectedKind, decoratorName, context) {
+    if (expectedKind === 'class' && context.kind === 'class')
+        return;
+    if (expectedKind === 'property' && context.kind === 'field')
+        return;
+    if (expectedKind === 'method' && context.kind === 'method')
+        return;
+    if (expectedKind === 'accessor' &&
+        (context.kind === 'accessor' || context.kind === 'getter' || context.kind === 'setter')) {
+        return;
+    }
+    throw new TypeError(`Decorator "${decoratorName}" can only be used on ${expectedKind} targets, but was used on ${context.kind}.`);
+}
+function getTargetConstructor(target) {
+    if (typeof target === 'function') {
+        return target;
+    }
+    const constructor = target.constructor;
+    return typeof constructor === 'function' ? constructor : undefined;
+}
+function getConstructorChain(constructor, includeInherited) {
+    if (!includeInherited)
+        return [constructor];
+    const chain = [];
+    let current = constructor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain.reverse();
+}
+function getOwnMetadataObject(constructor) {
+    if (!Object.prototype.hasOwnProperty.call(constructor, symbolMetadata_1.symbolMetadata)) {
+        return undefined;
+    }
+    const metadata = constructor[symbolMetadata_1.symbolMetadata];
+    return typeof metadata === 'object' && metadata !== null ? metadata : undefined;
+}
+function samePropertyKey(left, right) {
+    return left === right;
+}
+class ModernDecoratorRegistry {
+    constructor(options = {}) {
+        var _a, _b;
+        this.nextOrder = 0;
+        this.recordsByMetadata = new WeakMap();
+        this.namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
+        this.allowPrivateMembers = (_b = options.allowPrivateMembers) !== null && _b !== void 0 ? _b : false;
+    }
+    class(name) {
+        return this.createClassFactory(String(name));
+    }
+    for() {
+        return Object.freeze({
+            class: (name) => this.createScopedClassFactory(String(name)),
+            property: (name) => this.createPropertyFactory(String(name)),
+            method: (name) => this.createMethodFactory(String(name)),
+            accessor: (name) => this.createAccessorFactory(String(name)),
+        });
+    }
+    read(target, options = {}) {
+        var _a;
+        const constructor = getTargetConstructor(target);
+        if (constructor === undefined) {
+            return (0, snapshot_1.createSnapshot)([]);
+        }
+        const includeInherited = (_a = options.includeInherited) !== null && _a !== void 0 ? _a : true;
+        const constructors = getConstructorChain(constructor, includeInherited);
+        const records = [];
+        for (const current of constructors) {
+            const metadata = getOwnMetadataObject(current);
+            if (metadata === undefined)
+                continue;
+            const ownRecords = this.recordsByMetadata.get(metadata);
+            if (ownRecords !== undefined)
+                records.push(...ownRecords);
+        }
+        return (0, snapshot_1.createSnapshot)(records);
+    }
+    createClassFactory(decoratorName) {
+        const factory = ((...args) => {
+            const metadata = args.length === 0 ? undefined : args[0];
+            return (_value, context) => {
+                assertContextKind('class', decoratorName, context);
+                this.register(context.metadata, {
+                    kind: 'class',
+                    decorator: decoratorName,
+                    metadata,
+                    static: false,
+                    private: false,
+                });
+            };
+        });
+        return factory;
+    }
+    createScopedClassFactory(decoratorName) {
+        return ((...args) => {
+            const metadata = args.length === 0 ? undefined : args[0];
+            return (_value, context) => {
+                assertContextKind('class', decoratorName, context);
+                this.register(context.metadata, {
+                    kind: 'class',
+                    decorator: decoratorName,
+                    metadata,
+                    static: false,
+                    private: false,
+                });
+            };
+        });
+    }
+    createPropertyFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('property', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('property', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createMethodFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('method', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('method', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createAccessorFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('accessor', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('accessor', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createMemberDecorator(kind, decoratorName, parsed) {
+        return (_value, context) => {
+            assertContextKind(kind, decoratorName, context);
+            if (context.private && !this.allowPrivateMembers) {
+                throw new Error(`Decorator "${decoratorName}" cannot be used on private member "${String(context.name)}" unless allowPrivateMembers is true.`);
+            }
+            if (parsed.key !== undefined && !samePropertyKey(parsed.key, context.name)) {
+                throw new Error(`Decorator "${decoratorName}" was keyed for "${String(parsed.key)}" but applied to "${String(context.name)}".`);
+            }
+            this.register(context.metadata, {
+                kind,
+                decorator: decoratorName,
+                metadata: parsed.metadata,
+                memberName: context.name,
+                static: context.static,
+                private: context.private,
+            });
+        };
+    }
+    register(metadataObject, record) {
+        const order = this.nextOrder;
+        this.nextOrder += 1;
+        const immutableRecord = Object.freeze(Object.assign(Object.assign({}, record), { id: `${this.namespace}:${record.kind}:${record.decorator}:${order}`, order, metadata: (0, clone_1.immutableClone)(record.metadata) }));
+        const existing = this.recordsByMetadata.get(metadataObject);
+        if (existing === undefined) {
+            this.recordsByMetadata.set(metadataObject, [immutableRecord]);
+        }
+        else {
+            existing.push(immutableRecord);
+        }
+    }
+}
+function createDecoratorRegistry(options = {}) {
+    return new ModernDecoratorRegistry(options);
+}

package/build/decorators/factory/examples/accessors.d.ts

@@ -0,0 +1,25 @@
+type ViewDecorators = {
+    class: {};
+    property: {};
+    method: {};
+    accessor: {
+        cached: {
+            metadata: {
+                ttlMs?: number;
+            };
+            target: string;
+        };
+    };
+};
+type UserViewContract = {
+    displayName: string;
+};
+declare const registry: import("../types").DecoratorRegistry<ViewDecorators>;
+declare class UserView implements UserViewContract {
+    accessor displayName: string;
+}
+export declare function readAccessorMetadata(): {
+    memberName: string | symbol;
+    ttlMs: number | undefined;
+}[];
+export { UserView, registry as accessorRegistry };

package/build/decorators/factory/examples/accessors.js

@@ -0,0 +1,87 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessorRegistry = exports.UserView = void 0;
+exports.readAccessorMetadata = readAccessorMetadata;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'accessor-example' });
+exports.accessorRegistry = registry;
+const View = registry.for();
+const Cached = View.accessor('cached');
+let UserView = (() => {
+    var _a, _UserView_displayName_accessor_storage;
+    let _displayName_decorators;
+    let _displayName_initializers = [];
+    let _displayName_extraInitializers = [];
+    return _a = class UserView {
+            get displayName() { return __classPrivateFieldGet(this, _UserView_displayName_accessor_storage, "f"); }
+            set displayName(value) { __classPrivateFieldSet(this, _UserView_displayName_accessor_storage, value, "f"); }
+            constructor() {
+                _UserView_displayName_accessor_storage.set(this, __runInitializers(this, _displayName_initializers, 'Ray'));
+                __runInitializers(this, _displayName_extraInitializers);
+            }
+        },
+        _UserView_displayName_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _displayName_decorators = [Cached('displayName', { ttlMs: 1000 })];
+            __esDecorate(_a, null, _displayName_decorators, { kind: "accessor", name: "displayName", static: false, private: false, access: { has: obj => "displayName" in obj, get: obj => obj.displayName, set: (obj, value) => { obj.displayName = value; } }, metadata: _metadata }, _displayName_initializers, _displayName_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+exports.UserView = UserView;
+function readAccessorMetadata() {
+    return registry.read(UserView).accessorRecords('cached').map((record) => {
+        if (record.memberName === undefined)
+            throw new Error('Missing member name.');
+        return {
+            memberName: record.memberName,
+            ttlMs: record.metadata.ttlMs,
+        };
+    });
+}

package/build/decorators/factory/examples/crud.d.ts

@@ -0,0 +1,50 @@
+type CrudController<TEntity, TCreateInput> = {
+    id: string;
+    get(id: string): Promise<TEntity>;
+    create(input: TCreateInput): Promise<TEntity>;
+};
+type UserDto = {
+    id: string;
+    email: string;
+};
+type CreateUserInput = {
+    email: string;
+};
+type UserCrudController = CrudController<UserDto, CreateUserInput>;
+type CrudDecorators = {
+    class: {
+        resource: {
+            metadata: {
+                name: string;
+            };
+        };
+    };
+    property: {
+        idField: {
+            metadata: undefined;
+            target: string;
+        };
+    };
+    method: {
+        route: {
+            metadata: {
+                method: 'GET' | 'POST';
+                path: string;
+            };
+            target: (...args: any[]) => Promise<unknown>;
+        };
+    };
+    accessor: {};
+};
+declare const registry: import("../types").DecoratorRegistry<CrudDecorators>;
+declare class UserCrud implements UserCrudController {
+    id: string;
+    get(id: string): Promise<UserDto>;
+    create(input: CreateUserInput): Promise<UserDto>;
+}
+export declare function buildCrudSummary(): {
+    resource: string;
+    routes: string[];
+    idFields: Array<string | symbol>;
+};
+export { UserCrud, registry as crudRegistry };