phecda-server 7.0.0-alpha.15 → 7.0.0-alpha.18

package/dist/core-C8nKzrYj.d.ts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, f as Meta, E as Emitter } from './types-B_RVNTOF.js';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-CTa38Qb8.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-pCI7fyyv.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-C_vzHvIM.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-DwkH_ckj.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-CjJyvCUL.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-DfsKsjLM.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-CxB9E1Mb.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-DfNtpP-N.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-D5cwjnXb.d.ts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, f as Meta, E as Emitter } from './types-C6hpZpnS.js';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-D9ivz8Je.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, f as Meta, E as Emitter } from './types-C6hpZpnS.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/{core-KvmgTDU0.d.ts → core-DEjpz7U-.d.ts}

@@ -1,5 +1,5 @@
 import { Construct } from 'phecda-core';
-import { b as MetaData, M as Meta, E as Emitter } from './meta-DlHaMicF.js';
+import { M as MetaData, a as Meta, E as Emitter } from './meta-vC_LItVL.js';
 
 declare abstract class Generator {
     private _path;

package/dist/core-DFoppC8I.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, f as Meta, E as Emitter } from './types-BRCJyQsh.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-DU0-ELVr.d.ts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-DwkH_ckj.js';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-Dk6Y21IK.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, a as Meta, E as Emitter } from './meta-vC_LItVL.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-ppueS5ax.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, a as Meta, E as Emitter } from './types-DWVRUI6s.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-scwP4qK3.d.ts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, a as Meta, E as Emitter } from './types-DWVRUI6s.js';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-vtBLhyjz.d.mts

@@ -0,0 +1,49 @@
+import { Construct } from 'phecda-core';
+import { M as MetaData, i as Meta, E as Emitter } from './types-mcWWx2nR.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
+    destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/helper.d.mts

@@ -1,4 +1,4 @@
-import { M as Meta, C as ControllerMeta } from './meta-DlHaMicF.mjs';
+import { a as Meta, b as ControllerMeta } from './meta-vC_LItVL.mjs';
 import { Construct } from 'phecda-core';
 
 declare function HMR(cb: (oldModels: Construct[], newModels: Construct[]) => any): void;

package/dist/helper.d.ts

@@ -1,4 +1,4 @@
-import { M as Meta, C as ControllerMeta } from './meta-DlHaMicF.js';
+import { a as Meta, b as ControllerMeta } from './meta-vC_LItVL.js';
 import { Construct } from 'phecda-core';
 
 declare function HMR(cb: (oldModels: Construct[], newModels: Construct[]) => any): void;