@tstdl/base 0.92.8 → 0.92.9

package/ai/ai.service.d.ts

@@ -5,19 +5,18 @@ import { LiteralUnion } from 'type-fest';
 import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
 import { OneOrMany, SchemaTestable } from '../schema/index.js';
 import { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
-export type FileInput = {
-    path: string;
-    mimeType: string;
-} | Blob;
+import { Content, FileInput, SchemaFunctionDeclarations } from './types.js';
 export type GenerativeAIModel = LiteralUnion<'gemini-2.0-flash-exp' | 'gemini-exp-1206' | 'gemini-2.0-flash-thinking-exp-1219', string>;
 export type GenerationOptions = {
     model?: GenerativeAIModel;
+    systemInstruction?: string;
     maxOutputTokens?: number;
     temperature?: number;
     topP?: number;
     topK?: number;
     presencePenalty?: number;
     frequencyPenalty?: number;
+    forceFunctionCall?: boolean;
 };
 export type GenerationResult<T> = {
     result: T;
@@ -40,6 +39,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     readonly [resolveArgumentType]: AiServiceArgument;
     getFile(fileInput: FileInput): Promise<FileMetadataResponse>;
     getFiles(files: readonly FileInput[]): Promise<FileMetadataResponse[]>;
+    test(): Promise<void>;
     classify<T extends EnumerationType>(fileInput: OneOrMany<FileInput>, types: T, options?: GenerationOptions): Promise<GenerationResult<{
         types: {
             type: EnumerationValue<T>;
@@ -47,7 +47,22 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
         }[] | null;
     }>>;
     extractData<T>(fileInput: OneOrMany<FileInput>, schema: SchemaTestable<T>, options?: GenerationOptions): Promise<GenerationResult<T>>;
+    analyzeDocument<T extends EnumerationType>(fileInput: FileInput, types: T, options?: GenerationOptions): Promise<GenerationResult<{
+        content: string[];
+        documentTypes: {
+            type: EnumerationValue<T>;
+            confidence: 'high' | 'medium' | 'low';
+        }[];
+        tags: string[];
+    }>>;
+    findActions(fileInput: OneOrMany<FileInput>, options?: GenerationOptions): Promise<GenerationResult<{
+        text: string;
+        functions: any;
+    }>>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, contents: Content[], options?: GenerationOptions): Promise<void>;
     private waitForFileActive;
     private waitForFilesActive;
+    private convertContents;
+    private convertContent;
     private getModel;
 }

package/ai/ai.service.js

@@ -61,20 +61,24 @@ import { openAsBlob } from 'node:fs';
 import { unlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { inspect } from 'node:util';
+import { FunctionCallingMode, GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
 import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
+import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
 import { DetailsError } from '../errors/details.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
 import { Logger } from '../logger/logger.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
-import { array, enumeration, nullable, object, Schema } from '../schema/index.js';
+import { array, enumeration, nullable, object, Schema, string } from '../schema/index.js';
 import { toArray } from '../utils/array/array.js';
 import { digest } from '../utils/cryptography.js';
 import { formatBytes } from '../utils/format.js';
+import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
 import { timeout } from '../utils/timing.js';
 import { tryIgnoreAsync } from '../utils/try-ignore.js';
-import { isBlob } from '../utils/type-guards.js';
+import { assertDefinedPass, isBlob } from '../utils/type-guards.js';
 import { millisecondsPerSecond } from '../utils/units.js';
 let AiService = class AiService {
     #options = injectArgument(this);
@@ -136,6 +140,59 @@ let AiService = class AiService {
     async getFiles(files) {
         return Promise.all(files.map(async (file) => this.getFile(file)));
     }
+    async test() {
+        const result = await this.getModel('gemini-2.0-flash-exp').generateContent({
+            generationConfig: {
+                maxOutputTokens: 4096
+            },
+            tools: [{
+                    functionDeclarations: [
+                        {
+                            name: 'outputNumber',
+                            description: 'outputs a number',
+                            parameters: {
+                                type: SchemaType.OBJECT,
+                                properties: {
+                                    number: { type: SchemaType.INTEGER }
+                                },
+                                required: ['number']
+                            }
+                        }
+                    ],
+                }],
+            toolConfig: {
+                functionCallingConfig: {
+                    mode: FunctionCallingMode.ANY
+                }
+            },
+            contents: [
+                { role: 'user', parts: [{ text: 'Output 5 increasing numbers starting at 10' }] },
+                {
+                    role: 'model',
+                    parts: [
+                        { functionCall: { name: 'outputNumber', args: { number: 10 } } },
+                        { functionCall: { name: 'outputNumber', args: { number: 11 } } },
+                        { functionCall: { name: 'outputNumber', args: { number: 12 } } },
+                        { functionCall: { name: 'outputNumber', args: { number: 13 } } },
+                        { functionCall: { name: 'outputNumber', args: { number: 14 } } }
+                    ]
+                },
+                /*{
+                  role: 'user',
+                  parts: [
+                    { functionResponse: { name: 'outputNumber', response: { result: 'outputted number 10' } } },
+                    { functionResponse: { name: 'outputNumber', response: { result: 'outputted number 11' } } },
+                    { functionResponse: { name: 'outputNumber', response: { result: 'outputted number 12' } } },
+                    { functionResponse: { name: 'outputNumber', response: { result: 'outputted number 13' } } },
+                    { functionResponse: { name: 'outputNumber', response: { result: 'outputted number 14' } } }
+                  ]
+                },*/
+                // { role: 'model', parts: [{ text: 'Okay, I\'ve outputted the numbers 10, 11, 12, 13, and 14.' }] },
+                { role: 'user', parts: [{ text: 'Give me 5 more numbers. ONLY call functions, dont output text' }] }
+            ]
+        });
+        console.log(inspect(result.response, { depth: null }));
+    }
     async classify(fileInput, types, options) {
         const files = await this.getFiles(toArray(fileInput));
         const resultSchema = object({
@@ -201,6 +258,162 @@ Carefully read and analyze the provided document. Identify relevant information
             result: Schema.parse(schema, JSON.parse(result.response.text()))
         };
     }
+    async analyzeDocument(fileInput, types, options) {
+        const file = await this.getFile(fileInput);
+        const schema = object({
+            content: array(string({ description: 'Single content without data details' }), { description: 'List of contents' }),
+            documentTypes: array(object({
+                type: enumeration(types, { description: 'Type of document' }),
+                confidence: enumeration(['high', 'medium', 'low'], { description: 'How sure/certain you are about the classficiation.' })
+            }), { description: 'One or more document types that matches' }),
+            tags: array(string({ description: 'Tag which describes the content' }), { description: 'List of tags' })
+        });
+        const responseSchema = convertToOpenApiSchema(schema);
+        this.#logger.verbose('Extracting data...');
+        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
+            generationConfig: {
+                maxOutputTokens: 2048,
+                temperature: 0.75,
+                ...options,
+                responseMimeType: 'application/json',
+                responseSchema
+            },
+            systemInstruction: `You are a highly skilled data extraction AI, specializing in accurately identifying and extracting information from unstructured text documents and converting it into a structured JSON format. Your primary goal is to meticulously follow the provided JSON schema and populate it with data extracted from the given document.
+
+**Instructions:**
+Carefully read and analyze the provided document.
+Identify key points and relevant information that describes the content. Focus on a general overview without providing specific details.
+Only output as many content items as it is necessary to describe relevant content. It should be around 5 to 10 items.
+Classify the document based on the provided list of types.
+Output up to 5 tags.
+Always output the content and tags in Deutsch.`,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        { fileData: { mimeType: file.mimeType, fileUri: file.uri } },
+                        { text: `Classify the document. Output as JSON using the following schema:\n${JSON.stringify(responseSchema, null, 2)}` }
+                    ]
+                }
+            ]
+        });
+        return {
+            usage: result.response.usageMetadata,
+            result: Schema.parse(schema, JSON.parse(result.response.text()))
+        };
+    }
+    async findActions(fileInput, options) {
+        const files = await this.getFiles(toArray(fileInput));
+        this.#logger.verbose('Extracting data...');
+        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
+            generationConfig: {
+                maxOutputTokens: 4096,
+                temperature: 0.75,
+                ...options
+            },
+            tools: [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'createNewRealEstate',
+                            description: 'creates a new real estate',
+                            parameters: {
+                                type: SchemaType.OBJECT,
+                                properties: {
+                                    address: { type: SchemaType.STRING },
+                                    realEstateNumber: { type: SchemaType.STRING }
+                                },
+                                required: ['address', 'realEstateNumber']
+                            }
+                        },
+                        {
+                            name: 'createNewUnit',
+                            description: 'creates a new unit in a real estate. Make sure to get the correct unit number, each unit has to get its own',
+                            parameters: {
+                                type: SchemaType.OBJECT,
+                                description: 'data of the unit from documents',
+                                properties: {
+                                    unitNumber: { type: SchemaType.STRING },
+                                    owner: { type: SchemaType.STRING },
+                                    dweller: { type: SchemaType.STRING }
+                                },
+                                required: ['unitNumber', 'owner', 'dweller']
+                            }
+                        },
+                        {
+                            name: 'createNewDevice',
+                            description: 'creates a new device in a real estate / unit, for example HKV or WWZ',
+                            parameters: {
+                                type: SchemaType.OBJECT,
+                                description: 'data of the device from documents like Ablesebeleg.',
+                                properties: {
+                                    unitNumber: { type: SchemaType.STRING },
+                                    deviceNumber: { type: SchemaType.STRING },
+                                    factor: { type: SchemaType.NUMBER },
+                                    deviceType: { type: SchemaType.STRING },
+                                    roomType: { type: SchemaType.STRING }
+                                },
+                                required: ['unitNumber', 'deviceNumber', 'factor', 'deviceType', 'roomType']
+                            }
+                        }
+                    ]
+                }
+            ],
+            toolConfig: { functionCallingConfig: { mode: FunctionCallingMode.ANY } },
+            systemInstruction: `You are a specialized AI assistant designed to extract structured data from various document types related to real estate and device management. Your goal is to understand the document's content and identify key information to populate specific function calls. You will be provided with document text and a set of predefined functions.
+
+**Your task is:**
+
+1. **Analyze the document:** Carefully read the provided document text.
+2. **Identify relevant information:** Extract the key data points related to real estate (e.g., address, size, type) and devices (e.g., type, model, serial number, location).
+3. **Determine the appropriate function:** Based on the extracted information, select the most suitable function from the list below to perform the intended action.
+4. **Generate function call:**  Output the selected function name along with its arguments, populated with the extracted data. Use JSON format for the output.`,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        ...files.map((file) => ({ fileData: { mimeType: file.mimeType, fileUri: file.uri } })),
+                        { text: 'Extract the data from the document and call suitable functions.' }
+                    ]
+                }
+            ]
+        });
+        return {
+            usage: result.response.usageMetadata,
+            result: {
+                functions: result.response.functionCalls(),
+                text: result.response.text()
+            }
+        };
+    }
+    async callFunctions(functions, contents, options) {
+        const googleContent = await this.convertContents(contents);
+        const googleFunctionDeclarations = objectEntries(functions).map(([name, declaration]) => ({
+            name: name,
+            description: declaration.description,
+            parameters: convertToOpenApiSchema(declaration.parameters)
+        }));
+        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
+            generationConfig: {
+                maxOutputTokens: 4096,
+                temperature: 0.75,
+                ...options
+            },
+            systemInstruction: options?.systemInstruction,
+            tools: [{ functionDeclarations: googleFunctionDeclarations }],
+            toolConfig: {
+                functionCallingConfig: {
+                    mode: (options?.forceFunctionCall == false) ? FunctionCallingMode.AUTO : FunctionCallingMode.ANY
+                }
+            },
+            contents: googleContent
+        });
+        for (const call of result.response.functionCalls() ?? []) {
+            const fn = assertDefinedPass(functions[call.name]);
+            const parameters = fn.parameters.parse(call.args);
+            const functionResult = await fn.handler(parameters);
+        }
+    }
     async waitForFileActive(fileMetadata) {
         let file = await this.fileManager.getFile(fileMetadata.name);
         while (file.state == FileState.PROCESSING) {
@@ -220,6 +433,31 @@ Carefully read and analyze the provided document. Identify relevant information
         }
         return responses;
     }
+    async convertContents(contents) {
+        return AsyncEnumerable.from(contents)
+            .map(async (content) => this.convertContent(content))
+            .toArray();
+    }
+    async convertContent(content) {
+        return {
+            role: content.role,
+            parts: await AsyncEnumerable.from(content.parts)
+                .map(async (part) => {
+                if (hasOwnProperty(part, 'text')) {
+                    return { text: part.text };
+                }
+                if (hasOwnProperty(part, 'file')) {
+                    const fileMetadata = await this.getFile(part.file);
+                    return { fileData: { fileUri: fileMetadata.uri, mimeType: fileMetadata.mimeType } };
+                }
+                if (hasOwnProperty(part, 'functionResult')) {
+                    return { functionResponse: { name: part.functionResult.name, response: { result: part.functionResult.value } } };
+                }
+                throw new NotSupportedError('Unsupported content part.');
+            })
+                .toArray()
+        };
+    }
     getModel(model) {
         return this.genAI.getGenerativeModel({ model });
     }

package/ai/functions.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionDeclaration } from '@google/generative-ai';
+import type { AbstractConstructor } from '../types.js';
+import type { SchemaFunctionDeclarations } from './types.js';
+export declare function convertFunctionDeclarations(declarations: SchemaFunctionDeclarations): void;
+export declare function getFunctionDeclarations(type: AbstractConstructor): FunctionDeclaration[];

package/ai/functions.js

@@ -0,0 +1,40 @@
+import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
+import { FunctionSchema, getObjectSchema, object } from '../schema/index.js';
+import { fromEntries, objectEntries } from '../utils/object/object.js';
+import { isNotNull, isNull, isString } from '../utils/type-guards.js';
+export function convertFunctionDeclarations(declarations) {
+    const entries = objectEntries(declarations)
+        .map(([name, declaration]) => ({
+        name,
+        description: declaration.description,
+        parameters: convertToOpenApiSchema(declaration.parameters)
+    }));
+}
+export function getFunctionDeclarations(type) {
+    const objectSchema = getObjectSchema(type);
+    return objectEntries(objectSchema.properties)
+        .map(([key, schema]) => {
+        if (!(schema instanceof FunctionSchema)) {
+            return null;
+        }
+        return {
+            name: `${type.name}.${key}`,
+            description: schema.description ?? undefined,
+            parameters: isNull(schema.parameterSchemas)
+                ? undefined
+                : getFunctionDeclarationParameters(schema)
+        };
+    })
+        .filter(isNotNull);
+}
+function getFunctionDeclarationParameters(functionSchema) {
+    const entries = functionSchema.parameterSchemas.map((schema, index) => {
+        const parameterName = functionSchema.parameterNames[index];
+        if (!isString(parameterName)) {
+            throw new Error(`Parameter ${index} requires a name.`);
+        }
+        return [parameterName, schema];
+    });
+    const parametersSchema = object(fromEntries(entries));
+    return convertToOpenApiSchema(parametersSchema);
+}

package/ai/types.d.ts

@@ -0,0 +1,27 @@
+import type { ObjectSchema } from '../schema/index.js';
+import type { Record, UndefinableJson } from '../types.js';
+export type FileInput = {
+    path: string;
+    mimeType: string;
+} | Blob;
+export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
+export type SchemaFunctionDeclaration<T extends Record = Record, R = unknown> = {
+    description: string;
+    parameters: ObjectSchema<T>;
+    handler: (parameters: T) => R | Promise<R>;
+};
+export type Content = {
+    role: 'user' | 'model';
+    parts: ContentPart[];
+};
+export type ContentPart = {
+    text: string;
+} | {
+    file: FileInput;
+} | {
+    functionResult: {
+        name: string;
+        value: NonNullable<UndefinableJson>;
+    };
+};
+export declare function declareFunction<T extends Record = Record, R = unknown>(description: string, parameters: ObjectSchema<T>, handler: (parameters: T) => R | Promise<R>): SchemaFunctionDeclaration<T, R>;

package/ai/types.js

@@ -0,0 +1,3 @@
+export function declareFunction(description, parameters, handler) {
+    return { description, parameters, handler };
+}

package/orm/schemas/json.d.ts

@@ -1,9 +1,9 @@
 import { type Decorator } from '../../reflection/index.js';
-import { ObjectSchema, type ObjectSchemaOptions, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+import { ObjectSchema, type ObjectSchemaOptions, type SchemaDecoratorOptions } from '../../schema/index.js';
 export type JsonSchemaOptions = Pick<ObjectSchemaOptions, 'factory'>;
 export declare class JsonSchema extends ObjectSchema {
     readonly name = "Json";
     constructor(options?: JsonSchemaOptions);
 }
 export declare function json(options?: JsonSchemaOptions): JsonSchema;
-export declare function Json(options?: JsonSchemaOptions & SchemaPropertyDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
+export declare function Json(options?: JsonSchemaOptions & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;

package/orm/schemas/numeric-date.d.ts

@@ -1,8 +1,8 @@
-import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SimpleSchemaOptions } from '../../schema/index.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SimpleSchemaOptions } from '../../schema/index.js';
 export type NumericDateSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
 export declare class NumericDateSchema extends NumberSchema {
     readonly name = "NumericDate";
     constructor(options?: NumericDateSchemaOptions);
 }
 export declare function numericDate(options?: NumericDateSchemaOptions): NumericDateSchema;
-export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/timestamp.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../schema/index.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../schema/index.js';
 export type TimestampSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
 export declare class TimestampSchema extends NumberSchema {
     readonly name = "Timestamp";
@@ -7,4 +7,4 @@ export declare class TimestampSchema extends NumberSchema {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<number>;
 }
 export declare function timestamp(options?: TimestampSchemaOptions): TimestampSchema;
-export declare function Timestamp(options?: TimestampSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Timestamp(options?: TimestampSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/uuid.d.ts

@@ -1,4 +1,4 @@
-import { StringSchema, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+import { StringSchema, type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../../schema/index.js';
 export type UuidSchemaOptions = {
     defaultRandom?: boolean;
 };
@@ -8,4 +8,4 @@ export declare class UuidSchema extends StringSchema {
     constructor(options?: UuidSchemaOptions);
 }
 export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
-export declare function Uuid(options?: UuidSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uuid(options?: UuidSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.8",
+  "version": "0.92.9",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -46,6 +46,7 @@
     "./disposable": "./disposable/index.js",
     "./distributed-loop": "./distributed-loop/index.js",
     "./dom": "./dom/index.js",
+    "./document-management": "./document-management/index.js",
     "./enumerable": "./enumerable/index.js",
     "./errors": "./errors/index.js",
     "./file": "./file/index.js",
@@ -119,11 +120,11 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.31"
+    "type-fest": "4.32"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.12",
+    "@stylistic/eslint-plugin": "2.13",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -148,7 +149,7 @@
     "@elastic/elasticsearch": "^8.17",
     "@google/generative-ai": "^0.21",
     "@koa/router": "^13.1",
-    "@tstdl/angular": "^0.91",
+    "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",

package/reflection/registry.js

@@ -40,13 +40,13 @@ export class ReflectionRegistry {
             return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
         }
         else if (data.type == 'method-parameter') {
-            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
+            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey).parameters.at(data.index);
         }
         else if (data.type == 'constructor-parameter') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
             if (isUndefined(metadata.parameters)) {
                 throw new Error('Constructor parameters are not available. (missing decoration?)');
             }
-            return metadata.parameters[data.index];
+            return metadata.parameters.at(data.index);
         }
         throw new Error(`Unknown DecoratorData type ${data.type}`);
     }

package/reflection/utils.d.ts

@@ -1,8 +1,6 @@
 import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../types.js';
 import type { CombinedDecoratorParameters, Decorator, DecoratorData, DecoratorHandler, DecoratorMetadata, DecoratorType, DecoratorUnion } from './types.js';
-export type CreateDecoratorTypeOptions = {
-    [P in DecoratorType]?: boolean;
-};
+export type CreateDecoratorTypeOptions = Partial<Record<DecoratorType, boolean>>;
 export type CreateDecoratorOptions = {
     data?: Record<string | symbol>;
     /** Merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */

package/schema/decorators/index.d.ts

@@ -1,4 +1,3 @@
 export * from './class.js';
-export * from './property.js';
-export * from './types.js';
-export * from './utils.js';
+export * from './schema.js';
+export type * from './types.js';

package/schema/decorators/index.js

@@ -1,4 +1,2 @@
 export * from './class.js';
-export * from './property.js';
-export * from './types.js';
-export * from './utils.js';
+export * from './schema.js';

package/schema/decorators/schema.d.ts

@@ -0,0 +1,21 @@
+import type { SetRequired } from 'type-fest';
+import { type Decorator } from '../../reflection/index.js';
+import type { TypedOmit } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { CombinedSchemaDecorator, SchemaReflectionData, SchemaTestableProvider } from './types.js';
+export type SchemaDecoratorOptions = SchemaReflectionData;
+export type SchemaDecoratorOptionsWithRequiredSchema = SetRequired<SchemaReflectionData, 'schema'>;
+export type SchemaDecoratorOptionsWithoutSchema = TypedOmit<SchemaReflectionData, 'schema'>;
+export declare function createSchemaDecorator(data?: SchemaReflectionData): CombinedSchemaDecorator;
+export declare function SchemaDecorator(schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;
+export declare function SchemaDecorator(options: SchemaDecoratorOptionsWithRequiredSchema): CombinedSchemaDecorator;
+export declare function Parameter(name: string, schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): Decorator<'parameter'>;
+export declare function Parameter(name: string, options: SchemaDecoratorOptions): Decorator<'parameter'>;
+export declare const Property: typeof SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export declare function PropertySchema(schemaTestableProvider: SchemaTestableProvider, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;

package/schema/decorators/schema.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createDecorator } from '../../reflection/index.js';
+import { filterUndefinedObjectProperties } from '../../utils/object/object.js';
+import { isSchemaTestable } from '../testable.js';
+export function createSchemaDecorator(data = {}) {
+    return createDecorator({
+        property: true,
+        accessor: true,
+        method: true,
+        parameter: true,
+        data: { schema: filterUndefinedObjectProperties(data) },
+        mergeData: true
+    });
+}
+export function SchemaDecorator(schemaOrOptions, optionsOrNothing) {
+    if (isSchemaTestable(schemaOrOptions)) {
+        return createSchemaDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions });
+    }
+    return createSchemaDecorator(schemaOrOptions);
+}
+export function Parameter(name, schemaOrOptions, optionsOrNothing) {
+    if (isSchemaTestable(schemaOrOptions)) {
+        return createSchemaDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions, parameter: { name } });
+    }
+    return createSchemaDecorator({ ...schemaOrOptions, parameter: { name } });
+}
+export const Property = SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export function PropertySchema(schemaTestableProvider, options) {
+    return SchemaDecorator({ ...options, schema: schemaTestableProvider });
+}

package/schema/decorators/types.d.ts

@@ -3,14 +3,22 @@ import type { SchemaOptions, SchemaTestable } from '../schema.js';
 import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
 export type SchemaClassDecorator = Decorator<'class'>;
 export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
+export type SchemaMethodDecorator = Decorator<'method'>;
+export type CombinedSchemaDecorator = Decorator<'property' | 'accessor' | 'parameter'>;
 export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey' | 'description' | 'example'>> & {
     schema?: SchemaTestable;
     factory?: ObjectSchemaFactory<any>;
 };
-export type SchemaTestableProvider = (data: SchemaPropertyReflectionData) => SchemaTestable;
-export type SchemaPropertyReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
+export type SchemaTestableProvider = (data: SchemaReflectionData) => SchemaTestable;
+export type SchemaReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
     schema?: SchemaTestableProvider;
     array?: boolean;
     optional?: boolean;
     nullable?: boolean;
+    method?: {
+        returnType?: SchemaTestableProvider;
+    };
+    parameter?: {
+        name?: string;
+    };
 };

package/schema/decorators/utils.d.ts

@@ -1,2 +1,7 @@
-import type { SchemaPropertyDecorator, SchemaPropertyReflectionData } from './types.js';
-export declare function createSchemaPropertyDecorator(data?: SchemaPropertyReflectionData): SchemaPropertyDecorator;
+import type { AbstractConstructor } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaReflectionData } from './types.js';
+export declare function schemaReflectionDataToSchema(reflectionData: SchemaReflectionData | undefined, fallbackType: AbstractConstructor | null, source: {
+    type: AbstractConstructor;
+    key: string | symbol;
+}): SchemaTestable;