@cosmicdrift/kumiko-types 0.326.1 → 0.328.0

package/dist/feature.d.ts

@@ -0,0 +1,518 @@
+import type * as z from "zod";
+import type { ZodType } from "zod";
+import type { ConfigKeyDefinition, ConfigKeyHandle, ConfigKeyType, ConfigSeedDef, ExtensionSelectorDef, JobDefinition, JobHandlerFn, NotificationDataFn, NotificationDefinition, NotificationRecipientFn, NotificationTemplateFn, ReferenceDataDef, RegistrarExtensionDef, RegistrarExtensionRegistration, TranslationKeys, TranslationsDef } from "./config.js";
+import type { QueryHandlerDefinition, StreamHandlerDefinition, WriteHandlerDefinition } from "./define-handler.js";
+import type { RegisterEntityCrudOptions } from "./entity-handlers.js";
+import type { EntityTableMeta } from "./entity-table-meta-types.js";
+import type { ExtensionOptionsArgs, ExtensionOptionsFor } from "./extension-options-map.js";
+import type { EntityDefinition } from "./fields.js";
+import type { AccessRule, AgentHandlerHints, AuthClaimsFn, AuthClaimsHookDef, ClaimKeyDefinition, ClaimKeyHandle, ClaimKeyType, DeclarativeEventMigration, EntityRef, EscapeHatchDeclaration, EventDef, EventMigrationDef, EventPiiStance, EventUpcastFn, HandlerRef, NameOrRef, QualifiedEventName, QueryHandlerDef, QueryHandlerFn, RateLimitDeclaration, StreamHandlerDef, StreamHandlerFn, WriteHandlerDef, WriteHandlerFn } from "./handlers.js";
+import type { EntityHookMap, HookMap, HookPhase, OwnedFn, PostDeleteHookFn, PostQueryHookFn, PostSaveHookFn, PreDeleteHookFn, PreQueryHookFn, PreSaveHookFn, SearchPayloadContributorFn, ValidationHookFn } from "./hooks.js";
+import type { HttpRouteDefinition } from "./http-route.js";
+import type { ContentCollectionDefinition, NavDefinition } from "./nav.js";
+import type { EntityProjectionExtension, MultiStreamProjectionDefinition, ProjectionDefinition } from "./projection.js";
+import type { EntityRelations, RelationDefinition } from "./relations.js";
+import type { ScreenDefinition } from "./screen.js";
+import type { TreeActionDef, TreeActionsHandle } from "./tree-node.js";
+import type { WebSocketRouteDefinition } from "./websocket-route.js";
+import type { WorkspaceDefinition } from "./workspace.js";
+export type FeatureMetricType = "counter" | "histogram" | "gauge";
+export type FeatureMetricDef = {
+    readonly shortName: string;
+    readonly type: FeatureMetricType;
+    readonly description?: string;
+    readonly labels?: readonly string[];
+    readonly buckets?: readonly number[];
+    readonly unit?: string;
+    readonly tenantLabel?: boolean;
+};
+export type MetricOptions = Omit<FeatureMetricDef, "shortName">;
+export type SecretKeyDefinition = {
+    readonly shortName: string;
+    readonly qualifiedName: string;
+    readonly label: {
+        readonly [locale: string]: string;
+    };
+    readonly redact?: (plaintext: string) => string;
+    readonly hint?: {
+        readonly [locale: string]: string;
+    };
+    readonly scope: "tenant";
+    readonly required?: boolean;
+};
+export type SecretOptions = Omit<SecretKeyDefinition, "shortName" | "qualifiedName">;
+export type SecretKeyHandle = {
+    readonly name: string;
+};
+/** Options accepted by `r.storeTable()`. The `reason` is required so the
+ *  bypass leaves an audit trail at the registration site — reviewers can
+ *  judge legitimacy without spelunking into history, and a future cleanup
+ *  pass can find candidates for migration to `r.entity()`. */
+export type StoreTableOptions = {
+    /** Why this table needs to bypass the event-sourcing system. Examples:
+     *  "imported from pre-ES system, read-only", "external Stripe webhook
+     *  payload cache, write-only by webhook handler", "denormalised
+     *  projection of a non-Kumiko data source". */
+    readonly reason: string;
+    /** Direct-write stores skip the executor, so the executor's PII
+     *  encryption never runs for them — a feature whose meta carries
+     *  piiSubjectFields must encrypt those fields itself before every
+     *  insert/update and declare that here, or boot fails (#820). */
+    readonly piiEncryptedOnWrite?: true;
+};
+/** Per-feature store-table registration. `meta` is the `EntityTableMeta`
+ *  (framework-native shape used by `migrate-runner`). Carries the
+ *  bypass-justification reason but knows nothing about the owning
+ *  feature — that's added when the registry aggregates entries
+ *  cross-feature into `StoreTableDef`. */
+export type StoreTableEntry = {
+    readonly name: string;
+    readonly meta: EntityTableMeta;
+    readonly reason: string;
+    readonly piiEncryptedOnWrite?: true;
+};
+/** Registry-aggregated store-table — the per-feature `StoreTableEntry` plus
+ *  the owning feature name. This is what `Registry.getAllStoreTables()`
+ *  exposes to readers (dev-server, ops UIs). */
+export type StoreTableDef = StoreTableEntry & {
+    readonly featureName: string;
+};
+export type UiHintOption = {
+    readonly key: string;
+    readonly label: string;
+    readonly type: "boolean";
+    readonly default: boolean;
+};
+export type UiHints = {
+    readonly displayLabel?: string;
+    readonly category?: string;
+    readonly recommended?: boolean;
+    readonly configurableOptions?: readonly UiHintOption[];
+};
+export type BootCheckContext = {
+    readonly features: readonly FeatureDefinition[];
+};
+export type BootCheckFn = (ctx: BootCheckContext) => void;
+export type FeatureDefinition = {
+    readonly name: string;
+    readonly description?: string;
+    readonly systemScope: boolean;
+    readonly exports?: unknown;
+    readonly requires: readonly string[];
+    readonly optionalRequires: readonly string[];
+    readonly requiredProjections: ReadonlySet<string>;
+    readonly requiredSteps: ReadonlySet<string>;
+    readonly toggleableDefault?: boolean;
+    readonly uiHints?: UiHints;
+    readonly entities?: Readonly<Record<string, EntityDefinition>>;
+    readonly entityTables?: Readonly<Record<string, unknown>>;
+    readonly relations: Readonly<Record<string, EntityRelations>>;
+    readonly writeHandlers: Readonly<Record<string, WriteHandlerDef>>;
+    readonly queryHandlers: Readonly<Record<string, QueryHandlerDef>>;
+    readonly streamHandlers: Readonly<Record<string, StreamHandlerDef>>;
+    readonly translations: TranslationKeys;
+    readonly hooks?: HookMap;
+    readonly entityHooks?: EntityHookMap;
+    readonly searchPayloadExtensions?: Readonly<Record<string, readonly OwnedFn<SearchPayloadContributorFn>[]>>;
+    readonly configKeys: Readonly<Record<string, ConfigKeyDefinition>>;
+    readonly configSeeds: readonly ConfigSeedDef[];
+    readonly jobs: Readonly<Record<string, JobDefinition>>;
+    readonly registrarExtensions: Readonly<Record<string, RegistrarExtensionDef>>;
+    readonly extensionUsages: readonly RegistrarExtensionRegistration[];
+    readonly extensionSelectors: readonly ExtensionSelectorDef[];
+    /**
+     * Cross-feature API names this feature exposes via `r.exposesApi(name)`.
+     * Pure Marker-Deklaration — die echte Implementation wird als
+     * Query-/Write-Handler unter dem QN-Pattern registriert (z.B.
+     * `compliance-profiles:query:effective-profile`). Boot-Validator prüft
+     * dass jedes `r.usesApi(name)` einen passenden Exposer hier findet —
+     * Tippfehler oder Drop-Refactorings werden zu Boot-Fail statt Runtime-Crash.
+     */
+    readonly exposedApis: ReadonlySet<string>;
+    /**
+     * Cross-feature API names this feature calls. Pflicht-Boot-Check:
+     * jeder Eintrag muss in `exposedApis` irgendeines Features auftauchen
+     * UND das Provider-Feature muss in requires/optionalRequires sein.
+     */
+    readonly usedApis: ReadonlySet<string>;
+    /**
+     * Boot-time mount-invariant checks declared via `r.bootCheck(fn)`. Run
+     * once per feature after all other boot-validators, each with a ctx
+     * exposing the full mounted-feature set — throw to fail the boot with a
+     * feature-authored message (framework wraps it with `[Feature <name>]`).
+     */
+    readonly bootChecks: readonly BootCheckFn[];
+    readonly referenceData: readonly ReferenceDataDef[];
+    readonly notifications: Readonly<Record<string, NotificationDefinition>>;
+    readonly events: Readonly<Record<string, EventDef>>;
+    readonly eventMigrations: Readonly<Record<string, readonly EventMigrationDef[]>>;
+    readonly configReads: readonly string[];
+    readonly handlerEntityMappings: Readonly<Record<string, string>>;
+    readonly metrics: Readonly<Record<string, FeatureMetricDef>>;
+    readonly secretKeys: Readonly<Record<string, SecretKeyDefinition>>;
+    readonly projections: Readonly<Record<string, ProjectionDefinition>>;
+    readonly entityProjectionExtensions?: Readonly<Record<string, readonly EntityProjectionExtension[]>>;
+    readonly multiStreamProjections: Readonly<Record<string, MultiStreamProjectionDefinition>>;
+    readonly authClaimsHooks: readonly AuthClaimsFn[];
+    readonly claimKeys: Readonly<Record<string, ClaimKeyDefinition>>;
+    readonly screens: Readonly<Record<string, ScreenDefinition>>;
+    readonly navs: Readonly<Record<string, NavDefinition>>;
+    readonly workspaces: Readonly<Record<string, WorkspaceDefinition>>;
+    readonly treeActions?: Readonly<Record<string, TreeActionDef>>;
+    readonly contentCollections?: Readonly<Record<string, ContentCollectionDefinition>>;
+    readonly httpRoutes: Readonly<Record<string, HttpRouteDefinition>>;
+    readonly webSocketRoutes: Readonly<Record<string, WebSocketRouteDefinition>>;
+    readonly storeTables: Readonly<Record<string, StoreTableEntry>>;
+    readonly envSchema?: z.ZodObject<z.ZodRawShape>;
+    readonly dedupeOptions?: Readonly<Record<string, unknown>>;
+};
+type RefOrRefs = NameOrRef | readonly NameOrRef[];
+type HookTarget = RefOrRefs | {
+    readonly allOf: NameOrRef;
+};
+/**
+ * `TFeature` is the literal feature-name from `defineFeature("foo", ...)` —
+ * default-`string` keeps every existing usage zero-config. Strict-typed
+ * features (apps that opt into the literal-name flavour) get propagated
+ * through to `defineEvent` so the returned `EventDef.name` is a literal
+ * `${CamelToKebab<TFeature>}:event:${CamelToKebab<TInner>}`. That literal
+ * threads through `ctx.appendEvent({ type: eventDef.name, ... })`,
+ * keeping strict-mode alive even when handlers route via `eventDef.name`
+ * instead of hand-typed string literals.
+ */
+/**
+ * `r.requires` is a callable+namespace: existing call form takes feature
+ * names (`r.requires("auth", "tenant")`), the `.projection` extension
+ * declares read-side projection tables that this feature's pipeline
+ * steps are allowed to write via `r.step.unsafeProjectionUpsert`.
+ * Hard-required for any unsafeProjection-* step usage (see Q10).
+ */
+export type RequiresApi = ((...featureNames: string[]) => void) & ((options: {
+    readonly features: readonly string[];
+}) => void) & {
+    readonly projection: (tableName: string) => void;
+    readonly step: (stepKind: string) => void;
+};
+export type FeatureRegistrar<TFeature extends string = string> = {
+    systemScope(): void;
+    describe(text: string): void;
+    requires: RequiresApi;
+    optionalRequires(...featureNames: string[]): void;
+    optionalRequires(options: {
+        readonly features: readonly string[];
+    }): void;
+    toggleable(options: {
+        default: boolean;
+    }): void;
+    uiHints(hints: UiHints): void;
+    entity(name: string, definition: EntityDefinition, options?: {
+        readonly table?: unknown;
+    }): EntityRef;
+    entity(definition: {
+        readonly name: string;
+    } & EntityDefinition): EntityRef;
+    crud(entityName: string, entity: EntityDefinition, options?: RegisterEntityCrudOptions): void;
+    writeHandler<TName extends string, TSchema extends ZodType>(def: WriteHandlerDefinition<TName, TSchema>): HandlerRef;
+    writeHandler<TSchema extends ZodType>(name: string, schema: TSchema, handler: WriteHandlerFn<z.infer<TSchema>>, options: {
+        access: AccessRule;
+        rateLimit?: RateLimitDeclaration;
+        description?: string;
+        agent?: AgentHandlerHints;
+        escapeHatch?: EscapeHatchDeclaration;
+    }): HandlerRef;
+    queryHandler<TName extends string, TSchema extends ZodType>(def: QueryHandlerDefinition<TName, TSchema>): HandlerRef;
+    queryHandler<TSchema extends ZodType>(name: string, schema: TSchema, handler: QueryHandlerFn<z.infer<TSchema>>, options: {
+        access: AccessRule;
+        rateLimit?: RateLimitDeclaration;
+        outputSchema?: ZodType;
+        description?: string;
+        agent?: AgentHandlerHints;
+        escapeHatch?: EscapeHatchDeclaration;
+    }): HandlerRef;
+    streamHandler<TName extends string, TSchema extends ZodType>(def: StreamHandlerDefinition<TName, TSchema>): HandlerRef;
+    streamHandler<TSchema extends ZodType>(name: string, schema: TSchema, handler: StreamHandlerFn<z.infer<TSchema>>, options: {
+        access: AccessRule;
+        rateLimit?: RateLimitDeclaration;
+        escapeHatch?: EscapeHatchDeclaration;
+    }): HandlerRef;
+    relation(entity: NameOrRef, relationName: string, definition: RelationDefinition): void;
+    relation<TDef extends RelationDefinition>(definition: {
+        readonly entity: NameOrRef;
+        readonly name: string;
+    } & TDef): void;
+    hook(type: "validation", target: RefOrRefs, fn: ValidationHookFn): void;
+    hook(type: "preSave", target: RefOrRefs, fn: PreSaveHookFn, options?: {
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    hook(type: "postSave", target: HookTarget, fn: PostSaveHookFn, options?: {
+        phase?: HookPhase;
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    hook(type: "preDelete", target: HookTarget, fn: PreDeleteHookFn, options?: {
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    hook(type: "postDelete", target: HookTarget, fn: PostDeleteHookFn, options?: {
+        phase?: HookPhase;
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    hook(type: "preQuery", target: RefOrRefs, fn: PreQueryHookFn, options?: {
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    hook(type: "postQuery", target: HookTarget, fn: PostQueryHookFn, options?: {
+        escapeHatch?: EscapeHatchDeclaration;
+    }): void;
+    searchPayloadExtension(entity: NameOrRef, fn: SearchPayloadContributorFn): void;
+    config<T extends ConfigKeyType>(keyName: string, def: ConfigKeyDefinition<T>): ConfigKeyHandle<T>;
+    config<TKeys extends Readonly<Record<string, ConfigKeyDefinition<ConfigKeyType>>>>(definition: {
+        readonly keys: TKeys;
+        readonly seeds?: Readonly<Record<string, ConfigSeedDef>>;
+    }): {
+        readonly [K in keyof TKeys]: ConfigKeyHandle<TKeys[K]["type"]>;
+    };
+    job(name: string, options: Omit<JobDefinition, "name" | "handler">, handler: JobHandlerFn): void;
+    job(definition: JobDefinition): void;
+    notification(name: string, definition: {
+        readonly trigger: {
+            readonly on: NameOrRef;
+        };
+        readonly recipient: NotificationRecipientFn;
+        readonly data: NotificationDataFn;
+        readonly templates?: Readonly<Record<string, NotificationTemplateFn>>;
+    }): void;
+    notification(definition: {
+        readonly name: string;
+        readonly trigger: {
+            readonly on: NameOrRef;
+        };
+        readonly recipient: NotificationRecipientFn;
+        readonly data: NotificationDataFn;
+        readonly templates?: Readonly<Record<string, NotificationTemplateFn>>;
+    }): void;
+    translations(def: TranslationsDef): void;
+    defineEvent<const TInner extends string, TPayload>(name: TInner, schema: ZodType<TPayload>, options: {
+        readonly version?: number;
+        readonly piiFields: EventPiiStance;
+        readonly migrations?: readonly {
+            readonly fromVersion: number;
+            readonly toVersion: number;
+            readonly transform: EventUpcastFn | DeclarativeEventMigration;
+        }[];
+    }): EventDef<TPayload, QualifiedEventName<TFeature, TInner>>;
+    readsConfig(...qualifiedKeys: string[]): void;
+    readsConfig(options: {
+        readonly keys: readonly string[];
+    }): void;
+    referenceData(entity: NameOrRef, data: readonly Record<string, unknown>[], options?: {
+        upsertKey?: string;
+    }): void;
+    referenceData(definition: {
+        readonly entity: NameOrRef;
+        readonly data: readonly Record<string, unknown>[];
+        readonly upsertKey?: string;
+    }): void;
+    extendsRegistrar(name: string, def: RegistrarExtensionDef): void;
+    useExtension<N extends string>(extensionName: N, entity: NameOrRef, ...options: ExtensionOptionsArgs<N>): void;
+    useExtension<N extends string>(definition: {
+        readonly name: N;
+        readonly entity: NameOrRef;
+    } & ExtensionOptionsFor<N>): void;
+    /**
+     * Declares which config key selects the active provider under an
+     * extension point — called by the point-owning foundation (e.g.
+     * `r.extensionSelector("mailTransport", configKeys.provider)`).
+     * Readiness gating counts a provider-feature's `required` keys and
+     * secrets only while that provider is the selected one. Registry-build
+     * fails on duplicate declarations per extension and on selector keys
+     * that no mounted feature declares. A masked tenant selector key makes the
+     * Settings-Hub render one tenant dashboard for the owner: the selector as a
+     * select of the mounted plugin ids, the selected plugin's config and secrets
+     * as panels, and plugin features lose their own tenant nav. `config:write:set`
+     * rejects unknown plugin ids (`""` clears).
+     */
+    extensionSelector(extensionName: string, key: {
+        readonly name: string;
+    } | string): void;
+    /**
+     * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API
+     * unter dem genannten Namen bereit. Die eigentliche Implementation
+     * wird separat als Query- oder Write-Handler unter dem QN-Pattern
+     * registriert; `r.exposesApi` ist reine Boot-Check-Surface.
+     *
+     * Boot-Validator prüft, dass jedes `r.usesApi(name)` einen passenden
+     * Exposer findet, dass das Exposer-Feature in requires/optionalRequires
+     * gelisted ist und dass kein API-Name doppelt exposed wird.
+     *
+     * ```ts
+     * defineFeature("compliance-profiles", (r) => {
+     *   r.exposesApi("compliance.forTenant");
+     *   r.queryHandler({
+     *     name: "compliance:query:for-tenant",
+     *     // ... echte Implementation
+     *   });
+     * });
+     * ```
+     */
+    exposesApi(apiName: string): void;
+    /**
+     * Declares that this feature calls a cross-feature API. Boot-Validator
+     * checkt dass irgendein anderes Feature `r.exposesApi(apiName)` macht
+     * und dass dieses Feature `r.requires/optionalRequires` darauf hat.
+     *
+     * ```ts
+     * defineFeature("user-data-rights", (r) => {
+     *   r.requires("compliance-profiles");
+     *   r.usesApi("compliance.forTenant");
+     * });
+     * ```
+     */
+    usesApi(apiName: string): void;
+    /**
+     * Declares a boot-time mount-invariant for this feature. `fn` runs once
+     * at boot with a ctx exposing every mounted feature — throw to fail the
+     * boot with a clear message. Multiple calls per feature are allowed.
+     *
+     * Use for cross-feature invariants that `r.requires` can't express
+     * because they're conditional (only fail when the feature has a
+     * specific shape), e.g. "if this feature has PII entities, some
+     * user-data-hook feature must be mounted" (the prompt-store trap,
+     * kumiko-enterprise#229 — a UserData feature was written but never
+     * mounted, and nothing caught it at boot):
+     *
+     * ```ts
+     * defineFeature("prompt-store", (r) => {
+     *   const promptFields = { text: createTextField({ personal: "self", find: "none" }) };
+     *   r.entity("prompt", { fields: promptFields });
+     *   r.bootCheck(({ features }) => {
+     *     // Conditional on this feature's own shape (has a pii field) —
+     *     // r.requires("user-data-hook") can't express that, it would fail
+     *     // even for a prompt-store variant with no PII fields at all.
+     *     const hasPiiField = Object.values(promptFields).some((f) => f.pii);
+     *     const hasUserDataHook = features.some((f) => f.name === "user-data-hook");
+     *     if (hasPiiField && !hasUserDataHook) {
+     *       throw new Error("prompt-store has PII fields but no user-data-hook feature is mounted");
+     *     }
+     *   });
+     * });
+     * ```
+     */
+    bootCheck(fn: BootCheckFn): void;
+    metric(shortName: string, options: MetricOptions): void;
+    metric(definition: {
+        readonly name: string;
+    } & MetricOptions): void;
+    secret(shortName: string, options: SecretOptions): SecretKeyHandle;
+    secret(definition: {
+        readonly name: string;
+    } & SecretOptions): SecretKeyHandle;
+    projection(definition: ProjectionDefinition): void;
+    multiStreamProjection(definition: MultiStreamProjectionDefinition): void;
+    extendEntityProjection(entityName: string, extension: EntityProjectionExtension): void;
+    authClaims(fn: AuthClaimsFn): void;
+    claimKey<T extends ClaimKeyType>(shortName: string, options: {
+        readonly type: T;
+    }): ClaimKeyHandle<T>;
+    claimKey<T extends ClaimKeyType>(definition: {
+        readonly name: string;
+        readonly type: T;
+    }): ClaimKeyHandle<T>;
+    screen(definition: ScreenDefinition): void;
+    nav(definition: NavDefinition): void;
+    contentCollection(definition: ContentCollectionDefinition): string;
+    workspace(definition: WorkspaceDefinition): void;
+    httpRoute(definition: HttpRouteDefinition): void;
+    webSocketRoute(definition: WebSocketRouteDefinition): void;
+    storeTable(meta: EntityTableMeta, options: StoreTableOptions): void;
+    treeActions<const TActions extends Record<string, TreeActionDef>>(actions: TActions): TreeActionsHandle<TFeature, TActions>;
+    envSchema(schema: z.ZodObject<z.ZodRawShape>): void;
+};
+export type Registry = {
+    readonly features: ReadonlyMap<string, FeatureDefinition>;
+    getFeature(name: string): FeatureDefinition | undefined;
+    getEntity(name: string): EntityDefinition | undefined;
+    getAllEntities(): ReadonlyMap<string, EntityDefinition>;
+    getWriteHandler(name: string): WriteHandlerDef | undefined;
+    getQueryHandler(name: string): QueryHandlerDef | undefined;
+    getAllQueryHandlers(): ReadonlyMap<string, QueryHandlerDef>;
+    getAllWriteHandlers(): ReadonlyMap<string, WriteHandlerDef>;
+    getStreamHandler(name: string): StreamHandlerDef | undefined;
+    getAllStreamHandlers(): ReadonlyMap<string, StreamHandlerDef>;
+    getSearchableFields(entityName: string): readonly string[];
+    getSortableFields(entityName: string): readonly string[];
+    getRelations(entityName: string): EntityRelations;
+    getSearchableReferences(entityName: string): ReadonlyArray<{
+        fieldName: string;
+        targetEntityName: string;
+        labelField: string;
+    }>;
+    getSortableReferences(entityName: string): ReadonlyArray<{
+        fieldName: string;
+        targetEntityName: string;
+        labelField: string;
+    }>;
+    getIncomingRelations(entityName: string): ReadonlyArray<{
+        sourceEntity: string;
+        relationName: string;
+        relation: RelationDefinition;
+    }>;
+    getPreSaveHooks(name: string, effectiveFeatures?: ReadonlySet<string>): readonly PreSaveHookFn[];
+    getPostSaveHooks(name: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PostSaveHookFn[];
+    getPreDeleteHooks(name: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PreDeleteHookFn[];
+    getPostDeleteHooks(name: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PostDeleteHookFn[];
+    getPreQueryHooks(name: string, effectiveFeatures?: ReadonlySet<string>): readonly PreQueryHookFn[];
+    getPostQueryHooks(name: string, effectiveFeatures?: ReadonlySet<string>): readonly PostQueryHookFn[];
+    getEntityPostSaveHooks(entityName: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PostSaveHookFn[];
+    getEntityPreDeleteHooks(entityName: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PreDeleteHookFn[];
+    getEntityPostDeleteHooks(entityName: string, phase?: HookPhase, effectiveFeatures?: ReadonlySet<string>): readonly PostDeleteHookFn[];
+    getEntityPostQueryHooks(entityName: string, effectiveFeatures?: ReadonlySet<string>): readonly PostQueryHookFn[];
+    getSearchPayloadExtensions(entityName: string, effectiveFeatures?: ReadonlySet<string>): readonly SearchPayloadContributorFn[];
+    getHandlerEntity(qualifiedHandler: string): string | undefined;
+    isHandlerSystemScoped(qualifiedHandler: string): boolean;
+    isJobSystemScoped(qualifiedJobName: string): boolean;
+    getHandlerFeature(qualifiedHandler: string): string | undefined;
+    hasRateLimitedHandler(): boolean;
+    getAllMetrics(): ReadonlyMap<string, FeatureMetricDef & {
+        readonly featureName: string;
+    }>;
+    getAllTranslations(): TranslationKeys;
+    getConfigKey(qualifiedKey: string): ConfigKeyDefinition | undefined;
+    getAllConfigKeys(): ReadonlyMap<string, ConfigKeyDefinition>;
+    getAllConfigSeeds(): readonly ConfigSeedDef[];
+    getAllSecretKeys(): ReadonlyMap<string, SecretKeyDefinition>;
+    getSecretKey(qualifiedName: string): SecretKeyDefinition | undefined;
+    getJob(qualifiedName: string): JobDefinition | undefined;
+    getAllJobs(): ReadonlyMap<string, JobDefinition>;
+    getEvent(qualifiedName: string): EventDef | undefined;
+    getEventUpcasters(): ReadonlyMap<string, {
+        readonly currentVersion: number;
+        readonly chain: ReadonlyMap<number, EventUpcastFn>;
+    }>;
+    getExtension(name: string): RegistrarExtensionDef | undefined;
+    getExtensionUsages(extensionName: string): readonly RegistrarExtensionRegistration[];
+    getAllExtensionSelectors(): ReadonlyMap<string, string>;
+    getAllNotifications(): ReadonlyMap<string, NotificationDefinition>;
+    getAllReferenceData(): readonly ReferenceDataDef[];
+    getProjectionsForSource(entityName: string): readonly ProjectionDefinition[];
+    getAllProjections(): ReadonlyMap<string, ProjectionDefinition>;
+    getAllStoreTables(): ReadonlyMap<string, StoreTableDef>;
+    getAllMultiStreamProjections(): ReadonlyMap<string, MultiStreamProjectionDefinition>;
+    getMultiStreamProjectionFeature(qualifiedName: string): string | undefined;
+    getAuthClaimsHooks(): readonly AuthClaimsHookDef[];
+    getAllClaimKeys(): ReadonlyMap<string, ClaimKeyDefinition>;
+    getClaimKey(qualifiedName: string): ClaimKeyDefinition | undefined;
+    getAllScreens(): ReadonlyMap<string, ScreenDefinition>;
+    getScreen(qualifiedName: string): ScreenDefinition | undefined;
+    getScreenFeature(qualifiedName: string): string | undefined;
+    getScreensByEntity(entityName: string): readonly ScreenDefinition[];
+    getAllNavs(): ReadonlyMap<string, NavDefinition>;
+    getNav(qualifiedName: string): NavDefinition | undefined;
+    getNavFeature(qualifiedName: string): string | undefined;
+    getNavsByParent(parentQualifiedName: string): readonly NavDefinition[];
+    getTopLevelNavs(): readonly NavDefinition[];
+    getAllWorkspaces(): ReadonlyMap<string, WorkspaceDefinition>;
+    getWorkspace(qualifiedName: string): WorkspaceDefinition | undefined;
+    getWorkspaceFeature(qualifiedName: string): string | undefined;
+    getWorkspaceNavs(workspaceQualifiedName: string): readonly string[];
+    getDefaultWorkspace(): WorkspaceDefinition | undefined;
+    getTreeActions(featureName: string): Readonly<Record<string, TreeActionDef>> | undefined;
+};
+export {};

package/dist/feature.js

@@ -0,0 +1 @@
+export {};

package/dist/field-icon.d.ts

@@ -0,0 +1 @@
+export type FieldIconKey = "mail" | "lock" | "hash" | "search" | "user" | "phone" | "calendar" | "link" | "tag" | "building" | "globe" | "key" | "map-pin";

package/dist/field-icon.js

@@ -0,0 +1 @@
+export {};