@venizia/ignis-kernel 0.4.3 → 0.4.5

package/dist/cjs/helpers/inversion/registry.d.ts

@@ -1,588 +0,0 @@
-import type { AnyType, TClass } from '@venizia/ignis-helpers/common';
-import { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
-import type { IModelRegistryEntry, IRepositoryBinding } from './common/types';
-declare const BaseRegistry: {
-    new (...args: any[]): {
-        discoveredArtifacts: object[];
-        addDiscoveredArtifact<Target extends object = object>(opts: {
-            target: Target;
-        }): void;
-        getDiscoveredArtifacts(): ReadonlyArray<object>;
-        clearDiscoveredArtifacts(): void;
-        setArtifactMetadata<Target extends object = object, ApplicationType = unknown>(opts: {
-            target: Target;
-            metadata: import("./common/types").IArtifactMetadata<ApplicationType>;
-        }): void;
-        getArtifactMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IArtifactMetadata | undefined;
-        addProvideMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").IProvideMetadata;
-        }): void;
-        getProvideMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IProvideMetadata[];
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        addRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("./common/types").IRpcMetadata;
-        }): void;
-        getRpcs<Target extends object = object>(opts: {
-            target: Target;
-        }): Map<string | symbol, import("./common/types").IRpcMetadata> | undefined;
-        getRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("./common/types").IRpcMetadata | undefined;
-        hasRpcs<Target extends object = object>(opts: {
-            target: Target;
-        }): boolean;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        getRoutes<Target extends object = object>(opts: {
-            target: Target;
-        }): Map<string | symbol, import("../..").IAuthRouteConfig> | undefined;
-        getRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("../..").IAuthRouteConfig | undefined;
-        hasRoutes<Target extends object = object>(opts: {
-            target: Target;
-        }): boolean;
-        addRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("../..").IAuthRouteConfig;
-        }): void;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        setControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").TControllerMetadata;
-        }): void;
-        getControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").TControllerMetadata | undefined;
-        getRestControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IRestControllerMetadata | undefined;
-        getGrpcControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IGrpcControllerMetadata | undefined;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        repositoryBindings: Map<string, IRepositoryBinding<import("../..").AbstractEntity>>;
-        repositoryBindingsByClass: Map<Function, IRepositoryBinding<import("../..").AbstractEntity>>;
-        datasourceModels: Map<string | Function, Set<TClass<AnyType>>>;
-        setRepositoryMetadata<Target extends object = object, Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: {
-            target: Target;
-            metadata: import("./common/types").TRepositoryMetadata<Model, DataSource> & {
-                _resolved?: import("./common/types").IResolvedRepositoryMetadata<Model, DataSource> | undefined;
-            };
-        }): void;
-        getRepositoryMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): (import("./common/types").TRepositoryMetadata & {
-            _resolved?: import("./common/types").IResolvedRepositoryMetadata;
-        }) | undefined;
-        registerRepositoryBinding<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: IRepositoryBinding<Model, DataSource>): void;
-        getRepositoryBinding(opts: {
-            target: Function;
-        } | {
-            name: string;
-        }): IRepositoryBinding<import("../..").AbstractEntity> | undefined;
-        getDataSourceModelClasses(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): Set<TClass<AnyType>>;
-        resolveModelRelations(modelMeta: IModelRegistryEntry): unknown;
-        getModels(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            tableName: string;
-            schema: unknown;
-            relations?: unknown;
-        }[];
-        getModelClasses(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): Array<TClass<unknown>>;
-        resolveModelKey(opts: {
-            modelClass: TClass<AnyType>;
-        }): string;
-        buildSchema(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            schema: Record<string, unknown>;
-            relations: Record<string, unknown>;
-        };
-        hasModels(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): boolean;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-        modelRegistry: Map<string, IModelRegistryEntry>;
-        getModelMetadata: (opts: {
-            target: object;
-        }) => import("./common/types").IModelMetadata | undefined;
-    };
-} & {
-    new (...args: any[]): {
-        modelRegistry: Map<string, IModelRegistryEntry>;
-        modelsBySchema: WeakMap<object, IModelRegistryEntry>;
-        setModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IModelMetadata | undefined;
-        registerModel<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>>(opts: {
-            target: import("./common/types").TDecoratorModelTarget<Model>;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelEntry(opts: {
-            name: string;
-        }): IModelRegistryEntry | undefined;
-        getModelEntryBySchema(opts: {
-            schema: object;
-        }): IModelRegistryEntry | undefined;
-        getAllModels(): Map<string, IModelRegistryEntry>;
-        getModelAuthorizeSettings(opts: {
-            name: string;
-        }): import("./common/types").IModelAuthorizeSettings | undefined;
-        getAuthorizeModelPrincipals(opts: {
-            format: "array";
-        }): string[];
-        getAuthorizeModelPrincipals(opts: {
-            format: "record";
-        }): Record<string, string>;
-        getAuthorizeModelSettings(opts: {
-            format: "array";
-        }): {
-            name: string;
-            authorize: import("./common/types").IModelAuthorizeSettings;
-            entry: IModelRegistryEntry;
-        }[];
-        getAuthorizeModelSettings(opts: {
-            format: "record";
-        }): Record<string, {
-            authorize: import("./common/types").IModelAuthorizeSettings;
-            entry: IModelRegistryEntry;
-        }>;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        setDataSourceMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata?: import("./common/types").IDataSourceMetadata;
-        }): void;
-        getDataSourceMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IDataSourceMetadata | undefined;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        setBindingKey: <T extends object = object>(opts: {
-            target: T;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            isProvisional?: boolean;
-        }) => void;
-        getBindingKey: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & typeof _MetadataRegistry;
-/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
-export declare class MetadataRegistry extends BaseRegistry {
-    static readonly SINGLETON_REAL_KEY = "metadata-registry";
-    private constructor();
-    static getInstance(): MetadataRegistry;
-    clearAll(): void;
-}
-export {};
-//# sourceMappingURL=registry.d.ts.map

package/dist/cjs/helpers/inversion/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAEjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAW9E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAsCyS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAD,CAAC;;;;;;;;4BA9B3T,CAAC;AAEF,iHAAiH;AACjH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,MAAM,CAAC,QAAQ,CAAC,kBAAkB,uBAAuB;IAEzD,OAAO;IASP,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAOtC,QAAQ,IAAI,IAAI;CAOjB"}

package/dist/cjs/helpers/inversion/registry.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataRegistry = void 0;
-const ignis_inversion_1 = require("@venizia/ignis-inversion");
-const singleton_realm_1 = require("../singleton-realm");
-const mixins_1 = require("./mixins");
-const BaseRegistry = (0, mixins_1.ArtifactMetadataMixin)((0, mixins_1.GrpcControllerMetadataMixin)((0, mixins_1.RestControllerMetadataMixin)((0, mixins_1.ControllerMetadataMixin)((0, mixins_1.RepositoryMetadataMixin)((0, mixins_1.ModelMetadataMixin)((0, mixins_1.DatasourceMetadataMixin)(ignis_inversion_1.MetadataRegistry)))))));
-/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
-class MetadataRegistry extends BaseRegistry {
-    static { this.SINGLETON_REAL_KEY = 'metadata-registry'; }
-    constructor() {
-        super();
-        this.modelRegistry = new Map();
-        this.modelsBySchema = new WeakMap();
-        this.repositoryBindings = new Map();
-        this.repositoryBindingsByClass = new Map();
-        this.datasourceModels = new Map();
-    }
-    static getInstance() {
-        return singleton_realm_1.SingletonRealm.resolve({
-            key: MetadataRegistry.SINGLETON_REAL_KEY,
-            create: () => new MetadataRegistry(),
-        });
-    }
-    clearAll() {
-        this.modelRegistry.clear();
-        this.modelsBySchema = new WeakMap();
-        this.repositoryBindings.clear();
-        this.repositoryBindingsByClass.clear();
-        this.datasourceModels.clear();
-    }
-}
-exports.MetadataRegistry = MetadataRegistry;
-//# sourceMappingURL=registry.js.map

package/dist/cjs/helpers/inversion/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":";;;AACA,8DAAiF;AACjF,wDAAoD;AAEpD,qCAQkB;AAElB,MAAM,YAAY,GAAG,IAAA,8BAAqB,EACxC,IAAA,oCAA2B,EACzB,IAAA,oCAA2B,EACzB,IAAA,gCAAuB,EACrB,IAAA,gCAAuB,EAAC,IAAA,2BAAkB,EAAC,IAAA,gCAAuB,EAAC,kCAAiB,CAAC,CAAC,CAAC,CACxF,CACF,CACF,CACF,CAAC;AAEF,iHAAiH;AACjH,MAAa,gBAAiB,SAAQ,YAAY;aAChC,uBAAkB,GAAG,mBAAmB,CAAC;IAEzD;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,EAA+B,CAAC;QAC5D,IAAI,CAAC,cAAc,GAAG,IAAI,OAAO,EAA+B,CAAC;QACjE,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAA8B,CAAC;QAChE,IAAI,CAAC,yBAAyB,GAAG,IAAI,GAAG,EAAgC,CAAC;QACzE,IAAI,CAAC,gBAAgB,GAAG,IAAI,GAAG,EAA2C,CAAC;IAC7E,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,OAAO,gCAAc,CAAC,OAAO,CAAC;YAC5B,GAAG,EAAE,gBAAgB,CAAC,kBAAkB;YACxC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,gBAAgB,EAAE;SACrC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,IAAI,OAAO,EAA+B,CAAC;QACjE,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC;QACvC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC;;AAzBH,4CA0BC","sourcesContent":["import type { AnyType, TClass } from '@venizia/ignis-helpers/common';\nimport { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';\nimport { SingletonRealm } from '../singleton-realm';\nimport type { IModelRegistryEntry, IRepositoryBinding } from './common/types';\nimport {\n  ArtifactMetadataMixin,\n  ControllerMetadataMixin,\n  DatasourceMetadataMixin,\n  GrpcControllerMetadataMixin,\n  ModelMetadataMixin,\n  RepositoryMetadataMixin,\n  RestControllerMetadataMixin,\n} from './mixins';\n\nconst BaseRegistry = ArtifactMetadataMixin(\n  GrpcControllerMetadataMixin(\n    RestControllerMetadataMixin(\n      ControllerMetadataMixin(\n        RepositoryMetadataMixin(ModelMetadataMixin(DatasourceMetadataMixin(_MetadataRegistry))),\n      ),\n    ),\n  ),\n);\n\n/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */\nexport class MetadataRegistry extends BaseRegistry {\n  static readonly SINGLETON_REAL_KEY = 'metadata-registry';\n\n  private constructor() {\n    super();\n    this.modelRegistry = new Map<string, IModelRegistryEntry>();\n    this.modelsBySchema = new WeakMap<object, IModelRegistryEntry>();\n    this.repositoryBindings = new Map<string, IRepositoryBinding>();\n    this.repositoryBindingsByClass = new Map<Function, IRepositoryBinding>();\n    this.datasourceModels = new Map<string | Function, Set<TClass<AnyType>>>();\n  }\n\n  static getInstance(): MetadataRegistry {\n    return SingletonRealm.resolve({\n      key: MetadataRegistry.SINGLETON_REAL_KEY,\n      create: () => new MetadataRegistry(),\n    });\n  }\n\n  clearAll(): void {\n    this.modelRegistry.clear();\n    this.modelsBySchema = new WeakMap<object, IModelRegistryEntry>();\n    this.repositoryBindings.clear();\n    this.repositoryBindingsByClass.clear();\n    this.datasourceModels.clear();\n  }\n}\n"]}

package/dist/cjs/helpers/singleton-realm.d.ts

@@ -1,30 +0,0 @@
-/**
- * Anchors a value on the realm instead of on a module.
- *
- * Two copies of `@venizia/ignis-kernel` can end up in one install without either package changing:
- * `@venizia/ignis` and `@venizia/ignis-connectors` each pin a range, and the day those ranges stop
- * intersecting a package manager installs a nested second copy rather than failing. Module-level
- * statics then split in two, and nothing throws - `@repository` writes into one `datasourceModels`
- * map while `discoverSchema()` reads the other, `buildSchema()` returns `{}`, and every query fails
- * for a reason that points nowhere near the cause.
- *
- * `Symbol.for` is keyed on a global registry per realm, so both copies resolve the same symbol and
- * therefore the same instance. A browser tab and its Worker are separate realms and still get one
- * registry each, which is correct - they run separate applications.
- */
-export declare class SingletonRealm {
-    private static readonly ANCHOR_PREFIX;
-    /**
-     * Anchors are memoized, not the values: an anchored value is created once and only ever mutated,
-     * so re-deriving its symbol per call buys nothing. The audit enrichers reach this twice per
-     * inserted row.
-     */
-    private static readonly anchors;
-    /** The realm's own singleton for `key`, created on first call and shared by every copy of this package. */
-    static resolve<T>(opts: {
-        key: string;
-        create: () => T;
-    }): T;
-    private static anchorFor;
-}
-//# sourceMappingURL=singleton-realm.d.ts.map

package/dist/cjs/helpers/singleton-realm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"singleton-realm.d.ts","sourceRoot":"","sources":["../../../src/helpers/singleton-realm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAA4B;IAEjE;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAE5D,2GAA2G;IAC3G,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,CAAC;IAkB5D,OAAO,CAAC,MAAM,CAAC,SAAS;CAazB"}