@tstdl/base 0.92.123 → 0.92.124

package/utils/stream/stream-reader.js

@@ -14,51 +14,87 @@ export async function readBinaryStream(iterableOrStream, { length, onLengthExcee
         : getReadableStreamFromIterable(iterableOrStream);
     if (isDefined(length)) {
         const reader = stream.getReader({ mode: 'byob' });
-        let buffer = new ArrayBuffer(length + 1);
+        let buffer = new ArrayBuffer(length + 1); // To read one extra byte for exceed detection
         let bytesRead = 0;
-        while (true) {
-            const result = await reader.read(new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead));
-            buffer = result.value.buffer;
-            bytesRead += result.value.byteLength;
-            if (result.done) {
-                break;
+        let shouldCancelReaderAtEnd = true;
+        try {
+            while (true) {
+                const view = new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead);
+                const result = await reader.read(view);
+                buffer = result.value.buffer;
+                bytesRead += result.value.byteLength;
+                if (result.done) {
+                    break;
+                }
+                // Check if we have read more data than the specified 'length'.
+                // This implies bytesRead is at least length + 1.
+                if (bytesRead > length) {
+                    switch (onLengthExceed) {
+                        case 'error':
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            throw new MaxBytesExceededError('Size of stream is greater than provided length.');
+                        case 'close':
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            break;
+                        case 'leave-open':
+                            reader.releaseLock();
+                            shouldCancelReaderAtEnd = false;
+                            break;
+                        default:
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            throw new NotSupportedError(`Action ${onLengthExceed} not supported.`);
+                    }
+                    break;
+                }
             }
-            if (bytesRead > length) {
-                switch (onLengthExceed) {
+            if (bytesRead < length) { // Stream ended before specified length was read
+                switch (onLengthSubceed) {
                     case 'error':
-                        await reader.cancel();
-                        throw new MaxBytesExceededError('Size of stream is greater than provided length.');
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
+                        throw new BadRequestError('Size of stream was less than provided length.');
                     case 'close':
-                        await reader.cancel();
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
                         break;
                     case 'leave-open':
-                        reader.releaseLock();
+                        if (shouldCancelReaderAtEnd) {
+                            reader.releaseLock();
+                        }
+                        shouldCancelReaderAtEnd = false;
                         break;
                     default:
-                        throw new NotSupportedError(`Action ${onLengthExceed} not supported.`);
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
+                        throw new NotSupportedError(`Action ${onLengthSubceed} not supported.`);
                 }
             }
-            if (bytesRead == length + 1) {
-                break;
+            if (shouldCancelReaderAtEnd) {
+                await reader.cancel();
             }
+            return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
         }
-        if (bytesRead < length) {
-            switch (onLengthSubceed) {
-                case 'error':
-                    await reader.cancel();
-                    throw new BadRequestError('Size of stream was less than provided length.');
-                case 'close':
-                    await reader.cancel();
-                    break;
-                case 'leave-open':
-                    reader.releaseLock();
-                    break;
-                default:
-                    throw new NotSupportedError(`Action ${onLengthSubceed} not supported.`);
+        catch (error) {
+            // If an error occurred (e.g., network, or thrown by logic above)
+            // and reader hasn't been handled, try to cancel it.
+            // This is a "best effort" cleanup.
+            if (shouldCancelReaderAtEnd && reader) {
+                try {
+                    await reader.cancel(error); // Pass the error reason
+                }
+                catch { /* ignore */ }
             }
+            throw error;
         }
-        await reader.cancel();
-        return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
     }
     let totalLength = 0;
     const reader = stream.getReader();
@@ -66,6 +102,10 @@ export async function readBinaryStream(iterableOrStream, { length, onLengthExcee
     while (true) {
         const result = await reader.read();
         if (result.done) {
+            if (isDefined(result.value)) {
+                views.push(result.value);
+                totalLength += result.value.byteLength;
+            }
             break;
         }
         views.push(result.value);

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

@@ -1,27 +0,0 @@
-import '../polyfills.js';
-import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import type { AiServiceOptions } from './ai.service.js';
-import type { FileContentPart, FileInput } from './types.js';
-export type AiFileServiceOptions = Pick<AiServiceOptions, 'apiKey' | 'keyFile' | 'vertex'>;
-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 getBucket;
-    private waitForFileActive;
-    private waitForFilesActive;
-}
-export {};

package/ai/ai-session.d.ts

@@ -1,11 +0,0 @@
-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;
-    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
-    generate(request: GenerationRequest): Promise<GenerationResult>;
-}

package/ai/ai.service.d.ts

@@ -1,68 +0,0 @@
-import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import { type OneOrMany, type SchemaTestable } from '../schema/index.js';
-import type { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
-import { AiSession } from './ai-session.js';
-import { type AiModel, type Content, type ContentPart, type FileContentPart, type FileInput, type FunctionResultContentPart, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
-export type SpecializedGenerationResult<T> = {
-    result: T;
-    raw: GenerationResult;
-};
-export type SpecializedGenerationResultGenerator<T> = AsyncGenerator<T> & {
-    raw: Promise<GenerationResult>;
-};
-export declare class AiServiceOptions {
-    apiKey?: string;
-    keyFile?: string;
-    vertex?: {
-        project: string;
-        location: string;
-        bucket?: string;
-    };
-    defaultModel?: AiModel;
-}
-export type AiServiceArgument = AiServiceOptions;
-export type ClassificationResult<T extends EnumerationType> = {
-    types: {
-        type: EnumerationValue<T>;
-        confidence: 'high' | 'medium' | 'low';
-    }[] | null;
-};
-export type AnalyzeContentResult<T extends EnumerationType> = {
-    content: string[];
-    documentTypes: ClassificationResult<T>[];
-    tags: string[];
-};
-export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction' | 'functionCallingMode'> & GenerationOptions & {
-    functions: T;
-};
-export declare class AiService implements Resolvable<AiServiceArgument> {
-    #private;
-    readonly defaultModel: AiModel;
-    readonly [resolveArgumentType]: AiServiceArgument;
-    createSession(): AiSession;
-    processFile(fileInput: FileInput): Promise<FileContentPart>;
-    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
-    getFileById(id: string): FileContentPart;
-    classify<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<ClassificationResult<T>>>;
-    getClassifyContents(parts: OneOrMany<ContentPart>): Content[];
-    extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;
-    getExtractDataConents(parts: OneOrMany<ContentPart>): Content[];
-    analyzeContent<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & {
-        targetLanguage?: string;
-        maximumNumberOfTags?: number;
-    }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
-    getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
-    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]> & {
-        getFunctionResultContentParts: () => FunctionResultContentPart[];
-    }>;
-    callFunctionsStream<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): SpecializedGenerationResultGenerator<SchemaFunctionDeclarationsResult<T>>;
-    generate<S>(request: GenerationRequest<S>): Promise<GenerationResult<S>>;
-    generateStream<S>(request: GenerationRequest<S>): AsyncGenerator<GenerationResult<S>>;
-    private _callFunctionsStream;
-    private convertContents;
-    private convertContent;
-    private convertFunctions;
-    private convertGoogleContent;
-    private getModel;
-}
-export declare function mergeGenerationStreamItems<S>(items: GenerationResult<S>[], schema?: SchemaTestable<S>): GenerationResult<S>;

package/ai/functions.d.ts

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

package/ai/types.d.ts

@@ -1,89 +0,0 @@
-import type { LiteralUnion } from 'type-fest';
-import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { Record, UndefinableJsonObject } from '../types.js';
-import type { ResolvedValueOrProvider, ValueOrAsyncProvider } from '../utils/value-or-provider.js';
-export type FileInput = {
-    path: string;
-    mimeType: string;
-} | Blob;
-export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
-export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
-    description: string;
-    parameters?: ValueOrAsyncProvider<ObjectSchema<T>>;
-    enabled?: ValueOrAsyncProvider<boolean>;
-};
-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<NonNullable<ResolvedValueOrProvider<T[P]['parameters']>>>;
-        handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
-        getFunctionResultContentPart: () => FunctionResultContentPart;
-    };
-}[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: ContentRole;
-    parts: readonly ContentPart[];
-};
-export type FunctionCallingMode = 'auto' | 'force' | 'none';
-export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
-export type AiModel = LiteralUnion<'gemini-2.0-flash' | 'gemini-2.0-flash-lite' | 'gemini-2.0-pro-exp-02-05' | 'gemini-2.0-flash-thinking-exp-01-21', string>;
-export type GenerationOptions = {
-    maxOutputTokens?: number;
-    temperature?: number;
-    topP?: number;
-    topK?: number;
-    frequencyPenalty?: number;
-};
-export type GenerationRequest<S = unknown> = {
-    model?: AiModel;
-    systemInstruction?: string;
-    contents: Content | readonly Content[];
-    functions?: SchemaFunctionDeclarations;
-    functionCallingMode?: FunctionCallingMode;
-    generationSchema?: SchemaTestable<S>;
-    generationOptions?: GenerationOptions;
-};
-export type GenerationUsage = {
-    iterations: number;
-    prompt: number;
-    output: number;
-    total: number;
-};
-export type GenerationResult<S = unknown> = {
-    content: Content;
-    text: string | null;
-    json: S;
-    functionCalls: FunctionCall[];
-    finishReason: FinishReason;
-    usage: GenerationUsage;
-};
-export declare function defineFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
-export declare function defineFunction<P extends Record, T extends SchemaFunctionDeclaration<P>>(declaration: T & Pick<SchemaFunctionDeclaration<P>, 'parameters'>): T;
-export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;

package/api/client/client.d.ts

@@ -1,23 +0,0 @@
-import { HttpClient, type HttpClientOptions } from '../../http/client/index.js';
-import { type Resolvable } from '../../injector/interfaces.js';
-import type { Type } from '../../types.js';
-import { type ApiClientImplementation, type ApiDefinition, type ApiEndpointDefinition } from '../types.js';
-export type ApiClient<T extends ApiDefinition> = Type<ApiClientImplementation<T> & Resolvable<HttpClient | HttpClientOptions>, [httpClientOrOptions?: HttpClient | HttpClientOptions]>;
-export type ClientOptions = {
-    /**
-     * Url prefix
-     * @default `api/`
-     */
-    prefix?: string | null;
-    defaultHttpClientOptions?: HttpClientOptions | null;
-};
-export type ApiClientHttpRequestContext = {
-    endpoint: ApiEndpointDefinition;
-};
-export declare const httpClientSymbol: unique symbol;
-export declare const apiDefinitionSymbol: unique symbol;
-export declare const defaultOptions: ClientOptions;
-export declare function setDefaultApiClientOptions(options: ClientOptions): void;
-export declare function compileClient<T extends ApiDefinition>(definition: T, options?: ClientOptions): ApiClient<T>;
-export declare function getHttpClientOfApiClient(apiClient: any): HttpClient;
-export declare function getApiDefinitionOfApiClient(apiClient: any): ApiDefinition;

package/api/default-error-handlers.d.ts

@@ -1,14 +0,0 @@
-import { SchemaError } from '../schema/index.js';
-import type { OneOrMany } from '../types.js';
-export type SerializedSchemaError = {
-    path: string;
-    details?: any;
-    inner?: OneOrMany<SerializedInnerSchemaError>;
-};
-export type SerializedInnerSchemaError = SerializedSchemaError & {
-    message: string;
-};
-export declare function serializeSchemaError(error: SchemaError): SerializedSchemaError;
-export declare function serializeInnerSchemaError(error: SchemaError): SerializedInnerSchemaError;
-export declare function deserializeSchemaError(message: string, data: SerializedSchemaError): SchemaError;
-export declare function deserializeInnerSchemaError(data: SerializedInnerSchemaError): SchemaError;

package/api/server/api-controller.d.ts

@@ -1,11 +0,0 @@
-import { type InjectableOptionsWithoutLifecycle } from '../../injector/decorators.js';
-import type { Constructor, Type } from '../../types.js';
-import type { ApiController, ApiDefinition } from '../types.js';
-type ApiDefinitionProvider = () => ApiDefinition;
-export declare const apiControllerDefinition: unique symbol;
-export declare function getApiControllerDefinition(controller: Type | ApiController): ApiDefinition;
-export declare function isApiController(controller: Type): boolean;
-export declare function ensureApiController(controller: Type): void;
-export declare function apiController<T = Type<ApiController>, A = any>(definition: ApiDefinition | ApiDefinitionProvider, injectableOptions?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-export declare function implementApi<T extends ApiDefinition>(definition: T, implementation: ApiController<T>): Constructor<ApiController<T>>;
-export {};

package/api/server/error-handler.d.ts

@@ -1,4 +0,0 @@
-import type { HttpServerResponse } from '../../http/server/index.js';
-import type { Logger } from '../../logger/index.js';
-import type { Type } from '../../types.js';
-export declare function handleApiError(error: unknown, response: HttpServerResponse, supressedErrors: Set<Type<Error>>, logger: Logger): HttpServerResponse;

package/api/server/gateway.d.ts

@@ -1,77 +0,0 @@
-import 'urlpattern-polyfill';
-import type { HttpServerRequestContext } from '../../http/server/http-server.js';
-import { HttpServerResponse, type HttpServerRequest } from '../../http/server/index.js';
-import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import type { Type } from '../../types.js';
-import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../utils/middleware.js';
-import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
-import { ApiRequestTokenProvider } from './api-request-token.provider.js';
-import type { CorsMiddlewareOptions } from './middlewares/cors.middleware.js';
-export type ApiGatewayMiddlewareContext = {
-    readonly api: ApiItem;
-    /** can be undefined if used before allowedMethods middleware */
-    readonly endpoint: GatewayEndpoint;
-    readonly resourcePatternResult: URLPatternResult;
-    readonly request: HttpServerRequest;
-    readonly response: HttpServerResponse;
-};
-export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext;
-export type ApiGatewayMiddleware = AsyncMiddleware<ApiGatewayMiddlewareContext>;
-export declare abstract class ApiGatewayOptions {
-    /**
-     * Api prefix. Pass `null` to disable prefix.
-     * @default api
-     */
-    prefix?: string | null;
-    /** Initial middlewares */
-    middlewares?: ApiGatewayMiddleware[];
-    /** Errors to supress in log output */
-    supressedErrors?: Type<Error>[];
-    /** Cors middleware options */
-    cors?: CorsMiddlewareOptions;
-    /**
-     * Maximum size of request body. Useful to prevent harmful requests.
-     * @default 10 MB
-     */
-    defaultMaxBytes?: number;
-}
-export type GatewayEndpoint = {
-    definition: ApiEndpointDefinition;
-    implementation: ApiEndpointServerImplementation;
-};
-export type ApiItem = {
-    resource: string;
-    pattern: URLPattern;
-    endpoints: Map<ApiEndpointMethod, GatewayEndpoint>;
-};
-export type EndpointMetadataBodyType = 'none' | 'text' | 'json' | 'buffer' | 'stream';
-export type ApiGatewayArgument = ApiGatewayOptions;
-export type ApiMetadata = {
-    api: ApiItem;
-    patternResult: URLPatternResult;
-};
-/**
- * router for {@link ApiTransport} requests to {@link ApiImplementation}
- * @todo error handling (standardized format, serialization etc.)
- */
-export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
-    private readonly requestTokenProvider;
-    private readonly logger;
-    private readonly prefix;
-    private readonly apis;
-    private readonly middlewares;
-    private readonly supressedErrors;
-    private readonly catchErrorMiddleware;
-    private readonly options;
-    private composedMiddleware;
-    readonly [resolveArgumentType]: ApiGatewayOptions;
-    constructor(requestTokenProvider: ApiRequestTokenProvider, logger: Logger, options?: ApiGatewayOptions);
-    addMiddleware(middleware: ApiGatewayMiddleware): void;
-    supressErrors(...errorTypes: Type<Error>[]): void;
-    registerApi<T extends ApiDefinition>(definition: ApiDefinition, implementation: ApiController<T>): void;
-    handleHttpServerRequestContext({ request, respond, close }: HttpServerRequestContext): Promise<void>;
-    getApiMetadata(resource: URL): ApiMetadata;
-    private updateMiddleware;
-    private endpointMiddleware;
-}

package/api/server/middlewares/catch-error.middleware.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from '../../../logger/index.js';
-import type { Type } from '../../../types.js';
-import type { ApiGatewayMiddleware } from '../gateway.js';
-export declare function getCatchErrorMiddleware(supressedErrors: Set<Type<Error>>, logger: Logger): ApiGatewayMiddleware;

package/api/server/middlewares/cors.middleware.d.ts

@@ -1,6 +0,0 @@
-import type { ApiEndpointDefinitionCors } from '../../../api/types.js';
-import type { ApiGatewayMiddleware } from '../gateway.js';
-export type CorsMiddlewareOptions = {
-    default?: ApiEndpointDefinitionCors;
-};
-export declare function corsMiddleware(options?: CorsMiddlewareOptions): ApiGatewayMiddleware;

package/api/server/module.d.ts

@@ -1,10 +0,0 @@
-import type { Type } from '../../types.js';
-import { ApiRequestTokenProvider } from './api-request-token.provider.js';
-import type { ApiGatewayOptions } from './gateway.js';
-export type ApiModuleOptions = {
-    controllers: Type[];
-    requestTokenProvider?: Type<ApiRequestTokenProvider>;
-    gatewayOptions?: ApiGatewayOptions;
-};
-export declare const apiModuleOptions: ApiModuleOptions;
-export declare function configureApiServer(options: Partial<ApiModuleOptions>): void;

package/api/server/tokens.d.ts

@@ -1,5 +0,0 @@
-import type { ApiController } from '../types.js';
-import type { ApiModuleOptions } from './module.js';
-export declare const API_MODULE_OPTIONS: import("../../injector/token.js").InjectionToken<ApiModuleOptions, never>;
-export declare const API_CONTROLLER: import("../../injector/token.js").InjectionToken<ApiController, never>;
-export declare const API_CONTROLLERS: import("../../injector/token.js").InjectionToken<ApiController[], never>;

package/api/types.d.ts

@@ -1,123 +0,0 @@
-import type { HttpServerRequest, HttpServerResponse } from '../http/server/index.js';
-import type { HttpMethod } from '../http/types.js';
-import type { SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { ServerSentEventsSource } from '../sse/server-sent-events-source.js';
-import type { ServerSentEvents } from '../sse/server-sent-events.js';
-import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types.js';
-import { type ValueOrProvider } from '../utils/value-or-provider.js';
-import type { ApiGatewayMiddlewareContext } from './server/index.js';
-export type ApiRegistrationOptions = {
-    name?: string;
-    prefix?: string;
-};
-export type ApiRegistration = {
-    target: object;
-    name: string;
-    path: string;
-    prefix: string;
-};
-export type EndpointRegistrationOptions = {
-    path?: string;
-    description?: string;
-};
-export type ApiEndpointMethod = HttpMethod;
-export type ApiEndpointDefinitionParameters = SchemaTestable;
-export type ApiEndpointDefinitionBody = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
-export type ApiEndpointDefinitionResult = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
-export type ApiEndpointDataProvider<T> = T | ((request: HttpServerRequest, context: ApiGatewayMiddlewareContext) => T | Promise<T>);
-export type ApiEndpointDefinitionCors = {
-    accessControlAllowCredentials?: ApiEndpointDataProvider<boolean | undefined>;
-    accessControlAllowHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
-    accessControlAllowMethods?: ApiEndpointDataProvider<OneOrMany<HttpMethod> | undefined>;
-    accessControlAllowOrigin?: ApiEndpointDataProvider<string | undefined>;
-    autoAccessControlAllowOrigin?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
-    accessControlExposeHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
-    accessControlMaxAge?: ApiEndpointDataProvider<number | undefined>;
-};
-export type ApiEndpointDefinition = {
-    /**
-     * Http Method
-     * @default GET
-     */
-    method?: OneOrMany<ApiEndpointMethod>;
-    /** Endpoint prefix. Overwrites default from api and gateway. */
-    prefix?: string | null;
-    /** Root resource path. Overwrites default from {@link ApiDefinition}. */
-    rootResource?: string | null;
-    /**
-     * Sub resource in api
-     *
-     * results in
-     * ```ts
-     * ${endpoint.rootResource ?? api.ressource}/${endpoint.resource}
-     * ```
-     * @default name of endpoint property
-     */
-    resource?: string;
-    version?: OneOrMany<number | null>;
-    parameters?: ApiEndpointDefinitionParameters;
-    body?: ApiEndpointDefinitionBody;
-    result?: ApiEndpointDefinitionResult;
-    /** Maximum size of request body. Useful to prevent harmful requests. */
-    maxBytes?: number;
-    description?: string;
-    data?: Record;
-    /**
-     * If true, sets browsers fetch to { credentials: 'include' } and enables 'Access-Control-Allow-Credentials' header.
-     *
-     * @default false
-     */
-    credentials?: boolean;
-    cors?: ApiEndpointDefinitionCors;
-};
-export type ApiEndpointsDefinition = Record<string, ValueOrProvider<ApiEndpointDefinition>>;
-export type ApiDefinition<Resource extends string = string, Endpoints extends ApiEndpointsDefinition = ApiEndpointsDefinition> = {
-    /**
-     * Default root resource for endpoints.
-     */
-    resource: Resource;
-    /**
-     * Endpoint prefix. Overwrites default from gateway.
-     */
-    prefix?: string | null;
-    endpoints: Endpoints;
-};
-export type ApiEndpointKeys<T extends ApiDefinition> = keyof T['endpoints'];
-export type NormalizedApiEndpoints<T extends ApiDefinition['endpoints']> = {
-    [P in keyof T]: ReturnTypeOrT<T[P]>;
-};
-export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NormalizedApiEndpoints<T['endpoints']>[K];
-export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['parameters']>;
-export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
-export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
-export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream<any>;
-export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<ApiBinaryType> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends SchemaTestable ? SchemaOutput<T> : never;
-export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array> : T extends SchemaTestable ? SchemaOutput<T> : never;
-export type ApiParameters<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointParametersSchema<T, K>>;
-export type ApiClientBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointBodySchema<T, K>>;
-export type ApiServerBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointBodySchema<T, K>>;
-export type ApiServerResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointResultSchema<T, K>> | HttpServerResponse;
-export type ApiClientResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointResultSchema<T, K>>;
-export type ApiRequestData<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = {
-    parameters: ApiParameters<T, K>;
-    body: ApiServerBody<T, K>;
-    request: HttpServerRequest;
-};
-export type ApiRequestContext<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiRequestData<T, K> & {
-    getToken<Token>(): Promise<Token>;
-};
-export type ApiEndpointServerImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = (context: ApiRequestContext<T, K>) => ApiServerResult<T, K> | Promise<ApiServerResult<T, K>>;
-export type ApiEndpointClientImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiClientBody<T, K> extends never ? ApiParameters<T, K> extends never ? () => Promise<ApiClientResult<T, K>> : (parameters: ApiParameters<T, K>) => Promise<ApiClientResult<T, K>> : (parameters: ApiParameters<T, K> extends never ? undefined | Record<never, never> : ApiParameters<T, K>, body: ApiClientBody<T, K>) => Promise<ApiClientResult<T, K>>;
-export type ApiController<T extends ApiDefinition = any> = {
-    [P in ApiEndpointKeys<T>]: ApiEndpointServerImplementation<T, P>;
-};
-export type ApiClientImplementation<T extends ApiDefinition = any> = {
-    [P in ApiEndpointKeys<T>]: ApiEndpointClientImplementation<T, P>;
-} & {
-    getEndpointResource<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string;
-    getEndpointUrl<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string;
-};
-export declare function defineApi<T extends ApiDefinition>(definition: T): T;
-export declare function resolveApiEndpointDataProvider<T>(request: HttpServerRequest, context: ApiGatewayMiddlewareContext, provider: ApiEndpointDataProvider<T>): Promise<T>;
-export declare function normalizedApiDefinitionEndpoints<T extends ApiDefinition['endpoints']>(apiDefinitionEndpoints: T): NormalizedApiEndpoints<T>;
-export declare function normalizedApiDefinitionEndpointsEntries<T extends ApiDefinition['endpoints']>(apiDefinition: T): [keyof T, ApiEndpointDefinition][];