@hazeljs/ml 0.2.0-alpha.1

package/LICENSE

@@ -0,0 +1,192 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2024 HazelJS Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+   Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+   stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+   that You distribute, all copyright, patent, trademark, and
+   attribution notices from the Source form of the Work,
+   excluding those notices that do not pertain to any part of
+   the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+   distribution, then any Derivative Works that You distribute must
+   include a readable copy of the attribution notices contained
+   within such NOTICE file, excluding those notices that do not
+   pertain to any part of the Derivative Works, in at least one
+   of the following places: within a NOTICE text file distributed
+   as part of the Derivative Works; within the Source form or
+   documentation, if provided along with the Derivative Works; or,
+   within a display generated by the Derivative Works, if and
+   wherever such third-party notices normally appear. The contents
+   of the NOTICE file are for informational purposes only and
+   do not modify the License. You may add Your own attribution
+   notices within Derivative Works that You distribute, alongside
+   or as an addendum to the NOTICE text from the Work, provided
+   that such additional attribution notices cannot be construed
+   as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,300 @@
+# @hazeljs/ml
+
+Machine Learning & Model Management for HazelJS - training, prediction, model registry, and metrics.
+
+[![npm version](https://img.shields.io/npm/v/@hazeljs/ml.svg)](https://www.npmjs.com/package/@hazeljs/ml)
+[![npm downloads](https://img.shields.io/npm/dm/@hazeljs/ml)](https://www.npmjs.com/package/@hazeljs/ml)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Features
+
+- **Model registry** – Register and discover models by name and version
+- **Decorators** – `@Model`, `@Train`, `@Predict` for declarative ML APIs
+- **Training pipeline** – PipelineService for data preprocessing (normalize, filter)
+- **Inference** – PredictorService for single and batch predictions
+- **Metrics** – MetricsService for evaluation, A/B testing, and monitoring
+- **Framework-agnostic** – Works with TensorFlow.js, ONNX, Transformers.js, or custom backends
+
+## Installation
+
+```bash
+npm install @hazeljs/ml @hazeljs/core
+```
+
+### Peer dependencies (optional, per use case)
+
+```bash
+# TensorFlow.js
+npm install @tensorflow/tfjs-node
+
+# ONNX Runtime
+npm install onnxruntime-node
+
+# Hugging Face Transformers (embeddings, sentiment)
+npm install @huggingface/transformers
+```
+
+## Quick Start
+
+### 1. Import MLModule
+
+```typescript
+import { HazelApp } from '@hazeljs/core';
+import { MLModule } from '@hazeljs/ml';
+
+const app = new HazelApp({
+  imports: [
+    MLModule.forRoot({
+      models: [SentimentClassifier, SpamClassifier],
+    }),
+  ],
+});
+
+app.listen(3000);
+```
+
+### 2. Define a model with decorators
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import { Model, Train, Predict, ModelRegistry } from '@hazeljs/ml';
+
+@Model({ name: 'sentiment-classifier', version: '1.0.0', framework: 'custom' })
+@Injectable()
+export class SentimentClassifier {
+  private labels = ['positive', 'negative', 'neutral'];
+  private weights: Record<string, number[]> = {};
+
+  constructor(private registry: ModelRegistry) {}
+
+  @Train()
+  async train(data: { text: string; label: string }[]): Promise<void> {
+    // Your training logic – e.g. bag-of-words, embeddings, etc.
+    const vocab = this.buildVocabulary(data);
+    this.weights = this.computeWeights(data, vocab);
+  }
+
+  @Predict()
+  async predict(input: { text: string }): Promise<{ sentiment: string; confidence: number }> {
+    const scores = this.score(input.text);
+    const idx = scores.indexOf(Math.max(...scores));
+    return {
+      sentiment: this.labels[idx],
+      confidence: scores[idx],
+    };
+  }
+}
+```
+
+### 3. Predict from a controller or service
+
+```typescript
+import { Controller, Post, Body, Inject } from '@hazeljs/core';
+import { PredictorService } from '@hazeljs/ml';
+
+@Controller('ml')
+export class MLController {
+  constructor(private predictor: PredictorService) {}
+
+  @Post('predict')
+  async predict(@Body() body: { text: string; model?: string }) {
+    const result = await this.predictor.predict(
+      body.model ?? 'sentiment-classifier',
+      body
+    );
+    return { result };
+  }
+}
+```
+
+## ML Decorators
+
+The package uses three decorators to declare ML models and their behaviour. The registry and services discover them via reflection—no manual wiring needed.
+
+### `@Model` (class)
+
+Marks a class as an ML model and attaches **registry metadata**. Required so the model can be registered and looked up by name/version.
+
+| Property      | Type     | Required | Description |
+|---------------|----------|----------|-------------|
+| `name`        | string   | Yes      | Unique model id (e.g. `'sentiment-classifier'`). |
+| `version`     | string   | Yes      | Semver (e.g. `'1.0.0'`). |
+| `framework`   | string   | Yes      | `'tensorflow'` \| `'onnx'` \| `'custom'`. |
+| `description` | string   | No       | Human-readable description. |
+| `tags`        | string[] | No       | Tags for filtering (default: `[]`). |
+
+**Example:** One model per class; use `@Injectable()` so the app can construct it.
+
+```typescript
+@Model({
+  name: 'spam-classifier',
+  version: '1.0.0',
+  framework: 'custom',
+  description: 'Binary spam/ham classifier',
+  tags: ['nlp', 'moderation'],
+})
+@Injectable()
+export class SpamClassifier {
+  // ...
+}
+```
+
+---
+
+### `@Train` (method)
+
+Marks the **single method** that trains this model. `TrainerService.train(modelName, data)` will call it. Optional config is for documentation or pipeline wiring.
+
+| Option      | Type   | Default   | Description |
+|-------------|--------|-----------|-------------|
+| `pipeline`  | string | `'default'` | Name of a registered `PipelineService` pipeline to run before training. |
+| `batchSize` | number | `32`     | Hint for batching (your logic can ignore it). |
+| `epochs`    | number | `10`     | Hint for epochs (your logic can ignore it). |
+
+**Example:** Exactly one `@Train()` method per model; it receives training data and can return metrics.
+
+```typescript
+@Train({ pipeline: 'sentiment-preprocessing', epochs: 5 })
+async train(data: { samples: Array<{ text: string; label: string }> }): Promise<TrainingResult> {
+  // Your training logic
+  return { accuracy: 0.95, loss: 0.05 };
+}
+```
+
+---
+
+### `@Predict` (method)
+
+Marks the **single method** that runs inference. `PredictorService.predict(modelName, input)` will call it.
+
+| Option    | Type    | Default    | Description |
+|-----------|---------|------------|-------------|
+| `batch`   | boolean | `false`    | Hint that the method supports batch input (semantic only). |
+| `endpoint`| string  | `'/predict'` | Hint for route naming (semantic only). |
+
+**Example:** Exactly one `@Predict()` method per model; it receives one input and returns a prediction object.
+
+```typescript
+@Predict({ batch: true, endpoint: '/predict' })
+async predict(input: { text: string }): Promise<{ label: string; confidence: number }> {
+  // Your inference logic
+  return { label: 'ham', confidence: 0.92 };
+}
+```
+
+---
+
+### Rules
+
+- **One model class** = one `@Model`, one `@Train` method, one `@Predict` method.
+- **Order:** Put `@Model` on the class, then `@Train` and `@Predict` on the methods. Use `@Injectable()` from `@hazeljs/core` so the app can instantiate the model.
+- **Discovery:** When you pass model classes to `MLModule.forRoot({ models: [...] })`, the bootstrap finds the `@Train` and `@Predict` methods and registers them with the registry.
+
+## Model registration
+
+Models are registered when passed to `MLModule.forRoot({ models: [...] })`. The bootstrap discovers `@Train` and `@Predict` methods via reflection.
+
+### Manual registration
+
+```typescript
+import { registerMLModel, ModelRegistry, TrainerService, PredictorService } from '@hazeljs/ml';
+
+// When injecting ModelRegistry in a custom service:
+registerMLModel(
+  sentimentInstance,
+  modelRegistry,
+  trainerService,
+  predictorService
+);
+```
+
+## Training pipeline
+
+Preprocess data before training with `PipelineService`:
+
+```typescript
+import { PipelineService } from '@hazeljs/ml';
+
+const pipeline = new PipelineService();
+const steps = [
+  { name: 'normalize', transform: (d: unknown) => ({ ...(d as object), text: (d as { text: string }).text?.toLowerCase() }) },
+  { name: 'filter', transform: (d: unknown) => (d as { text: string }).text?.length > 0 ? d : null },
+];
+// Inline steps (no registration required)
+const processed = await pipeline.run(data, steps);
+await model.train(processed);
+
+// Or register a named pipeline
+pipeline.registerPipeline('default', steps);
+const processed2 = await pipeline.run('default', data);
+```
+
+## Batch predictions
+
+```typescript
+import { BatchService } from '@hazeljs/ml';
+
+const batchService = new BatchService(predictorService);
+const results = await batchService.predictBatch('sentiment-classifier', items, {
+  batchSize: 32,
+  concurrency: 4,
+});
+// Results are returned in the same order as inputs
+```
+
+## Metrics and evaluation
+
+```typescript
+import { MetricsService } from '@hazeljs/ml';
+
+// Evaluate model on test data (inject MetricsService via MLModule - it receives PredictorService)
+@Injectable()
+class EvaluationService {
+  constructor(private metricsService: MetricsService) {}
+
+  async runEvaluation() {
+    const testData = [
+      { text: 'great product', label: 'positive' },
+      { text: 'terrible', label: 'negative' },
+    ];
+    const evaluation = await this.metricsService.evaluate('sentiment-classifier', testData, {
+      metrics: ['accuracy', 'f1', 'precision', 'recall'],
+      labelKey: 'label',           // key in test sample for ground truth
+      predictionKey: 'sentiment',   // key in prediction result (auto-detect: label, sentiment, class)
+    });
+    // evaluation.metrics: { accuracy, precision, recall, f1Score }
+    // Result is automatically recorded via recordEvaluation()
+  }
+}
+
+// Manual recording
+metricsService.recordEvaluation({
+  modelName: 'my-model',
+  version: '1.0.0',
+  metrics: { accuracy: 0.95, loss: 0.05 },
+  evaluatedAt: new Date(),
+});
+```
+
+## API summary
+
+| Service | Purpose |
+|---------|---------|
+| `ModelRegistry` | Register and lookup models by name/version |
+| `TrainerService` | Discover and invoke `@Train` methods |
+| `PredictorService` | Discover and invoke `@Predict` methods |
+| `PipelineService` | Data preprocessing pipeline |
+| `BatchService` | Batch prediction with configurable batch size |
+| `MetricsService` | Model evaluation and metrics tracking |
+
+## Examples
+
+- **[hazeljs-ml-starter](../../../hazeljs-ml-starter)** – Full app: sentiment, spam, intent classifiers, REST API, training pipeline, and metrics.
+- **[example/src/ml](../../example/src/ml)** – Minimal runnable example of the three decorators (`npm run ml:decorators` from the example repo).
+
+## Links
+
+- [Documentation](https://hazeljs.com/docs/packages/ml)
+- [GitHub](https://github.com/hazel-js/hazeljs)
+- [Issues](https://github.com/hazel-js/hazeljs/issues)
+- [Homepage](https://hazeljs.com)

package/dist/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export { Model, getModelMetadata, hasModelMetadata } from './model.decorator';
+export { Train, getTrainMetadata, hasTrainMetadata, type TrainOptions } from './train.decorator';
+export { Predict, getPredictMetadata, hasPredictMetadata, type PredictOptions, } from './predict.decorator';
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjG,OAAO,EACL,OAAO,EACP,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC"}

package/dist/decorators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPredictMetadata = exports.getPredictMetadata = exports.Predict = exports.hasTrainMetadata = exports.getTrainMetadata = exports.Train = exports.hasModelMetadata = exports.getModelMetadata = exports.Model = void 0;
+var model_decorator_1 = require("./model.decorator");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_decorator_1.Model; } });
+Object.defineProperty(exports, "getModelMetadata", { enumerable: true, get: function () { return model_decorator_1.getModelMetadata; } });
+Object.defineProperty(exports, "hasModelMetadata", { enumerable: true, get: function () { return model_decorator_1.hasModelMetadata; } });
+var train_decorator_1 = require("./train.decorator");
+Object.defineProperty(exports, "Train", { enumerable: true, get: function () { return train_decorator_1.Train; } });
+Object.defineProperty(exports, "getTrainMetadata", { enumerable: true, get: function () { return train_decorator_1.getTrainMetadata; } });
+Object.defineProperty(exports, "hasTrainMetadata", { enumerable: true, get: function () { return train_decorator_1.hasTrainMetadata; } });
+var predict_decorator_1 = require("./predict.decorator");
+Object.defineProperty(exports, "Predict", { enumerable: true, get: function () { return predict_decorator_1.Predict; } });
+Object.defineProperty(exports, "getPredictMetadata", { enumerable: true, get: function () { return predict_decorator_1.getPredictMetadata; } });
+Object.defineProperty(exports, "hasPredictMetadata", { enumerable: true, get: function () { return predict_decorator_1.hasPredictMetadata; } });

package/dist/decorators/model.decorator.d.ts

@@ -0,0 +1,26 @@
+import 'reflect-metadata';
+import { ModelMetadata } from '../ml.types';
+/**
+ * @Model decorator - Register ML models with the registry
+ *
+ * @example
+ * ```typescript
+ * @Model({
+ *   name: 'sentiment-classifier',
+ *   version: '1.0.0',
+ *   framework: 'tensorflow',
+ * })
+ * @Injectable()
+ * export class SentimentModel {
+ *   @Train()
+ *   async train(data: TrainingData) { ... }
+ *
+ *   @Predict()
+ *   async predict(text: string) { ... }
+ * }
+ * ```
+ */
+export declare function Model(config: ModelMetadata): ClassDecorator;
+export declare function getModelMetadata(target: object): ModelMetadata | undefined;
+export declare function hasModelMetadata(target: object): boolean;
+//# sourceMappingURL=model.decorator.d.ts.map

package/dist/decorators/model.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/model.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAK5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE1E;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/decorators/model.decorator.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = Model;
+exports.getModelMetadata = getModelMetadata;
+exports.hasModelMetadata = hasModelMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const MODEL_METADATA_KEY = 'hazel:ml:model';
+/**
+ * @Model decorator - Register ML models with the registry
+ *
+ * @example
+ * ```typescript
+ * @Model({
+ *   name: 'sentiment-classifier',
+ *   version: '1.0.0',
+ *   framework: 'tensorflow',
+ * })
+ * @Injectable()
+ * export class SentimentModel {
+ *   @Train()
+ *   async train(data: TrainingData) { ... }
+ *
+ *   @Predict()
+ *   async predict(text: string) { ... }
+ * }
+ * ```
+ */
+function Model(config) {
+    return (target) => {
+        const metadata = {
+            description: '',
+            tags: [],
+            ...config,
+        };
+        Reflect.defineMetadata(MODEL_METADATA_KEY, metadata, target);
+        core_1.default.debug(`Model decorator applied: ${metadata.name}@${metadata.version}`);
+    };
+}
+function getModelMetadata(target) {
+    return Reflect.getMetadata(MODEL_METADATA_KEY, target);
+}
+function hasModelMetadata(target) {
+    return Reflect.hasMetadata(MODEL_METADATA_KEY, target);
+}

package/dist/decorators/model.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=model.decorator.test.d.ts.map

package/dist/decorators/model.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/model.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}