@tstdl/base 0.92.122 → 0.92.124

package/ai/ai-file.service.js

@@ -5,9 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import '../polyfills.js';
-import { readFile } from 'node:fs/promises';
+import { openAsBlob } from 'node:fs';
 import { Storage } from '@google-cloud/storage';
-import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
+import { FileState, GoogleGenAI } from '@google/genai';
 import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
 import { DetailsError } from '../errors/details.error.js';
 import { NotImplementedError } from '../errors/not-implemented.error.js';
@@ -21,7 +21,13 @@ import { assertDefinedPass, isBlob, isDefined, isUndefined } from '../utils/type
 import { millisecondsPerSecond } from '../utils/units.js';
 let AiFileService = class AiFileService {
     #options = injectArgument(this);
-    #fileManager = isUndefined(this.#options.vertex) ? new GoogleAIFileManager(assertDefinedPass(this.#options.apiKey, 'Api key not defined')) : undefined;
+    #genAI = new GoogleGenAI({
+        vertexai: isDefined(this.#options.vertex?.project),
+        project: this.#options.vertex?.project,
+        location: this.#options.vertex?.location,
+        googleAuthOptions: isDefined(this.#options.vertex?.project) ? { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } : undefined,
+        apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
+    });
     #storage = isDefined(this.#options.vertex) ? new Storage({ keyFile: assertDefinedPass(this.#options.keyFile, 'Key file not defined'), projectId: this.#options.vertex.project }) : undefined;
     #fileMap = new Map();
     #fileUriMap = new Map();
@@ -63,11 +69,10 @@ let AiFileService = class AiFileService {
     }
     async uploadFile(fileInput, id) {
         const inputIsBlob = isBlob(fileInput);
-        const buffer = inputIsBlob
-            ? Buffer.from(await fileInput.arrayBuffer())
-            : await readFile(fileInput.path);
-        const mimeType = inputIsBlob ? fileInput.type : fileInput.mimeType;
-        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(buffer.length)})...`);
+        const blob = inputIsBlob
+            ? fileInput
+            : await openAsBlob(fileInput.path, { type: fileInput.mimeType });
+        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(blob.size)})...`);
         if (isDefined(this.#storage)) {
             throw new NotImplementedError();
             /*
@@ -82,12 +87,12 @@ let AiFileService = class AiFileService {
             };
             */
         }
-        const response = await this.#fileManager.uploadFile(buffer, { mimeType });
+        const response = await this.#genAI.files.upload({ file: blob, config: { mimeType: blob.type } });
         return {
             id,
-            name: response.file.name,
-            uri: response.file.uri,
-            mimeType: response.file.mimeType
+            name: assertDefinedPass(response.name, 'Missing file name'),
+            uri: assertDefinedPass(response.uri, 'Missing file uri'),
+            mimeType: assertDefinedPass(response.mimeType, 'Missing file mime type'),
         };
     }
     async getBucket() {
@@ -105,22 +110,22 @@ let AiFileService = class AiFileService {
                 lifecycle: {
                     rule: [{
                             action: { type: 'Delete' },
-                            condition: { age: 1 }
-                        }]
-                }
+                            condition: { age: 1 },
+                        }],
+                },
             });
             this.#bucket = bucket;
         }
         return this.#bucket;
     }
     async waitForFileActive(file) {
-        if (isUndefined(this.#fileManager)) {
+        if (isUndefined(this.#genAI)) {
             return;
         }
-        let state = await this.#fileManager.getFile(file.name);
+        let state = await this.#genAI.files.get({ name: file.name });
         while (state.state == FileState.PROCESSING) {
             await timeout(millisecondsPerSecond);
-            state = await this.#fileManager.getFile(file.name);
+            state = await this.#genAI.files.get({ name: file.name });
         }
         if (state.state == FileState.FAILED) {
             throw new DetailsError(state.error?.message ?? `Failed to process file ${state.name}`, state.error?.details);

package/ai/ai.service.js

@@ -6,8 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var AiService_1;
-import { FinishReason, FunctionCallingMode as GoogleFunctionCallingMode, VertexAI } from '@google-cloud/vertexai';
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
@@ -16,14 +15,14 @@ import { getShutdownSignal } from '../process-shutdown.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { LazyPromise } from '../promise/lazy-promise.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
-import { array, enumeration, nullable, object, Schema, string } from '../schema/index.js';
+import { Schema } from '../schema/index.js';
 import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
 import { lazyObject } from '../utils/object/lazy-property.js';
 import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
 import { cancelableTimeout } from '../utils/timing.js';
-import { assertDefinedPass, assertNotNullPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
 import { millisecondsPerSecond } from '../utils/units.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
@@ -39,16 +38,21 @@ export class AiServiceOptions {
 const functionCallingModeMap = {
     auto: GoogleFunctionCallingMode.AUTO,
     force: GoogleFunctionCallingMode.ANY,
-    none: GoogleFunctionCallingMode.NONE
+    none: GoogleFunctionCallingMode.NONE,
 };
 let generationCounter = 0;
 let AiService = AiService_1 = class AiService {
     #options = injectArgument(this, { optional: true }) ?? inject(AiServiceOptions);
     #fileService = inject(AiFileService, this.#options);
     #logger = inject(Logger, AiService_1.name);
-    #genAI = (isDefined(this.#options.vertex)
-        ? new VertexAI({ project: this.#options.vertex.project, location: this.#options.vertex.location, googleAuthOptions: { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } })
-        : new GoogleGenerativeAI(assertDefinedPass(this.#options.apiKey, 'Api key not defined')));
+    #genAI = new GoogleGenAI({
+        vertexai: isDefined(this.#options.vertex?.project),
+        project: this.#options.vertex?.project,
+        location: this.#options.vertex?.location,
+        googleAuthOptions: isDefined(this.#options.vertex?.project) ? { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } : undefined,
+        apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
+    });
+    #maxOutputTokensCache = new Map();
     defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash';
     createSession() {
         return new AiSession(this);
@@ -62,117 +66,17 @@ let AiService = AiService_1 = class AiService {
     getFileById(id) {
         return { file: id };
     }
-    async classify(parts, types, options) {
-        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 generation = await this.generate({
-            model: options?.model,
-            generationOptions: {
-                maxOutputTokens: 1048,
-                temperature: 0.5,
-                ...options
-            },
-            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: this.getClassifyContents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getClassifyContents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { 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.' }
-                ]
-            }];
-    }
-    async extractData(parts, schema, options) {
-        const generation = await this.generate({
-            model: options?.model,
-            generationOptions: {
-                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:**
-Carefully read and analyze the provided document. Identify relevant information that corresponds to each field in the JSON schema. Focus on accuracy and avoid making assumptions. If a field has multiple possible values, extract all relevant ones into the correct array structures ONLY IF the schema defines that field as an array; otherwise, extract only the single most relevant value.`,
-            contents: this.getExtractDataConents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getExtractDataConents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { text: 'Extract the data as specified in the schema. Output as JSON.' }
-                ]
-            }];
-    }
-    async analyzeContent(parts, types, options) {
-        const schema = object({
-            content: string({ description: 'Content of the document with important details only' }),
-            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' })),
-            tags: array(string({ description: 'Tag which describes the content' }), { description: 'List of tags', maximum: options?.maximumNumberOfTags ?? 5 })
-        });
-        const generation = await this.generate({
-            generationOptions: {
-                maxOutputTokens: 2048,
-                temperature: 0.5,
-                ...options
-            },
-            generationSchema: schema,
-            systemInstruction: `You are a highly skilled data extraction AI, specializing in accurately identifying and extracting information from unstructured content 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 content.
-Identify key points and relevant information that describes the content. Focus on a general overview without providing specific details.
-Classify the content based on the provided list of types.
-Output up to ${options?.maximumNumberOfTags ?? 5} tags.
-Always output the content and tags in ${options?.targetLanguage ?? 'the same language as the content'}.`,
-            contents: this.getAnalyzeContentConents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getAnalyzeContentConents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { text: 'Classify the document. Output as JSON.' }
-                ]
-            }];
-    }
     async callFunctions(options) {
         const generation = await this.generate({
             model: options.model,
             generationOptions: {
                 temperature: 0.5,
-                ...options
+                ...options,
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
             functionCallingMode: options.functionCallingMode ?? 'force',
-            contents: options.contents
+            contents: options.contents,
         });
         const result = [];
         for (const call of generation.functionCalls) {
@@ -184,13 +88,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 functionName: call.name,
                 parameters: parameters,
                 handlerResult: handlerResult,
-                getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+                getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } }),
             });
         }
         return {
             result,
             raw: generation,
-            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart())
+            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart()),
         };
     }
     callFunctionsStream(options) {
@@ -209,17 +113,26 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
     async *generateStream(request) {
         const generationNumber = ++generationCounter;
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
-        const generationConfig = {
-            maxOutputTokens: request.generationOptions?.maxOutputTokens,
+        const config = {
+            systemInstruction: request.systemInstruction,
             temperature: request.generationOptions?.temperature,
             topP: request.generationOptions?.topP,
             topK: request.generationOptions?.topK,
+            presencePenalty: request.generationOptions?.presencePenalty,
+            frequencyPenalty: request.generationOptions?.frequencyPenalty,
             responseMimeType: isDefined(request.generationSchema) ? 'application/json' : undefined,
             responseSchema: isDefined(request.generationSchema) ? convertToOpenApiSchema(request.generationSchema) : undefined,
-            frequencyPenalty: request.generationOptions?.frequencyPenalty
+            safetySettings: [],
+            tools: (isDefined(googleFunctionDeclarations) && (googleFunctionDeclarations.length > 0)) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
+            toolConfig: isDefined(request.functionCallingMode)
+                ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
+                : undefined,
+            thinkingConfig: {
+                thinkingBudget: request.generationOptions?.thinkingBudget,
+            },
         };
         const model = request.model ?? this.defaultModel;
-        const maxModelTokens = model.includes('thinking') ? 65536 : 8192;
+        const maxModelTokens = await this.getModelOutputTokenLimit(model);
         const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? maxModelTokens;
         const inputContent = this.convertContents(request.contents);
         let iterations = 0;
@@ -231,17 +144,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             for (let i = 0;; i++) {
                 try {
                     this.#logger.verbose(`[C:${generationNumber}] [I:${iterations + 1}] Generating...`);
-                    generation = await this.getModel(model).generateContentStream({
-                        generationConfig: {
-                            ...generationConfig,
-                            maxOutputTokens: Math.min(maxModelTokens, maxTotalOutputTokens - totalOutputTokens)
+                    generation = await this.#genAI.models.generateContentStream({
+                        model,
+                        config: {
+                            ...config,
+                            maxOutputTokens: Math.min(maxModelTokens, maxTotalOutputTokens - totalOutputTokens),
                         },
-                        systemInstruction: request.systemInstruction,
-                        tools: (isDefined(googleFunctionDeclarations) && (googleFunctionDeclarations.length > 0)) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
-                        toolConfig: isDefined(request.functionCallingMode)
-                            ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
-                            : undefined,
-                        contents: inputContent
+                        contents: inputContent,
                     });
                     break;
                 }
@@ -259,12 +168,19 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             iterations++;
             let lastUsageMetadata;
             let candidate;
-            for await (const generationResponse of generation.stream) {
-                candidate = generationResponse.candidates.at(0);
-                inputContent.push(candidate.content);
+            for await (const generationResponse of generation) {
+                candidate = generationResponse.candidates?.at(0);
+                const rawContent = candidate?.content;
+                if (isUndefined(candidate)) {
+                    throw new Error('No candidate returned.');
+                }
+                if (isUndefined(rawContent)) {
+                    throw new Error('No content returned.');
+                }
+                inputContent.push(rawContent);
                 const { promptTokenCount = 0, candidatesTokenCount = 0 } = generationResponse.usageMetadata ?? {};
                 lastUsageMetadata = generationResponse.usageMetadata;
-                const content = this.convertGoogleContent(candidate.content);
+                const content = this.convertGoogleContent(rawContent);
                 let text;
                 let functionCallParts;
                 const result = {
@@ -294,13 +210,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                         iterations,
                         prompt: totalPromptTokens + promptTokenCount,
                         output: totalOutputTokens + candidatesTokenCount,
-                        total: totalTokens + promptTokenCount + candidatesTokenCount
-                    }
+                        total: totalTokens + promptTokenCount + candidatesTokenCount,
+                    },
                 };
                 yield result;
             }
             totalPromptTokens += lastUsageMetadata?.promptTokenCount ?? 0;
-            totalOutputTokens += lastUsageMetadata?.candidatesTokenCount ?? 0;
+            totalOutputTokens += lastUsageMetadata?.responseTokenCount ?? 0;
             totalTokens += lastUsageMetadata?.totalTokenCount ?? 0;
             if (candidate?.finishReason != FinishReason.MAX_TOKENS) {
                 break;
@@ -312,12 +228,12 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             model: options.model,
             generationOptions: {
                 temperature: 0.5,
-                ...options
+                ...options,
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
             functionCallingMode: options.functionCallingMode ?? 'force',
-            contents: options.contents
+            contents: options.contents,
         });
         const items = [];
         for await (const generation of generationStream) {
@@ -331,12 +247,31 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                     functionName: call.name,
                     parameters: parameters,
                     handlerResult: handlerResult,
-                    getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+                    getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } }),
                 };
             }
         }
         itemsPromise.resolve(items);
     }
+    async getModelOutputTokenLimit(model) {
+        const existingValue = this.#maxOutputTokensCache.get(model);
+        if (isDefined(existingValue)) {
+            return existingValue;
+        }
+        const promise = this._getModelOutputTokenLimit(model);
+        this.#maxOutputTokensCache.set(model, promise);
+        promise
+            .then((limit) => this.#maxOutputTokensCache.set(model, limit))
+            .catch(() => this.#maxOutputTokensCache.delete(model));
+        return promise;
+    }
+    async _getModelOutputTokenLimit(model) {
+        const modelInfo = await this.#genAI.models.get({ model });
+        if (isUndefined(modelInfo.outputTokenLimit)) {
+            throw new Error(`Model ${model} does not support maxOutputTokens`);
+        }
+        return modelInfo.outputTokenLimit;
+    }
     convertContents(contents) {
         return toArray(contents).map((content) => this.convertContent(content));
     }
@@ -358,7 +293,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                     return { functionCall: { name: part.functionCall.name, args: part.functionCall.parameters } };
                 }
                 throw new NotSupportedError('Unsupported content part.');
-            })
+            }),
         };
     }
     async convertFunctions(functions) {
@@ -371,7 +306,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             return {
                 name,
                 description: declaration.description,
-                parameters: isDefined(parametersSchema) ? convertToOpenApiSchema(parametersSchema) : undefined
+                parameters: isDefined(parametersSchema) ? convertToOpenApiSchema(parametersSchema) : undefined,
             };
         });
         const functionsArray = await toArrayAsync(mapped);
@@ -391,23 +326,20 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                         return { text: part.text };
                     }
                     if (isDefined(part.fileData)) {
-                        const file = assertDefinedPass(this.#fileService.getFileByUri(part.fileData.fileUri), 'File not found.');
+                        const file = assertDefinedPass(this.#fileService.getFileByUri(assertDefinedPass(part.fileData.fileUri, 'Missing file uri')), 'File not found.');
                         return { file: file.id };
                     }
                     if (isDefined(part.functionResponse)) {
-                        return { functionResult: { name: part.functionResponse.name, value: part.functionResponse.response } };
+                        return { functionResult: { name: assertDefinedPass(part.functionResponse.name, 'Missing function name'), value: part.functionResponse.response } };
                     }
                     if (isDefined(part.functionCall)) {
-                        return { functionCall: { name: part.functionCall.name, parameters: part.functionCall.args } };
+                        return { functionCall: { name: assertDefinedPass(part.functionCall.name, 'Missing function name'), parameters: part.functionCall.args } };
                     }
                     throw new NotSupportedError('Unsupported content part.');
                 })
-                    .filter(isNotNull)
+                    .filter(isNotNull),
         };
     }
-    getModel(model) {
-        return this.#genAI.getGenerativeModel({ model });
-    }
 };
 AiService = AiService_1 = __decorate([
     Singleton()
@@ -428,7 +360,7 @@ export function mergeGenerationStreamItems(items, schema) {
         },
         json() {
             if (isUndefined(schema)) {
-                return undefined;
+                return undefined; // eslint-disable-line @typescript-eslint/no-unsafe-return
             }
             if (isNull(this.text)) {
                 throw new Error('No text to parse available.');
@@ -442,6 +374,6 @@ export function mergeGenerationStreamItems(items, schema) {
             return functionCallParts;
         },
         finishReason: { value: items.at(-1).finishReason },
-        usage: { value: items.at(-1).usage }
+        usage: { value: items.at(-1).usage },
     });
 }

package/api/server/gateway.js

@@ -106,9 +106,9 @@ let ApiGateway = class ApiGateway {
                             hostname: '*',
                             port: '*',
                             search: '*',
-                            hash: '*'
+                            hash: '*',
                         }),
-                        endpoints: new Map()
+                        endpoints: new Map(),
                     };
                     this.apis.set(resource, resourceApis);
                 }
@@ -185,14 +185,14 @@ let ApiGateway = class ApiGateway {
             parameters: validatedParameters,
             body,
             request: context.request,
-            getToken: async () => this.requestTokenProvider.getToken(requestContext)
+            getToken: async () => this.requestTokenProvider.getToken(requestContext),
         };
         const result = await context.endpoint.implementation(requestContext);
         if (result instanceof HttpServerResponse) {
-            context.response.update(result); // eslint-disable-line require-atomic-updates
+            context.response.update(result);
         }
         else {
-            context.response.body = isUint8Array(result) ? { buffer: result } // eslint-disable-line require-atomic-updates
+            context.response.body = isUint8Array(result) ? { buffer: result }
                 : isBlob(result) ? { stream: result.stream() }
                     : isReadableStream(result) ? { stream: result }
                         : (result instanceof ServerSentEventsSource) ? { events: result }
@@ -204,7 +204,7 @@ let ApiGateway = class ApiGateway {
 };
 ApiGateway = __decorate([
     Singleton({
-        defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions
+        defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions,
     }),
     __param(1, ResolveArg('ApiGateway')),
     __param(2, InjectArg()),

package/authentication/authentication.api.js

@@ -9,8 +9,8 @@ export function getAuthenticationApiDefinition(additionalTokenPayloadSchema, aut
         resource: resource ?? 'auth',
         endpoints: {
             ...getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema, initSecretResetDataSchema),
-            ...additionalEndpoints
-        }
+            ...additionalEndpoints,
+        },
     });
 }
 export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetDataSchema) {
@@ -22,50 +22,50 @@ export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSc
             parameters: explicitObject({
                 subject: string(),
                 secret: string(),
-                data: authenticationDataSchema
+                data: authenticationDataSchema,
             }),
             result: tokenResultSchema,
             credentials: true,
             data: {
-                [dontWaitForValidToken]: true
-            }
+                [dontWaitForValidToken]: true,
+            },
         },
         refresh: {
             resource: 'refresh',
             method: 'POST',
             parameters: explicitObject({
-                data: authenticationDataSchema
+                data: authenticationDataSchema,
             }),
             result: tokenResultSchema,
             credentials: true,
             data: {
-                [dontWaitForValidToken]: true
-            }
+                [dontWaitForValidToken]: true,
+            },
         },
         impersonate: {
             resource: 'impersonate',
             method: 'POST',
             parameters: explicitObject({
                 subject: string(),
-                data: authenticationDataSchema
+                data: authenticationDataSchema,
             }),
             result: tokenResultSchema,
             credentials: true,
             data: {
-                [dontWaitForValidToken]: true
-            }
+                [dontWaitForValidToken]: true,
+            },
         },
         unimpersonate: {
             resource: 'unimpersonate',
             method: 'POST',
             parameters: explicitObject({
-                data: authenticationDataSchema
+                data: authenticationDataSchema,
             }),
             result: tokenResultSchema,
             credentials: true,
             data: {
-                [dontWaitForValidToken]: true
-            }
+                [dontWaitForValidToken]: true,
+            },
         },
         endSession: {
             resource: 'end-session',
@@ -73,38 +73,38 @@ export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSc
             result: literal('ok'),
             credentials: true,
             data: {
-                [dontWaitForValidToken]: true
-            }
+                [dontWaitForValidToken]: true,
+            },
         },
         initSecretReset: {
             resource: 'secret/init-reset',
             method: 'POST',
             parameters: explicitObject({
                 subject: string(),
-                data: additionalInitSecretResetDataSchema
+                data: additionalInitSecretResetDataSchema,
             }),
-            result: literal('ok')
+            result: literal('ok'),
         },
         resetSecret: {
             resource: 'secret/reset',
             method: 'POST',
             parameters: object({
                 token: string(),
-                newSecret: string()
+                newSecret: string(),
             }),
-            result: literal('ok')
+            result: literal('ok'),
         },
         checkSecret: {
             resource: 'secret/check',
             method: 'POST',
             parameters: object({
-                secret: string()
+                secret: string(),
             }),
-            result: SecretCheckResult
+            result: SecretCheckResult,
         },
         timestamp: {
             resource: 'timestamp',
-            result: number()
-        }
+            result: number(),
+        },
     };
 }