@decaf-ts/decoration 0.0.2

package/lib/decoration/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Decoration.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVjb3JhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQTZCO0FBQzdCLDhDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0RlY29yYXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4iXX0=

package/lib/decoration/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Decoration";
+export * from "./types";

package/lib/decoration/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/decoration/types.d.ts

@@ -0,0 +1,95 @@
+import { DecoratorData } from "./Decoration";
+/**
+ * @description Interface for the final stage of the decoration builder pattern
+ * @summary Represents the build stage of the decoration builder, providing the ability to apply
+ * the configured decorator to a target. This is the final stage in the builder chain.
+ *
+ * @interface DecorationBuilderBuild
+ */
+export interface DecorationBuilderBuild {
+    /**
+     * @description Creates and returns the decorator function
+     * @summary Finalizes the builder process and returns a decorator function that can be applied to a class,
+     * property, or method.
+     *
+     * @returns {function} A decorator function that can be applied to a target
+     */
+    apply(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+}
+/**
+ * @description Interface for the extension stage of the decoration builder pattern
+ * @summary Represents the extension stage of the decoration builder, providing the ability to add
+ * additional decorators to the existing configuration.
+ *
+ * @interface DecorationBuilderEnd
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderEnd {
+    /**
+     * @description Adds additional decorators to the existing configuration
+     * @summary Extends the current decorator configuration with additional decorators.
+     * This is useful for adding behavior to existing decorators.
+     *
+     * @param {...(ClassDecorator|PropertyDecorator|MethodDecorator)} decorators - Additional decorators to add
+     * @returns {DecorationBuilderBuild} The build stage of the builder pattern
+     */
+    extend(...decorators: DecoratorData[]): DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the middle stage of the decoration builder pattern
+ * @summary Represents the middle stage of the decoration builder, extending the end stage
+ * and providing the ability to define the primary decorators for the configuration.
+ *
+ * @interface DecorationBuilderMid
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderMid extends DecorationBuilderEnd {
+    /**
+     * @description Defines the primary decorators for the configuration
+     * @summary Sets the main decorators for the current context. This is typically
+     * called after specifying the key with the 'for' method.
+     */
+    define(...decorators: DecoratorData[]): DecorationBuilderEnd & DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the starting stage of the decoration builder pattern
+ * @summary Represents the initial stage of the decoration builder, providing the entry point
+ * for the builder pattern by specifying the key for the decorator.
+ *
+ * @interface DecorationBuilderStart
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderStart {
+    /**
+     * @description Specifies the key for the decorator
+     * @summary Sets the identifier for the decorator, which is used to register and retrieve
+     * the decorator in the decoration registry.
+     *
+     * @param {string} id - The identifier for the decorator
+     * @return {DecorationBuilderMid} The middle stage of the builder pattern
+     */
+    for(id: string): DecorationBuilderMid;
+}
+/**
+ * @description Comprehensive interface for the complete decoration builder pattern
+ * @summary A unified interface that combines all stages of the decoration builder pattern,
+ * providing a complete API for creating, configuring, and applying decorators.
+ * This interface is implemented by the Decoration class.
+ *
+ * @interface IDecorationBuilder
+ * @memberOf module:decoration
+ */
+export interface IDecorationBuilder extends DecorationBuilderStart, DecorationBuilderMid, DecorationBuilderEnd, DecorationBuilderBuild {
+}
+/**
+ * @description Type definition for a function that resolves the flavour for a target
+ * @summary Defines a function type that determines the appropriate flavour for a given target object.
+ * This is used by the Decoration class to resolve which flavour of decorator to apply based on the target.
+ *
+ * @typedef {function(object): string} FlavourResolver
+ *
+ * @param {object} target - The target object to resolve the flavour for
+ * @return {string} The resolved flavour identifier
+ * @memberOf module:decoration
+ */
+export type FlavourResolver = (target: object) => string;

package/lib/decorators.cjs

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadata = metadata;
+exports.prop = prop;
+exports.apply = apply;
+exports.propMetadata = propMetadata;
+exports.description = description;
+const Metadata_1 = require("./metadata/Metadata.cjs");
+const constants_1 = require("./constants.cjs");
+/**
+ * @description Assigns arbitrary metadata to a target using a string key
+ * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.
+ * @param {string} key The metadata key to associate with the target
+ * @param {*} value The metadata value to store under the given key
+ * @return A decorator that writes the metadata when applied
+ * @function metadata
+ * @category Decorators
+ */
+function metadata(key, value) {
+    return function metadata(model, prop, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    descriptor) {
+        Metadata_1.Metadata.set(prop ? model.constructor : model, key, value);
+    };
+}
+/**
+ * @description Captures and stores a property's design type
+ * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.
+ * @return A decorator that records the property's type metadata when applied
+ * @function prop
+ * @category Property Decorators
+ */
+function prop() {
+    return function prop(model, prop) {
+        const designType = Reflect.getOwnMetadata(constants_1.DecorationKeys.DESIGN_TYPE, model, prop);
+        return metadata(`${constants_1.DecorationKeys.PROPERTIES}.${prop}`, designType)(model, prop);
+    };
+}
+/**
+ * @description Decorator factory that applies multiple decorators to a single target
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
+ * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
+ * @return {Function} A decorator function that applies all provided decorators to the target
+ * @function apply
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant A as apply(...decorators)
+ *   participant D as Decorator
+ *   U->>A: get decorator(...decorators)
+ *   A->>U: returns (target, key?, desc?) => void
+ *   U->>A: invoke on target
+ *   loop for each decorator
+ *     A->>D: invoke appropriate decorator type
+ *   end
+ * @category Decorators
+ */
+function apply(...decorators) {
+    return (target, propertyKey, descriptor) => {
+        for (const decorator of decorators) {
+            if (target instanceof Function && !descriptor) {
+                decorator(target);
+                continue;
+            }
+            decorator(target, propertyKey, descriptor);
+        }
+    };
+}
+/**
+ * @description Creates a property metadata decorator
+ * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.
+ * @param {string} key The metadata key to set for the property
+ * @param {*} value The metadata value to associate with the key
+ * @return A decorator that sets the metadata and captures the property's type
+ * @function propMetadata
+ * @category Property Decorators
+ */
+function propMetadata(key, value) {
+    return apply(metadata(key, value), prop());
+}
+/**
+ * @description Attaches a human-readable description to a class or member
+ * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.
+ * @param {string} desc The descriptive text to associate with the class or property
+ * @return A decorator that records the description when applied
+ * @function description
+ * @category Decorators
+ */
+function description(desc) {
+    return function description(original, prop, descriptor) {
+        return metadata([
+            constants_1.DecorationKeys.DESCRIPTION,
+            prop ? prop.toString() : constants_1.DecorationKeys.CLASS,
+        ].join(constants_1.ObjectKeySplitter), desc)(original, prop, descriptor);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/decorators.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @description Assigns arbitrary metadata to a target using a string key
+ * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.
+ * @param {string} key The metadata key to associate with the target
+ * @param {*} value The metadata value to store under the given key
+ * @return A decorator that writes the metadata when applied
+ * @function metadata
+ * @category Decorators
+ */
+export declare function metadata(key: string, value: any): (model: any, prop?: any, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Captures and stores a property's design type
+ * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.
+ * @return A decorator that records the property's type metadata when applied
+ * @function prop
+ * @category Property Decorators
+ */
+export declare function prop(): (model: object, prop: any) => void;
+/**
+ * @description Decorator factory that applies multiple decorators to a single target
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
+ * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
+ * @return {Function} A decorator function that applies all provided decorators to the target
+ * @function apply
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant A as apply(...decorators)
+ *   participant D as Decorator
+ *   U->>A: get decorator(...decorators)
+ *   A->>U: returns (target, key?, desc?) => void
+ *   U->>A: invoke on target
+ *   loop for each decorator
+ *     A->>D: invoke appropriate decorator type
+ *   end
+ * @category Decorators
+ */
+export declare function apply(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Creates a property metadata decorator
+ * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.
+ * @param {string} key The metadata key to set for the property
+ * @param {*} value The metadata value to associate with the key
+ * @return A decorator that sets the metadata and captures the property's type
+ * @function propMetadata
+ * @category Property Decorators
+ */
+export declare function propMetadata(key: string, value: any): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Attaches a human-readable description to a class or member
+ * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.
+ * @param {string} desc The descriptive text to associate with the class or property
+ * @return A decorator that records the description when applied
+ * @function description
+ * @category Decorators
+ */
+export declare function description(desc: string): (original: any, prop: any, descriptor?: any) => void;

package/lib/esm/constants.d.ts

@@ -0,0 +1,58 @@
+import { BasicMetadata } from "./metadata/types";
+/**
+ * @description Default flavour identifier for the decorator system
+ * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.
+ * This constant is used throughout the library as the fallback flavour for decorators.
+ * @const DefaultFlavour
+ * @memberOf module:decoration
+ */
+export declare const DefaultFlavour = "decaf";
+/**
+ * @description Character used to split nested metadata keys
+ * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.
+ * @const ObjectKeySplitter
+ * @memberOf module:decoration
+ */
+export declare const ObjectKeySplitter = ".";
+/**
+ * @description Enum containing metadata keys used for reflection in the model system
+ * @summary Defines the various Model keys used for reflection and metadata storage.
+ * These keys are used throughout the library to store and retrieve metadata about models,
+ * their properties, and their behavior.
+ * @readonly
+ * @enum {string}
+ * @readonly
+ * @memberOf module:decoration
+ */
+export declare enum DecorationKeys {
+    /** Storage key used on the constructor to mirror runtime metadata */
+    REFLECT = "__decaf",
+    /** Map of model property keys to their reflected design types */
+    PROPERTIES = "properties",
+    /** Key under which the model's constructor is stored */
+    CLASS = "class",
+    /** Container of human-friendly descriptions per class and property */
+    DESCRIPTION = "description",
+    /** Reflect metadata key for design time type of a property */
+    DESIGN_TYPE = "design:type",
+    /** Reflect metadata key for constructor parameter types */
+    DESIGN_PARAMS = "design:paramtypes",
+    /** Reflect metadata key for method return type */
+    DESIGN_RETURN = "design:returntype"
+}
+/**
+ * @description Typedef for the default metadata object shape
+ * @summary Describes the minimal structure persisted for a model before any metadata is recorded.
+ * @template M
+ * @typedef {object} DefaultMetadataType<M>
+ * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types
+ * @memberOf module:decoration
+ */
+/**
+ * @description Default metadata instance
+ * @summary Concrete default metadata object used when initializing metadata for a model
+ * @type {DefaultMetadataType<any>}
+ * @const DefaultMetadata
+ * @memberOf module:decoration
+ */
+export declare const DefaultMetadata: BasicMetadata<any>;

package/lib/esm/constants.js

@@ -0,0 +1,61 @@
+/**
+ * @description Default flavour identifier for the decorator system
+ * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.
+ * This constant is used throughout the library as the fallback flavour for decorators.
+ * @const DefaultFlavour
+ * @memberOf module:decoration
+ */
+export const DefaultFlavour = "decaf";
+/**
+ * @description Character used to split nested metadata keys
+ * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.
+ * @const ObjectKeySplitter
+ * @memberOf module:decoration
+ */
+export const ObjectKeySplitter = ".";
+/**
+ * @description Enum containing metadata keys used for reflection in the model system
+ * @summary Defines the various Model keys used for reflection and metadata storage.
+ * These keys are used throughout the library to store and retrieve metadata about models,
+ * their properties, and their behavior.
+ * @readonly
+ * @enum {string}
+ * @readonly
+ * @memberOf module:decoration
+ */
+export var DecorationKeys;
+(function (DecorationKeys) {
+    /** Storage key used on the constructor to mirror runtime metadata */
+    DecorationKeys["REFLECT"] = "__decaf";
+    /** Map of model property keys to their reflected design types */
+    DecorationKeys["PROPERTIES"] = "properties";
+    /** Key under which the model's constructor is stored */
+    DecorationKeys["CLASS"] = "class";
+    /** Container of human-friendly descriptions per class and property */
+    DecorationKeys["DESCRIPTION"] = "description";
+    /** Reflect metadata key for design time type of a property */
+    DecorationKeys["DESIGN_TYPE"] = "design:type";
+    /** Reflect metadata key for constructor parameter types */
+    DecorationKeys["DESIGN_PARAMS"] = "design:paramtypes";
+    /** Reflect metadata key for method return type */
+    DecorationKeys["DESIGN_RETURN"] = "design:returntype";
+})(DecorationKeys || (DecorationKeys = {}));
+/**
+ * @description Typedef for the default metadata object shape
+ * @summary Describes the minimal structure persisted for a model before any metadata is recorded.
+ * @template M
+ * @typedef {object} DefaultMetadataType<M>
+ * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types
+ * @memberOf module:decoration
+ */
+/**
+ * @description Default metadata instance
+ * @summary Concrete default metadata object used when initializing metadata for a model
+ * @type {DefaultMetadataType<any>}
+ * @const DefaultMetadata
+ * @memberOf module:decoration
+ */
+export const DefaultMetadata = {
+    [DecorationKeys.PROPERTIES]: [],
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/decoration/Decoration.d.ts

@@ -0,0 +1,196 @@
+import { DecorationBuilderBuild, DecorationBuilderEnd, DecorationBuilderMid, DecorationBuilderStart, FlavourResolver, IDecorationBuilder } from "./types";
+/**
+ * @description Union type covering supported decorator kinds
+ * @summary Represents any of the standard TypeScript decorator signatures (class, property, or method), enabling flexible registration and application within the Decoration system.
+ * @template T
+ * @typeDef DecoratorTypes
+ * @memberOf module:decoration
+ */
+export type DecoratorTypes = ClassDecorator | PropertyDecorator | MethodDecorator;
+/**
+ * @description Type definition for a decorator factory function
+ * @summary Represents a function that accepts arbitrary arguments and returns a concrete decorator function to be applied to a target.
+ * @template A
+ * @typeDef DecoratorFactory
+ * @memberOf module:decoration
+ */
+export type DecoratorFactory = (...args: any[]) => DecoratorTypes;
+/**
+ * @description Argument bundle for a decorator factory
+ * @summary Object form used to defer decorator creation, carrying both the factory function and its argument list to be invoked later during application.
+ * @typeDef DecoratorFactoryArgs
+ * @property {DecoratorFactory} decorator The factory function that produces a decorator when invoked
+ * @property {any[]} [args] Optional list of arguments to pass to the decorator factory
+ * @memberOf module:decoration
+ */
+export type DecoratorFactoryArgs = {
+    decorator: DecoratorFactory;
+    args?: any[];
+};
+/**
+ * @description Union that represents either a ready-to-apply decorator or a factory with arguments
+ * @summary Allows registering decorators in two forms: as direct decorator functions or as deferred factories paired with their argument lists for later instantiation.
+ * @typeDef DecoratorData
+ * @memberOf module:decoration
+ */
+export type DecoratorData = DecoratorTypes | DecoratorFactoryArgs;
+/**
+ * @description A decorator management class that handles flavoured decorators
+ * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.
+ * It supports registering, extending, and applying decorators with context-aware flavour resolution.
+ * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,
+ * allowing for framework-specific decorator implementations while maintaining a consistent API.
+ * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)
+ * @param {string} [flavour] Optional flavour parameter for the decorator context
+ * @class
+ * @example
+ * ```typescript
+ * // Create a new decoration for 'component' with default flavour
+ * const componentDecorator = new Decoration()
+ *   .for('component')
+ *   .define(customComponentDecorator);
+ *
+ * // Create a flavoured decoration
+ * const vueComponent = new Decoration('vue')
+ *   .for('component')
+ *   .define(vueComponentDecorator);
+ *
+ * // Apply the decoration
+ * @componentDecorator
+ * class MyComponent {}
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant D as Decoration
+ *   participant R as FlavourResolver
+ *   participant F as DecoratorFactory
+ *
+ *   C->>D: new Decoration(flavour)
+ *   C->>D: for(key)
+ *   C->>D: define(decorators)
+ *   D->>D: register(key, flavour, decorators)
+ *   D->>F: decoratorFactory(key, flavour)
+ *   F->>R: resolve(target)
+ *   R-->>F: resolved flavour
+ *   F->>F: apply decorators
+ *   F-->>C: decorated target
+ */
+export declare class Decoration implements IDecorationBuilder {
+    private flavour;
+    /**
+     * @description Static map of registered decorators
+     * @summary Stores all registered decorators organized by key and flavour
+     */
+    private static decorators;
+    /**
+     * @description Function to resolve flavour from a target
+     * @summary Resolver function that determines the appropriate flavour for a given target
+     */
+    private static flavourResolver;
+    /**
+     * @description Set of decorators for the current context
+     */
+    private decorators?;
+    /**
+     * @description Set of additional decorators
+     */
+    private extras?;
+    /**
+     * @description Current decorator key
+     */
+    private key?;
+    constructor(flavour?: string);
+    /**
+     * @description Sets the key for the decoration builder
+     * @summary Initializes a new decoration chain with the specified key
+     * @param {string} key The identifier for the decorator
+     * @return {DecorationBuilderMid} Builder instance for method chaining
+     */
+    for(key: string): DecorationBuilderMid;
+    /**
+     * @description Adds decorators to the current context
+     * @summary Internal method to add decorators with addon support
+     * @param {boolean} [addon=false] Whether the decorators are addons
+     * @param decorators Array of decorators
+     * @return {this} Current instance for chaining
+     */
+    private decorate;
+    /**
+     * @description Defines the base decorators
+     * @summary Sets the primary decorators for the current context
+     * @param decorators Decorators to define
+     * @return Builder instance for finishing the chain
+     */
+    define(...decorators: DecoratorData[]): DecorationBuilderEnd & DecorationBuilderBuild;
+    /**
+     * @description Extends existing decorators
+     * @summary Adds additional decorators to the current context
+     * @param decorators Additional decorators
+     * @return {DecorationBuilderBuild} Builder instance for building the decorator
+     */
+    extend(...decorators: DecoratorData[]): DecorationBuilderBuild;
+    /**
+     * @description Factory that creates a context-aware decorator for a key/flavour
+     * @summary Produces a decorator function bound to the provided key and flavour. The resulting decorator resolves the actual
+     * decorators to apply at invocation time based on the target's resolved flavour and the registered base and extra decorators.
+     * @param {string} key The decoration key used to look up registered decorators
+     * @param {string} [f=DefaultFlavour] Optional explicit flavour to bind the factory to
+     * @return {function(object, any, TypedPropertyDescriptor<any>): any} A decorator function that applies the resolved decorators
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User Code
+     *   participant B as Decoration (builder)
+     *   participant F as decoratorFactory(key, f)
+     *   participant R as flavourResolver
+     *   participant A as Applied Decorators
+     *   U->>B: define()/extend() and apply()
+     *   B->>F: create context decorator
+     *   F->>R: resolve(target)
+     *   R-->>F: flavour
+     *   F->>A: collect base + extras
+     *   loop each decorator
+     *     A->>U: invoke decorator(target, key?, desc?)
+     *   end
+     */
+    protected decoratorFactory(key: string, f?: string): (target: object, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => {
+        target: object;
+        propertyKey: any;
+        descriptor: TypedPropertyDescriptor<any> | undefined;
+    };
+    /**
+     * @description Creates the final decorator function
+     * @summary Builds and returns the decorator factory function
+     * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function
+     */
+    apply(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+    /**
+     * @description Registers decorators for a specific key and flavour
+     * @summary Internal method to store decorators in the static registry
+     * @param {string} key Decorator key
+     * @param {string} flavour Decorator flavour
+     * @param [decorators] Primary decorators
+     * @param [extras] Additional decorators
+     */
+    private static register;
+    /**
+     * @description Sets the global flavour resolver
+     * @summary Configures the function used to determine decorator flavours
+     * @param {FlavourResolver} resolver Function to resolve flavours
+     */
+    static setFlavourResolver(resolver: FlavourResolver): void;
+    /**
+     * @description Convenience static entry to start a decoration builder
+     * @summary Creates a new Decoration instance and initiates the builder chain with the provided key.
+     * @param {string} key The decoration key to configure
+     * @return {DecorationBuilderMid} A builder instance for chaining definitions
+     */
+    static for(key: string): DecorationBuilderMid;
+    /**
+     * @description Starts a builder for a specific flavour
+     * @summary Convenience method to begin a Decoration builder chain bound to the given flavour identifier, allowing registration of flavour-specific decorators.
+     * @param {string} flavour The flavour name to bind to the builder
+     * @return {DecorationBuilderStart} A builder start interface to continue configuration
+     */
+    static flavouredAs(flavour: string): DecorationBuilderStart;
+}