@tstdl/base 0.92.10 → 0.92.12

package/ai/ai-file.service.d.ts

@@ -0,0 +1,28 @@
+import '../polyfills.js';
+import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
+import { FileContentPart, FileInput, AiModel } from './types.js';
+export type AiFileServiceOptions = {
+    apiKey: string;
+    defaultModel?: AiModel;
+};
+export type AiFileServiceArgument = AiFileServiceOptions;
+type File = {
+    id: string;
+    name: string;
+    uri: string;
+    mimeType: string;
+};
+export declare class AiFileService implements Resolvable<AiFileServiceArgument> {
+    #private;
+    readonly [resolveArgumentType]: AiFileServiceArgument;
+    processFile(fileInput: FileInput): Promise<FileContentPart>;
+    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
+    getFileById(id: string): File | undefined;
+    getFileByUri(uri: string): File | undefined;
+    private getFile;
+    private getFiles;
+    private uploadFile;
+    private waitForFileActive;
+    private waitForFilesActive;
+}
+export {};

package/ai/ai-file.service.js

@@ -0,0 +1,174 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import '../polyfills.js';
+import { stat, unlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
+import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
+import { DetailsError } from '../errors/details.error.js';
+import { Singleton } from '../injector/decorators.js';
+import { inject, injectArgument } from '../injector/inject.js';
+import { Logger } from '../logger/logger.js';
+import { createArray } from '../utils/array/array.js';
+import { formatBytes } from '../utils/format.js';
+import { timeout } from '../utils/timing.js';
+import { tryIgnoreAsync } from '../utils/try-ignore.js';
+import { isBlob } from '../utils/type-guards.js';
+import { millisecondsPerSecond } from '../utils/units.js';
+let AiFileService = class AiFileService {
+    #options = injectArgument(this);
+    #fileManager = new GoogleAIFileManager(this.#options.apiKey);
+    #fileMap = new Map();
+    #fileUriMap = new Map();
+    #logger = inject(Logger, 'AiFileService');
+    async processFile(fileInput) {
+        const file = await this.getFile(fileInput);
+        this.#fileMap.set(file.id, file);
+        this.#fileUriMap.set(file.uri, file);
+        return { file: file.id };
+    }
+    async processFiles(fileInputs) {
+        const files = await this.getFiles(fileInputs);
+        return files.map((file) => {
+            this.#fileMap.set(file.id, file);
+            this.#fileUriMap.set(file.uri, file);
+            return { file: file.id };
+        });
+    }
+    getFileById(id) {
+        return this.#fileMap.get(id);
+    }
+    getFileByUri(uri) {
+        return this.#fileUriMap.get(uri);
+    }
+    async getFile(fileInput) {
+        const id = crypto.randomUUID();
+        const uploadResponse = await this.uploadFile(fileInput, id);
+        this.#logger.verbose(`Processing file "${id}"...`);
+        const response = await this.waitForFileActive(uploadResponse);
+        return {
+            id,
+            name: response.name,
+            uri: response.uri,
+            mimeType: response.mimeType
+        };
+    }
+    async getFiles(files) {
+        const ids = createArray(files.length, () => crypto.randomUUID());
+        const uploadResponses = await AsyncEnumerable.from(files).parallelMap(5, true, async (file, index) => this.uploadFile(file, ids[index])).toArray();
+        this.#logger.verbose(`Processing ${files.length} files...`);
+        const responses = await this.waitForFilesActive(uploadResponses);
+        return responses.map((response, index) => ({
+            id: ids[index],
+            name: response.name,
+            uri: response.uri,
+            mimeType: response.mimeType
+        }));
+    }
+    async uploadFile(fileInput, id) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const path = isBlob(fileInput) ? join(tmpdir(), crypto.randomUUID()) : fileInput.path;
+            const mimeType = isBlob(fileInput) ? fileInput.type : fileInput.mimeType;
+            const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+            if (isBlob(fileInput)) {
+                this.#logger.verbose(`Preparing file "${id}"...`);
+                stack.defer(async () => tryIgnoreAsync(async () => unlink(path)));
+                await writeFile(path, fileInput.stream());
+            }
+            const fileSize = isBlob(fileInput) ? fileInput.size : (await stat(path)).size;
+            this.#logger.verbose(`Uploading file "${id}" (${formatBytes(fileSize)})...`);
+            const response = await this.#fileManager.uploadFile(path, { mimeType });
+            return response.file;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async waitForFileActive(fileMetadata) {
+        let file = await this.#fileManager.getFile(fileMetadata.name);
+        while (file.state == FileState.PROCESSING) {
+            await timeout(millisecondsPerSecond);
+            file = await this.#fileManager.getFile(fileMetadata.name);
+        }
+        if (file.state == FileState.FAILED) {
+            throw new DetailsError(file.error?.message ?? `Failed to process file ${file.name}`, file.error?.details);
+        }
+        return file;
+    }
+    async waitForFilesActive(files) {
+        const responses = [];
+        for (const file of files) {
+            const respones = await this.waitForFileActive(file);
+            responses.push(respones);
+        }
+        return responses;
+    }
+};
+AiFileService = __decorate([
+    Singleton()
+], AiFileService);
+export { AiFileService };

package/ai/ai-session.d.ts

@@ -0,0 +1,9 @@
+import type { TypedOmit } from '../types.js';
+import type { AiService } from './ai.service.js';
+import type { Content, GenerationRequest, GenerationResult } from './types.js';
+export declare class AiSession {
+    #private;
+    readonly contents: Content[];
+    constructor(aiService: AiService);
+    generate(content: Content | [Content, ...Content[]], request?: TypedOmit<GenerationRequest, 'contents'>): Promise<GenerationResult>;
+}

package/ai/ai-session.js

@@ -0,0 +1,18 @@
+import { toArray } from '../utils/array/array.js';
+export class AiSession {
+    #aiService;
+    contents = [];
+    constructor(aiService) {
+        this.#aiService = aiService;
+    }
+    async generate(content, request) {
+        const newContents = toArray(content);
+        const result = await this.#aiService.generate({
+            ...request,
+            contents: [...this.contents, ...newContents]
+        });
+        this.contents.push(...newContents);
+        this.contents.push(result.content);
+        return result;
+    }
+}

package/ai/ai.service.d.ts

@@ -1,53 +1,33 @@
 import '../polyfills.js';
-import { GoogleGenerativeAI } from '@google/generative-ai';
-import { type FileMetadataResponse, GoogleAIFileManager } from '@google/generative-ai/server';
-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';
-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> = {
+import { AiSession } from './ai-session.js';
+import { AiModel, Content, FileContentPart, FileInput, GenerationOptions, GenerationRequest, GenerationResult, GenerationUsage, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
+export type SpecializedGenerationResult<T> = {
     result: T;
-    usage?: {
-        promptTokenCount: number;
-        candidatesTokenCount: number;
-        totalTokenCount: number;
-    };
+    usage: GenerationUsage;
 };
 export type AiServiceOptions = {
     apiKey: string;
-    defaultModel?: GenerativeAIModel;
+    defaultModel?: AiModel;
 };
 export type AiServiceArgument = AiServiceOptions;
 export declare class AiService implements Resolvable<AiServiceArgument> {
     #private;
-    readonly genAI: GoogleGenerativeAI;
-    readonly fileManager: GoogleAIFileManager;
-    readonly defaultModel: GenerativeAIModel;
+    readonly defaultModel: AiModel;
     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<{
+    newSession(): AiSession;
+    processFile(fileInput: FileInput): Promise<FileContentPart>;
+    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
+    classify<T extends EnumerationType>(files: OneOrMany<FileContentPart>, types: T, model?: AiModel): Promise<SpecializedGenerationResult<{
         types: {
             type: EnumerationValue<T>;
             confidence: 'high' | 'medium' | 'low';
         }[] | 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<{
+    extractData<T>(files: OneOrMany<FileContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions): Promise<SpecializedGenerationResult<T>>;
+    analyzeDocument<T extends EnumerationType>(file: FileContentPart, types: T, options?: GenerationOptions): Promise<SpecializedGenerationResult<{
         content: string[];
         documentTypes: {
             type: EnumerationValue<T>;
@@ -55,14 +35,11 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
         }[];
         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;
+    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, contents: Content[], options?: Pick<GenerationRequest, 'model' | 'systemInstruction'> & GenerationOptions): Promise<SchemaFunctionDeclarationsResult<T>[]>;
+    generate(request: GenerationRequest): Promise<GenerationResult>;
     private convertContents;
     private convertContent;
+    private convertFunctions;
+    private convertGoogleContent;
     private getModel;
 }

package/ai/ai.service.js

@@ -4,241 +4,69 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import '../polyfills.js';
-import { openAsBlob } from 'node:fs';
-import { unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-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 { GoogleGenerativeAI } from '@google/generative-ai';
 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, string } from '../schema/index.js';
+import { array, enumeration, nullable, object, 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 { assertDefinedPass, isBlob } from '../utils/type-guards.js';
-import { millisecondsPerSecond } from '../utils/units.js';
+import { assertDefinedPass, assertNotNullPass, isDefined } from '../utils/type-guards.js';
+import { AiFileService } from './ai-file.service.js';
+import { AiSession } from './ai-session.js';
+import { isSchemaFunctionDeclarationWithHandler } from './types.js';
 let AiService = class AiService {
     #options = injectArgument(this);
-    #fileCache = new Map();
-    #logger = inject(Logger, 'AiService');
-    genAI = new GoogleGenerativeAI(this.#options.apiKey);
-    fileManager = new GoogleAIFileManager(this.#options.apiKey);
+    #fileService = inject(AiFileService, this.#options);
+    #genAI = new GoogleGenerativeAI(this.#options.apiKey);
     defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash-exp';
-    async getFile(fileInput) {
-        const path = isBlob(fileInput) ? join(tmpdir(), crypto.randomUUID()) : fileInput.path;
-        const mimeType = isBlob(fileInput) ? fileInput.type : fileInput.mimeType;
-        const blob = isBlob(fileInput) ? fileInput : await openAsBlob(path, { type: mimeType });
-        const buffer = await blob.arrayBuffer();
-        const byteArray = new Uint8Array(buffer);
-        const fileHash = await digest('SHA-1', byteArray).toBase64();
-        const fileKey = `${fileHash}:${byteArray.length}`;
-        if (this.#fileCache.has(fileKey)) {
-            try {
-                this.#logger.verbose(`Fetching file "${fileHash}" from cache...`);
-                const cachedFile = await this.#fileCache.get(fileKey);
-                return await this.fileManager.getFile(cachedFile.name);
-            }
-            catch {
-                this.#fileCache.delete(fileKey);
-            }
-        }
-        const filePromise = (async () => {
-            try {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-                    if (isBlob(fileInput)) {
-                        stack.defer(async () => tryIgnoreAsync(async () => unlink(path)));
-                        await writeFile(path, byteArray);
-                    }
-                    this.#logger.verbose(`Uploading file "${fileHash}" (${formatBytes(byteArray.length)})...`);
-                    const result = await this.fileManager.uploadFile(path, { mimeType });
-                    this.#logger.verbose(`Processing file "${fileHash}"...`);
-                    return await this.waitForFileActive(result.file);
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    const result_1 = __disposeResources(env_1);
-                    if (result_1)
-                        await result_1;
-                }
-            }
-            catch (error) {
-                this.#fileCache.delete(fileKey);
-                throw error;
-            }
-        })();
-        this.#fileCache.set(fileKey, filePromise);
-        return filePromise;
+    newSession() {
+        return new AiSession(this);
     }
-    async getFiles(files) {
-        return Promise.all(files.map(async (file) => this.getFile(file)));
+    async processFile(fileInput) {
+        return this.#fileService.processFile(fileInput);
     }
-    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 processFiles(fileInputs) {
+        return this.#fileService.processFiles(fileInputs);
     }
-    async classify(fileInput, types, options) {
-        const files = await this.getFiles(toArray(fileInput));
-        const resultSchema = object({
+    async classify(files, types, model) {
+        const generationSchema = object({
             types: nullable(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' }))
         });
-        const responseSchema = convertToOpenApiSchema(resultSchema);
-        this.#logger.verbose('Classifying...');
-        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
-            generationConfig: {
-                maxOutputTokens: 2048,
-                temperature: 0.75,
-                ...options,
-                responseMimeType: 'application/json',
-                responseSchema
+        const result = await this.generate({
+            model,
+            generationOptions: {
+                maxOutputTokens: 1048,
+                temperature: 0.5
             },
+            generationSchema,
             systemInstruction: 'You are a highly accurate document classification AI. Your task is to analyze the content of a given document and determine its type based on a predefined list of possible document types.',
-            contents: [
-                {
+            contents: [{
                     role: 'user',
                     parts: [
-                        ...files.map((file) => ({ fileData: { mimeType: file.mimeType, fileUri: file.uri } })),
-                        { text: `Classify the document. Output as JSON using the following schema:\n${JSON.stringify(responseSchema, null, 2)}\n\nIf none of the provided document types are a suitable match, return null for types.` }
+                        ...toArray(files),
+                        { text: 'Classify the document. Output as JSON using the provided schema\n\nIf none of the provided document types are a suitable match, return null for types.' }
                     ]
-                }
-            ]
+                }]
         });
         return {
-            usage: result.response.usageMetadata,
-            result: resultSchema.parse(JSON.parse(result.response.text()))
+            usage: result.usage,
+            result: JSON.parse(assertNotNullPass(result.text, 'No text returned.'))
         };
     }
-    async extractData(fileInput, schema, options) {
-        const files = await this.getFiles(toArray(fileInput));
-        const responseSchema = convertToOpenApiSchema(schema);
-        this.#logger.verbose('Extracting data...');
-        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
-            generationConfig: {
+    async extractData(files, schema, options) {
+        const result = await this.generate({
+            generationOptions: {
                 maxOutputTokens: 8192,
-                temperature: 0.75,
-                ...options,
-                responseMimeType: 'application/json',
-                responseSchema
+                temperature: 0.5,
+                ...options
             },
+            generationSchema: schema,
             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:**
@@ -247,37 +75,33 @@ Carefully read and analyze the provided document. Identify relevant information
                 {
                     role: 'user',
                     parts: [
-                        ...files.map((file) => ({ fileData: { mimeType: file.mimeType, fileUri: file.uri } })),
-                        { text: `Classify the document. Output as JSON using the following schema:\n${JSON.stringify(responseSchema, null, 2)}` }
+                        ...toArray(files),
+                        { text: 'Classify the document. Output as JSON.' }
                     ]
                 }
             ]
         });
         return {
-            usage: result.response.usageMetadata,
-            result: Schema.parse(schema, JSON.parse(result.response.text()))
+            usage: result.usage,
+            result: JSON.parse(assertNotNullPass(result.text, 'No text returned.'))
         };
     }
-    async analyzeDocument(fileInput, types, options) {
-        const file = await this.getFile(fileInput);
+    async analyzeDocument(file, types, options) {
         const schema = object({
-            content: array(string({ description: 'Single content without data details' }), { description: 'List of contents' }),
+            content: string({ description: 'Content of the document with important details only' }),
             documentTypes: array(object({
                 type: enumeration(types, { description: 'Type of document' }),
-                confidence: enumeration(['high', 'medium', 'low'], { description: 'How sure/certain you are about the classficiation.' })
+                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' })
+            tags: array(string({ description: 'Tag which describes the content' }), { description: 'List of tags', maximum: 5 })
         });
-        const responseSchema = convertToOpenApiSchema(schema);
-        this.#logger.verbose('Extracting data...');
-        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
-            generationConfig: {
+        const result = await this.generate({
+            generationOptions: {
                 maxOutputTokens: 2048,
-                temperature: 0.75,
-                ...options,
-                responseMimeType: 'application/json',
-                responseSchema
+                temperature: 0.5,
+                ...options
             },
+            generationSchema: schema,
             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:**
@@ -291,175 +115,123 @@ Always output the content and tags in Deutsch.`,
                 {
                     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.' }
+                        file,
+                        { text: 'Classify the document. Output as JSON.' }
                     ]
                 }
             ]
         });
         return {
-            usage: result.response.usageMetadata,
-            result: {
-                functions: result.response.functionCalls(),
-                text: result.response.text()
-            }
+            usage: result.usage,
+            result: JSON.parse(assertNotNullPass(result.text, 'No text returned.'))
         };
     }
     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: {
+        const generation = await this.generate({
+            model: options?.model,
+            generationOptions: {
                 maxOutputTokens: 4096,
-                temperature: 0.75,
+                temperature: 0.5,
                 ...options
             },
             systemInstruction: options?.systemInstruction,
-            tools: [{ functionDeclarations: googleFunctionDeclarations }],
-            toolConfig: {
-                functionCallingConfig: {
-                    mode: (options?.forceFunctionCall == false) ? FunctionCallingMode.AUTO : FunctionCallingMode.ANY
-                }
-            },
-            contents: googleContent
+            functions,
+            functionCallingMode: 'force',
+            contents
         });
-        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);
+        const result = [];
+        for (const call of generation.functionCalls) {
+            const fn = assertDefinedPass(functions[call.name], 'Function in response not declared.');
+            const parameters = fn.parameters.parse(call.parameters);
+            const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
+            result.push({ functionName: call.name, parameters: parameters, handlerResult: handlerResult });
         }
+        return result;
     }
-    async waitForFileActive(fileMetadata) {
-        let file = await this.fileManager.getFile(fileMetadata.name);
-        while (file.state == FileState.PROCESSING) {
-            await timeout(millisecondsPerSecond);
-            file = await this.fileManager.getFile(fileMetadata.name);
-        }
-        if (file.state == FileState.FAILED) {
-            throw new DetailsError(file.error?.message ?? `Failed to process file ${file.name}`, file.error?.details);
-        }
-        return file;
-    }
-    async waitForFilesActive(...files) {
-        const responses = [];
-        for (const file of files) {
-            const respones = await this.waitForFileActive(file);
-            responses.push(respones);
-        }
-        return responses;
+    async generate(request) {
+        const googleContent = this.convertContents(request.contents);
+        const googleFunctionDeclarations = isDefined(request.functions) ? this.convertFunctions(request.functions) : undefined;
+        const generationConfig = isDefined(request.generationSchema)
+            ? { ...request.generationOptions, responseMimeType: 'application/json', responseSchema: convertToOpenApiSchema(request.generationSchema) }
+            : request.generationOptions;
+        const generation = await this.getModel(request.model ?? this.defaultModel).generateContent({
+            generationConfig,
+            systemInstruction: request.systemInstruction,
+            tools: isDefined(googleFunctionDeclarations) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
+            toolConfig: isDefined(request.functionCallingMode)
+                ? { functionCallingConfig: { mode: (request.functionCallingMode ?? 'auto').toUpperCase() } }
+                : undefined,
+            contents: googleContent
+        });
+        const content = this.convertGoogleContent(generation.response.candidates.at(0).content);
+        const textParts = content.parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
+        const functionCallParts = content.parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
+        return {
+            content,
+            text: textParts.length > 0 ? textParts.join('') : null,
+            functionCalls: functionCallParts,
+            usage: {
+                prompt: generation.response.usageMetadata.promptTokenCount,
+                output: generation.response.usageMetadata.candidatesTokenCount,
+                total: generation.response.usageMetadata.totalTokenCount
+            }
+        };
     }
-    async convertContents(contents) {
-        return AsyncEnumerable.from(contents)
-            .map(async (content) => this.convertContent(content))
-            .toArray();
+    convertContents(contents) {
+        return contents.map((content) => this.convertContent(content));
     }
-    async convertContent(content) {
+    convertContent(content) {
         return {
             role: content.role,
-            parts: await AsyncEnumerable.from(content.parts)
-                .map(async (part) => {
+            parts: content.parts.map((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 } };
+                    const file = assertDefinedPass(this.#fileService.getFileById(part.file), `File ${part.file} not found.`);
+                    return { fileData: { fileUri: file.uri, mimeType: file.mimeType } };
                 }
                 if (hasOwnProperty(part, 'functionResult')) {
-                    return { functionResponse: { name: part.functionResult.name, response: { result: part.functionResult.value } } };
+                    return { functionResponse: { name: part.functionResult.name, response: part.functionResult.value } };
+                }
+                if (hasOwnProperty(part, 'functionCall')) {
+                    return { functionCall: { name: part.functionCall.name, args: part.functionCall.parameters } };
+                }
+                throw new NotSupportedError('Unsupported content part.');
+            })
+        };
+    }
+    convertFunctions(functions) {
+        return objectEntries(functions).map(([name, declaration]) => ({
+            name,
+            description: declaration.description,
+            parameters: convertToOpenApiSchema(declaration.parameters)
+        }));
+    }
+    convertGoogleContent(content) {
+        return {
+            role: content.role,
+            parts: content.parts.map((part) => {
+                if (isDefined(part.text)) {
+                    return { text: part.text };
+                }
+                if (isDefined(part.fileData)) {
+                    const file = assertDefinedPass(this.#fileService.getFileByUri(part.fileData.fileUri), `File not found.`);
+                    return { file: file.id };
+                }
+                ;
+                if (isDefined(part.functionResponse)) {
+                    return { functionResult: { name: part.functionResponse.name, value: part.functionResponse.response } };
+                }
+                if (isDefined(part.functionCall)) {
+                    return { functionCall: { name: part.functionCall.name, parameters: part.functionCall.args } };
                 }
                 throw new NotSupportedError('Unsupported content part.');
             })
-                .toArray()
         };
     }
     getModel(model) {
-        return this.genAI.getGenerativeModel({ model });
+        return this.#genAI.getGenerativeModel({ model });
     }
 };
 AiService = __decorate([

package/ai/functions.d.ts

@@ -1,5 +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 convertFunctionDeclarations(declarations: SchemaFunctionDeclarations): FunctionDeclaration[];
 export declare function getFunctionDeclarations(type: AbstractConstructor): FunctionDeclaration[];

package/ai/functions.js

@@ -3,7 +3,7 @@ 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)
+    return objectEntries(declarations)
         .map(([name, declaration]) => ({
         name,
         description: declaration.description,

package/ai/index.d.ts

@@ -1 +1,5 @@
+export * from './ai-file.service.js';
+export * from './ai-session.js';
 export * from './ai.service.js';
+export * from './functions.js';
+export * from './types.js';

package/ai/index.js

@@ -1 +1,5 @@
+export * from './ai-file.service.js';
+export * from './ai-session.js';
 export * from './ai.service.js';
+export * from './functions.js';
+export * from './types.js';

package/ai/types.d.ts

@@ -1,27 +1,84 @@
-import type { ObjectSchema } from '../schema/index.js';
-import type { Record, UndefinableJson } from '../types.js';
+import type { LiteralUnion } from 'type-fest';
+import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
+import type { Record, UndefinableJsonObject } 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> = {
+export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
     description: string;
     parameters: ObjectSchema<T>;
+};
+export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
     handler: (parameters: T) => R | Promise<R>;
 };
+export type SchemaFunctionDeclaration<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> | SchemaFunctionDeclarationWithHandler<T, R>;
+export type SchemaFunctionDeclarationHandlerResult<T extends SchemaFunctionDeclaration> = T extends SchemaFunctionDeclarationWithHandler<any, infer R> ? R : never;
+export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclarations = SchemaFunctionDeclarations> = {
+    [P in keyof T]: {
+        functionName: P;
+        parameters: SchemaOutput<T[P]['parameters']>;
+        handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
+    };
+}[keyof T];
+export type ContentRole = 'user' | 'model';
+export type TextContentPart = {
+    text: string;
+};
+export type FileContentPart = {
+    file: string;
+};
+export type FunctionCall = {
+    name: string;
+    parameters: UndefinableJsonObject;
+};
+export type FunctionCallContentPart = {
+    functionCall: FunctionCall;
+};
+export type FunctionResult = {
+    name: string;
+    value: UndefinableJsonObject;
+};
+export type FunctionResultContentPart = {
+    functionResult: FunctionResult;
+};
+export type ContentPart = TextContentPart | FileContentPart | FunctionCallContentPart | FunctionResultContentPart;
 export type Content = {
-    role: 'user' | 'model';
+    role: ContentRole;
     parts: ContentPart[];
 };
-export type ContentPart = {
-    text: string;
-} | {
-    file: FileInput;
-} | {
-    functionResult: {
-        name: string;
-        value: NonNullable<UndefinableJson>;
-    };
+export type FunctionCallingMode = 'auto' | 'force' | 'none';
+export type AiModel = LiteralUnion<'gemini-2.0-flash-exp' | 'gemini-exp-1206' | 'gemini-2.0-flash-thinking-exp-1219', string>;
+export type GenerationOptions = {
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+};
+export type GenerationRequest = {
+    model?: AiModel;
+    systemInstruction?: string;
+    contents: Content[];
+    functions?: SchemaFunctionDeclarations;
+    functionCallingMode?: FunctionCallingMode;
+    generationSchema?: SchemaTestable;
+    generationOptions?: GenerationOptions;
+};
+export type GenerationUsage = {
+    prompt: number;
+    output: number;
+    total: number;
+};
+export type GenerationResult = {
+    content: Content;
+    text: string | null;
+    functionCalls: FunctionCall[];
+    usage: GenerationUsage;
 };
-export declare function declareFunction<T extends Record = Record, R = unknown>(description: string, parameters: ObjectSchema<T>, handler: (parameters: T) => R | Promise<R>): SchemaFunctionDeclaration<T, R>;
+export declare function declareFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
+export declare function declareFunction<T extends Record = Record>(description: string, parameters: ObjectSchema<T>): SchemaFunctionDeclaration<T, never>;
+export declare function declareFunction<T extends Record = Record, R = never>(description: string, parameters: ObjectSchema<T>, handler: (parameters: T) => R | Promise<R>): SchemaFunctionDeclaration<T, R>;
+export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;

package/ai/types.js

@@ -1,3 +1,10 @@
+import { hasOwnProperty } from '../utils/object/object.js';
+export function declareFunctions(declarations) {
+    return declarations;
+}
 export function declareFunction(description, parameters, handler) {
     return { description, parameters, handler };
 }
+export function isSchemaFunctionDeclarationWithHandler(declaration) {
+    return hasOwnProperty(declaration, 'handler');
+}

package/api/response.d.ts

@@ -1,4 +1,4 @@
-import type { CustomError, CustomErrorStatic } from '../errors/index.js';
+import { type CustomError, type CustomErrorStatic } from '../errors/index.js';
 import type { UndefinableJson } from '../types.js';
 export type ErrorHandlerData = undefined | UndefinableJson;
 export type ErrorSerializer<T extends CustomError, TData extends ErrorHandlerData> = (error: T) => TData;

package/api/response.js

@@ -28,7 +28,7 @@ export function createErrorResponse(errorOrName, message = '', details) {
     let response;
     if (errorOrName instanceof Error) {
         const handler = errorHandlers.get(errorOrName.name);
-        if (handler != undefined) {
+        if (isDefined(handler)) {
             const data = handler.serializer(errorOrName);
             response = {
                 error: {

package/data-structures/weak-ref-map.d.ts

@@ -5,7 +5,7 @@ export declare class WeakRefMap<K, V extends object> extends Collection<[K, V],
     private finalizationRegistry;
     readonly [Symbol.toStringTag] = "WeakRefMap";
     /**
-     * provides the real size. This is slow because it requires a cleanup iteration
+     * Provides the real size. This is slow because it requires a cleanup iteration
      */
     get realSize(): number;
     static get supported(): boolean;
@@ -17,7 +17,7 @@ export declare class WeakRefMap<K, V extends object> extends Collection<[K, V],
     addMany(values: Iterable<[K, V]>): void;
     set(key: K, value: V): this;
     delete(key: K): boolean;
-    /** prune garbage collected entries */
+    /** Prune garbage collected entries */
     cleanup(): void;
     clone(): WeakRefMap<K, V>;
     forEach(callback: (value: V, key: K, map: WeakRefMap<K, V>) => void, thisArg?: any): void;

package/data-structures/weak-ref-map.js

@@ -8,7 +8,7 @@ export class WeakRefMap extends Collection {
     finalizationRegistry;
     [Symbol.toStringTag] = 'WeakRefMap';
     /**
-     * provides the real size. This is slow because it requires a cleanup iteration
+     * Provides the real size. This is slow because it requires a cleanup iteration
      */
     get realSize() {
         this.cleanup();
@@ -77,10 +77,10 @@ export class WeakRefMap extends Collection {
         }
         return deleted;
     }
-    /** prune garbage collected entries */
+    /** Prune garbage collected entries */
     cleanup() {
         for (const _ of this) {
-            // ignore
+            // Ignore
         }
     }
     clone() {

package/document-management/api/document-management.api.d.ts

@@ -32,8 +32,8 @@ export declare const documentManagementApiDefinition: {
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly title: string | null;
                 readonly id: string;
+                readonly title: string | null;
                 readonly download?: boolean | undefined;
             }>;
             result: Uint8ArrayConstructor;
@@ -43,8 +43,8 @@ export declare const documentManagementApiDefinition: {
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly title: string | null;
                 readonly id: string;
+                readonly title: string | null;
                 readonly download?: boolean | undefined;
             }>;
             result: import("../../schema/index.js").StringSchema;
@@ -406,8 +406,8 @@ declare const _DocumentManagementApi: import("../../api/index.js").ApiClient<{
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly title: string | null;
                 readonly id: string;
+                readonly title: string | null;
                 readonly download?: boolean | undefined;
             }>;
             result: Uint8ArrayConstructor;
@@ -417,8 +417,8 @@ declare const _DocumentManagementApi: import("../../api/index.js").ApiClient<{
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly title: string | null;
                 readonly id: string;
+                readonly title: string | null;
                 readonly download?: boolean | undefined;
             }>;
             result: import("../../schema/index.js").StringSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.10",
+  "version": "0.92.12",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -134,7 +134,7 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.19",
+    "@typescript-eslint/eslint-plugin": "8.20",
     "concurrently": "9.1",
     "drizzle-kit": "0.30",
     "eslint": "8.57",

package/schema/schema.d.ts

@@ -19,7 +19,7 @@ export type SchemaTestResult<T> = {
     error: SchemaError;
 };
 type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, String>> extends true ? typeof String : Or<IsEqual<T, number>, IsEqual<T, Number>> extends true ? typeof Number : Or<IsEqual<T, boolean>, IsEqual<T, Boolean>> extends true ? typeof Boolean : Or<IsEqual<T, bigint>, IsEqual<T, BigInt>> extends true ? typeof BigInt : Or<IsEqual<T, symbol>, IsEqual<T, Symbol>> extends true ? typeof Symbol : never;
-export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
+export type SchemaTestable<T = any> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
 export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
 export declare const OPTIONAL: unique symbol;
 export type SchemaOptions<_T> = {

package/schema/schemas/array.js

@@ -1,6 +1,6 @@
 import { SchemaError } from '../../schema/schema.error.js';
 import { lazyProperty } from '../../utils/object/lazy-property.js';
-import { isArray } from '../../utils/type-guards.js';
+import { isArray, isNotNull } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { PropertySchema } from '../decorators/index.js';
 import { Schema } from '../schema.js';
@@ -26,6 +26,12 @@ export class ArraySchema extends Schema {
             }
             return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
         }
+        if (isNotNull(this.maximum) && (value.length > this.maximum)) {
+            throw new Error(`A maximum of ${this.maximum} items are allowed.`);
+        }
+        if (isNotNull(this.minimum) && (value.length < this.minimum)) {
+            throw new Error(`A minimum of ${this.minimum} items are required.`);
+        }
         const values = [];
         for (let i = 0; i < value.length; i++) {
             const result = this.itemSchema._test(value[i], path.add(i), options);

package/schema/schemas/one-or-many.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { OneOrMany as OneOrManyType } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]>;
 export type OneOrMany<T> = OneOrManyType<T>;