@tstdl/base 0.92.15 → 0.92.17

package/ai/ai-session.d.ts

@@ -1,18 +1,11 @@
-import type { SchemaTestable } from '../schema/index.js';
-import type { Enumeration, OneOrMany, TypedOmit } from '../types.js';
-import type { AiService, AnalyzeContentResult, ClassificationResult, SpecializedGenerationResult } from './ai.service.js';
-import type { Content, ContentPart, GenerationOptions, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
+import type { OneOrMany } from '../types.js';
+import type { AiService, CallFunctionsOptions, SpecializedGenerationResult } from './ai.service.js';
+import type { Content, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
 export declare class AiSession {
     #private;
     readonly contents: Content[];
     constructor(aiService: AiService);
     addContent(content: OneOrMany<Content>): void;
-    analyzeContent<T extends Enumeration>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & {
-        targetLanguage?: string;
-        maximumNumberOfTags?: number;
-    }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
-    classify<T extends Enumeration>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<ClassificationResult<T>>>;
-    extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;
-    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, content: Content | [Content, ...Content[]], options?: Pick<GenerationRequest, 'model' | 'systemInstruction'> & GenerationOptions): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
-    generate(content: Content | [Content, ...Content[]], request?: TypedOmit<GenerationRequest, 'contents'>): Promise<GenerationResult>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    generate(request: GenerationRequest): Promise<GenerationResult>;
 }

package/ai/ai-session.js

@@ -8,35 +8,14 @@ export class AiSession {
     addContent(content) {
         this.contents.push(...toArray(content));
     }
-    async analyzeContent(parts, types, options) {
-        const newContents = this.#aiService.getAnalyzeContentConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.analyzeContent(parts, types, options);
+    async callFunctions(options) {
+        this.contents.push(...toArray(options.contents));
+        const result = await this.#aiService.callFunctions({ ...options, contents: this.contents });
         this.contents.push(result.raw.content);
         return result;
     }
-    async classify(parts, types, options) {
-        const newContents = this.#aiService.getExtractDataConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.classify(parts, types, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async extractData(parts, schema, options) {
-        const newContents = this.#aiService.getExtractDataConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.extractData(parts, schema, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async callFunctions(functions, content, options) {
-        this.contents.push(...toArray(content));
-        const result = await this.#aiService.callFunctions(functions, this.contents, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async generate(content, request) {
-        this.contents.push(...toArray(content));
+    async generate(request) {
+        this.contents.push(...toArray(request.contents));
         const result = await this.#aiService.generate({ ...request, contents: this.contents });
         this.contents.push(result.content);
         return result;

package/ai/ai.service.d.ts

@@ -1,4 +1,3 @@
-import '../polyfills.js';
 import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
 import { OneOrMany, SchemaTestable } from '../schema/index.js';
 import { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
@@ -24,6 +23,9 @@ export type AnalyzeContentResult<T extends EnumerationType> = {
     documentTypes: ClassificationResult<T>[];
     tags: string[];
 };
+export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction'> & GenerationOptions & {
+    functions: T;
+};
 export declare class AiService implements Resolvable<AiServiceArgument> {
     #private;
     readonly defaultModel: AiModel;
@@ -40,7 +42,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
         maximumNumberOfTags?: number;
     }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
     getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
-    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, contents: Content[], options?: Pick<GenerationRequest, 'model' | 'systemInstruction'> & GenerationOptions): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
     generate(request: GenerationRequest): Promise<GenerationResult>;
     private convertContents;
     private convertContent;

package/ai/ai.service.js

@@ -4,8 +4,7 @@ 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;
 };
-import '../polyfills.js';
-import { FunctionCallingMode as GoogleFunctionCallingMode, GoogleGenerativeAI } from '@google/generative-ai';
+import { FinishReason, FunctionCallingMode as GoogleFunctionCallingMode, 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';
@@ -136,22 +135,21 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 ]
             }];
     }
-    async callFunctions(functions, contents, options) {
+    async callFunctions(options) {
         const generation = await this.generate({
-            model: options?.model,
+            model: options.model,
             generationOptions: {
-                maxOutputTokens: 4096,
                 temperature: 0.5,
                 ...options
             },
-            systemInstruction: options?.systemInstruction,
-            functions,
+            systemInstruction: options.systemInstruction,
+            functions: options.functions,
             functionCallingMode: 'force',
-            contents
+            contents: options.contents
         });
         const result = [];
         for (const call of generation.functionCalls) {
-            const fn = assertDefinedPass(functions[call.name], 'Function in response not declared.');
+            const fn = assertDefinedPass(options.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 });
@@ -162,7 +160,6 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         };
     }
     async generate(request) {
-        const googleContent = this.convertContents(request.contents);
         const googleFunctionDeclarations = isDefined(request.functions) ? this.convertFunctions(request.functions) : undefined;
         const generationConfig = {
             maxOutputTokens: request.generationOptions?.maxOutputTokens,
@@ -174,31 +171,61 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             presencePenalty: request.generationOptions?.presencePenalty,
             frequencyPenalty: request.generationOptions?.frequencyPenalty
         };
-        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: functionCallingModeMap[request.functionCallingMode] } }
-                : undefined,
-            contents: googleContent
-        });
-        const content = this.convertGoogleContent(generation.response.candidates.at(0).content);
+        const googleContent = this.convertContents(request.contents);
+        const generationContent = { role: 'model', parts: [] };
+        const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? 8192;
+        let iterations = 0;
+        let totalPromptTokens = 0;
+        let totalOutputTokens = 0;
+        let candidate;
+        while (totalOutputTokens < maxTotalOutputTokens) {
+            const generation = await this.getModel(request.model ?? this.defaultModel).generateContent({
+                generationConfig: {
+                    ...generationConfig,
+                    maxOutputTokens: Math.min(8192, maxTotalOutputTokens - totalOutputTokens)
+                },
+                systemInstruction: request.systemInstruction,
+                tools: isDefined(googleFunctionDeclarations) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
+                toolConfig: isDefined(request.functionCallingMode)
+                    ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
+                    : undefined,
+                contents: googleContent
+            });
+            iterations++;
+            candidate = generation.response.candidates.at(0);
+            // On first generation only
+            if (generationContent.parts.length == 0) {
+                googleContent.push(generationContent);
+            }
+            generationContent.parts.push(...candidate.content.parts);
+            totalPromptTokens += generation.response.usageMetadata.promptTokenCount;
+            totalOutputTokens += generation.response.usageMetadata.candidatesTokenCount;
+            if (candidate.finishReason != FinishReason.MAX_TOKENS) {
+                break;
+            }
+        }
+        const content = this.convertGoogleContent(generationContent);
         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,
+            finishReason: candidate.finishReason == FinishReason.MAX_TOKENS
+                ? 'maxTokens'
+                : candidate.finishReason == FinishReason.STOP
+                    ? 'stop'
+                    : 'unknown',
             usage: {
-                prompt: generation.response.usageMetadata.promptTokenCount,
-                output: generation.response.usageMetadata.candidatesTokenCount,
-                total: generation.response.usageMetadata.totalTokenCount
+                iterations,
+                prompt: totalPromptTokens,
+                output: totalOutputTokens,
+                total: totalPromptTokens + totalOutputTokens
             }
         };
     }
     convertContents(contents) {
-        return contents.map((content) => this.convertContent(content));
+        return toArray(contents).map((content) => this.convertContent(content));
     }
     convertContent(content) {
         return {

package/ai/types.d.ts

@@ -49,6 +49,7 @@ export type Content = {
     parts: readonly ContentPart[];
 };
 export type FunctionCallingMode = 'auto' | 'force' | 'none';
+export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
 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;
@@ -61,13 +62,14 @@ export type GenerationOptions = {
 export type GenerationRequest = {
     model?: AiModel;
     systemInstruction?: string;
-    contents: readonly Content[];
+    contents: Content | readonly Content[];
     functions?: SchemaFunctionDeclarations;
     functionCallingMode?: FunctionCallingMode;
     generationSchema?: SchemaTestable;
     generationOptions?: GenerationOptions;
 };
 export type GenerationUsage = {
+    iterations: number;
     prompt: number;
     output: number;
     total: number;
@@ -76,6 +78,7 @@ export type GenerationResult = {
     content: Content;
     text: string | null;
     functionCalls: FunctionCall[];
+    finishReason: FinishReason;
     usage: GenerationUsage;
 };
 export declare function declareFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;

package/authentication/server/authentication.service.d.ts

@@ -1,8 +1,7 @@
-import type { AfterResolve } from '../../injector/index.js';
-import { afterResolve } from '../../injector/index.js';
-import type { Record } from '../../types.js';
+import { type AfterResolve, afterResolve } from '../../injector/index.js';
+import type { BinaryData, Record } from '../../types.js';
 import type { RefreshToken, SecretCheckResult, SecretResetToken, Token } from '../models/index.js';
-import type { SecretTestResult } from './authentication-secret-requirements.validator.js';
+import { type SecretTestResult } from './authentication-secret-requirements.validator.js';
 export type CreateTokenData<AdditionalTokenPayload extends Record> = {
     tokenVersion?: number;
     jwtId?: string;

package/authentication/server/helper.d.ts

@@ -1,5 +1,5 @@
 import type { HttpServerRequest } from '../../http/server/index.js';
-import type { Record } from '../../types.js';
+import type { BinaryData, Record } from '../../types.js';
 import type { RefreshToken, SecretResetToken, Token } from '../models/index.js';
 /**
  *

package/file/mime-type.js

@@ -1,7 +1,5 @@
-import { dynamicImport } from '../import.js';
-import { decodeTextStream } from '../utils/encoding.js';
-import { readTextStream } from '../utils/stream/stream-reader.js';
-import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { spawnCommand } from '../process/spawn.js';
+import { isDefined, isString } from '../utils/type-guards.js';
 import { mimeTypesMap } from './mime-types.js';
 export async function getMimeType(file) {
     const path = isString(file) ? file : '-';
@@ -12,22 +10,10 @@ export function getMimeTypeExtensions(mimeType) {
     return mimeTypesMap.get(mimeType) ?? [];
 }
 async function spawnFileCommand(args, file) {
-    const { spawn } = await dynamicImport('node:child_process');
-    const { Readable, Writable } = await dynamicImport('node:stream');
-    const process = spawn('file', args, { stdio: 'pipe' });
-    const stdin = Writable.toWeb(process.stdin);
-    const stdout = Readable.toWeb(process.stdout).pipeThrough(decodeTextStream());
-    if (isReadableStream(file)) {
-        await file.pipeTo(stdin);
-    }
-    else if (isUint8Array(file)) {
-        const writer = stdin.getWriter();
-        try {
-            await writer.write(file);
-            await writer.close();
-        }
-        catch { /* File command closes stream as soon as it has the required data */ }
-    }
-    const output = await readTextStream(stdout);
-    return output.trim();
+    const process = await spawnCommand('file', args, { stdinPipeOptions: { preventCancel: true } });
+    const [stdout] = await Promise.all([
+        process.readOutput(),
+        isDefined(file) ? process.write(file) : undefined
+    ]);
+    return stdout.trim();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.15",
+  "version": "0.92.17",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -144,7 +144,7 @@
     "tsx": "^4.19.2",
     "typedoc": "0.27",
     "typedoc-plugin-missing-exports": "3.1",
-    "typescript": "5.6"
+    "typescript": "5.7"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.17",

package/pdf/index.d.ts

@@ -1 +1,2 @@
 export * from './pdf.service.js';
+export * from './utils.js';

package/pdf/index.js

@@ -1 +1,2 @@
 export * from './pdf.service.js';
+export * from './utils.js';

package/pdf/utils.d.ts

@@ -0,0 +1 @@
+export declare function getPdfPageCount(file: string): Promise<number>;

package/pdf/utils.js

@@ -0,0 +1,11 @@
+import { spawnCommand } from '../process/spawn.js';
+export async function getPdfPageCount(file) {
+    const process = await spawnCommand('qpdf', ['--show-npages', file]);
+    const { code } = await process.wait();
+    if (code != 0) {
+        const errorOutput = await process.readError();
+        throw new Error(errorOutput.trim());
+    }
+    const output = await process.readOutput();
+    return Number(output);
+}

package/process/spawn.d.ts

@@ -5,11 +5,13 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     write(chunk: ReadableStream<Uint8Array> | Uint8Array | string): Promise<void>;
     readOutputBytes(): Promise<Uint8Array>;
     readOutput(): Promise<string>;
-    readErrBytes(): Promise<Uint8Array>;
-    readErr(): Promise<string>;
+    readErrorBytes(): Promise<Uint8Array>;
+    readError(): Promise<string>;
     wait(): Promise<{
         code: number | null;
         signal: string | null;
     }>;
 };
-export declare function spawnCommand(command: string, args: string[]): Promise<SpawnCommandResult>;
+export declare function spawnCommand(command: string, args?: string[], options?: {
+    stdinPipeOptions?: StreamPipeOptions;
+}): Promise<SpawnCommandResult>;

package/process/spawn.js

@@ -3,7 +3,7 @@ import { decodeTextStream, encodeUtf8Stream } from '../utils/encoding.js';
 import { readBinaryStream, readTextStream } from '../utils/stream/stream-reader.js';
 import { toReadableStream } from '../utils/stream/to-readable-stream.js';
 import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
-export async function spawnCommand(command, args) {
+export async function spawnCommand(command, args, options) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
     const process = spawn(command, args, { stdio: 'pipe' });
@@ -16,13 +16,13 @@ export async function spawnCommand(command, args) {
     const stderr = Readable.toWeb(process.stderr);
     async function write(data) {
         if (isReadableStream(data)) {
-            await data.pipeTo(writable);
+            await data.pipeTo(writable, options?.stdinPipeOptions);
         }
         else if (isUint8Array(data)) {
-            await toReadableStream(data).pipeTo(writable);
+            await toReadableStream(data).pipeTo(writable, options?.stdinPipeOptions);
         }
         else if (isString(data)) {
-            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable);
+            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable, options?.stdinPipeOptions);
         }
     }
     async function readOutputBytes() {
@@ -46,10 +46,10 @@ export async function spawnCommand(command, args) {
         write,
         readOutputBytes,
         readOutput,
-        readErrBytes,
-        readErr,
+        readErrorBytes: readErrBytes,
+        readError: readErr,
         async wait() {
             return signalPromise;
-        },
+        }
     };
 }

package/rpc/rpc.d.ts

@@ -1,4 +1,4 @@
-import type { SerializationOptions } from '../serializer/index.js';
+import { type SerializationOptions } from '../serializer/index.js';
 import type { RpcRemote, RpcRemoteInput } from './model.js';
 import type { RpcAdapter } from './rpc.adapter.js';
 import type { RpcEndpoint } from './rpc.endpoint.js';

package/rpc/rpc.js

@@ -137,7 +137,8 @@ function createProxy(channel, path = []) {
             handlers[method] = deferThrow(() => new NotSupportedError(`${method} not supported on rpc proxies.`));
         }
     }
-    return new Proxy(RpcProxy, handlers);
+    proxy = new Proxy(RpcProxy, handlers);
+    return proxy;
 }
 function exposeObject(object, channel) {
     const { endpoint } = channel;

package/serializer/handlers/binary.d.ts

@@ -4,7 +4,7 @@ interface TypedArrayConstructor {
     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): TypedArray;
 }
 export declare function serializeArrayBuffer(buffer: ArrayBuffer): string;
-export declare function deserializeArrayBuffer(data: string): ArrayBuffer;
+export declare function deserializeArrayBuffer(data: string): ArrayBufferLike;
 export declare function serializeTypedArray(array: TypedArray): string;
 export declare function getTypedArrayDeserializer(constructor: TypedArrayConstructor): (data: string) => TypedArray;
 export declare function serializeBuffer(buffer: Buffer): string;

package/signals/operators/derive-async.js

@@ -1,4 +1,4 @@
-import { Subject, concatAll, exhaustAll, isObservable, mergeAll, of, switchAll, takeUntil } from 'rxjs';
+import { Subject, concatAll, exhaustAll, from, isObservable, mergeAll, of, switchAll, takeUntil } from 'rxjs';
 import { registerFinalization } from '../../memory/finalization.js';
 import { isPromise } from '../../utils/type-guards.js';
 import { computed, effect, toSignal, untracked } from '../api.js';
@@ -9,15 +9,23 @@ const operatorMap = {
     switch: switchAll,
 };
 export function deriveAsync(source, options) {
-    const outerSource = computed(source);
+    const outerSource = computed(() => {
+        const rawSource = source();
+        if (isPromise(rawSource)) {
+            return from(rawSource);
+        }
+        if (isObservable(rawSource)) {
+            return rawSource;
+        }
+        return of(rawSource);
+    });
     const source$ = new Subject();
     const destroy$ = new Subject();
     const operator = operatorMap[options?.behavior ?? 'switch'];
     const valueSource$ = source$.pipe(operator(), takeUntil(destroy$));
     const result = toSignal(valueSource$, options);
     const effectRef = effect(() => {
-        const rawSource = outerSource();
-        const observableInput = (isPromise(rawSource) || isObservable(rawSource)) ? rawSource : of(rawSource);
+        const observableInput = outerSource();
         untracked(() => source$.next(observableInput));
     });
     registerFinalization(result, () => {

package/utils/binary.d.ts

@@ -4,14 +4,13 @@ import type { BinaryData, Type } from '../types.js';
  * @param data data to get ArrayBuffer from
  * @param clone force cloning (might still clone if datas underlying buffer is larger than its view)
  */
-export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBuffer;
+export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBufferLike;
 /**
- * eslint-disable-next-line @typescript-eslint/no-shadow
- * convert to Uint8Array
+ * Convert to Uint8Array
  * @param data binary data
  * @param clone whether to clone buffer or not
  */
 export declare function toUint8Array(data: BinaryData, clone?: boolean): Uint8Array;
-export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBuffer;
+export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBufferLike;
 export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: T[], totalLength?: number): T;
 export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: ArrayBufferView[], targetType: Type<T, [ArrayBufferLike, number, number]>, totalLength?: number): T;

package/utils/binary.js

@@ -16,8 +16,7 @@ export function toArrayBuffer(data, clone = false) {
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
 }
 /**
- * eslint-disable-next-line @typescript-eslint/no-shadow
- * convert to Uint8Array
+ * Convert to Uint8Array
  * @param data binary data
  * @param clone whether to clone buffer or not
  */

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
@@ -6,19 +6,7 @@ export type AssertFunction<T> = <U extends T = T>(value: any, message?: Assertio
 export type AssertNotFunction<T> = <V>(value: V, message?: AssertionMessage) => asserts value is Exclude<V, T>;
 export type AssertPassFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => U;
 export type AssertNotPassFunction<T> = <V>(value: V, message?: AssertionMessage) => Exclude<V, T>;
-export type GuardFunctions<N extends string, T> = {
-    [P in `is${PascalCase<N>}`]: IsFunction<T>;
-} & {
-    [P in `isNot${PascalCase<N>}`]: IsNotFunction<T>;
-} & {
-    [P in `assert${PascalCase<N>}`]: AssertFunction<T>;
-} & {
-    [P in `assertNot${PascalCase<N>}`]: AssertNotFunction<T>;
-} & {
-    [P in `assert${PascalCase<N>}Pass`]: AssertPassFunction<T>;
-} & {
-    [P in `assertNot${PascalCase<N>}Pass`]: AssertNotPassFunction<T>;
-};
+export type GuardFunctions<N extends string, T> = Record<`is${PascalCase<N>}`, IsFunction<T>> & Record<`isNot${PascalCase<N>}`, IsNotFunction<T>> & Record<`assert${PascalCase<N>}`, AssertFunction<T>> & Record<`assertNot${PascalCase<N>}`, AssertNotFunction<T>> & Record<`assert${PascalCase<N>}Pass`, AssertPassFunction<T>> & Record<`assertNot${PascalCase<N>}Pass`, AssertNotPassFunction<T>>;
 export declare function assert(condition: boolean, message?: AssertionMessage): asserts condition;
 export declare function assertNot(condition: boolean, message?: AssertionMessage): asserts condition;
 export declare function createGuards<N extends string, T>(name: N, testFn: (value: any) => value is T): GuardFunctions<N, T>;