@tstdl/base 0.92.124 → 0.92.125

package/types/lock/mongo/model.d.ts

@@ -1,6 +0,0 @@
-import type { Entity } from '../../../database/index.js';
-export type MongoLockEntity = Entity & {
-    resource: string;
-    key: string;
-    expiration: Date;
-};

package/types/lock/mongo/module.d.ts

@@ -1,12 +0,0 @@
-import type { MongoRepositoryConfig } from '../../../database/mongo/index.js';
-import type { MongoLockEntity } from './model.js';
-export type MongoLockModuleConfig = {
-    lockEntityRepositoryConfig: MongoRepositoryConfig<MongoLockEntity> | undefined;
-};
-export declare const mongoLockModuleConfig: MongoLockModuleConfig;
-/**
- * configure mongo lock module
- * @param lockRepositoryConfig repository configuration for locks
- * @param register whether to register for {@link Lock} and {@link LockProvider}
- */
-export declare function configureMongoLock(lockRepositoryConfig: MongoRepositoryConfig<MongoLockEntity>, register?: boolean): void;

package/types/lock/mongo/mongo-lock-repository.d.ts

@@ -1,14 +0,0 @@
-import type { CollectionArgument } from '../../../database/mongo/index.js';
-import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
-import { resolveArgumentType } from '../../../injector/index.js';
-import type { Resolvable } from '../../../injector/interfaces.js';
-import { Logger } from '../../../logger/index.js';
-import type { MongoLockEntity } from './model.js';
-export declare class MongoLockRepository extends MongoEntityRepository<MongoLockEntity> implements Resolvable<CollectionArgument<MongoLockEntity>> {
-    readonly [resolveArgumentType]: CollectionArgument<MongoLockEntity>;
-    constructor(collection: Collection<MongoLockEntity>, logger: Logger);
-    tryInsertOrRefresh(resource: string, key: string, newExpirationDate: Date): Promise<false | Date>;
-    exists(resource: string): Promise<boolean>;
-    tryUpdateExpiration(resource: string, key: string, expirationDate: Date): Promise<false | Date>;
-    deleteByResource(resource: string, key: string): Promise<boolean>;
-}

package/types/lock/mongo/provider.d.ts

@@ -1,8 +0,0 @@
-import type { Lock } from '../../../lock/index.js';
-import { LockProvider } from '../../../lock/index.js';
-export declare class MongoLockProvider extends LockProvider {
-    #private;
-    prefix(prefix: string): MongoLockProvider;
-    get(resource: string): Lock;
-    private getResourceString;
-}

package/types/lock/provider.d.ts

@@ -1,10 +0,0 @@
-import type { Resolvable } from '../../injector/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
-import type { Lock } from './lock.js';
-/** prefix */
-export type LockProviderArgument = string;
-export declare abstract class LockProvider implements Resolvable<LockProviderArgument> {
-    readonly [resolveArgumentType]: LockProviderArgument;
-    abstract prefix(prefix: string): LockProvider;
-    abstract get(resource: string): Lock;
-}

package/types/lock/web/web-lock.provider.d.ts

@@ -1,8 +0,0 @@
-import type { Lock } from '../../../lock/index.js';
-import { LockProvider } from '../../../lock/index.js';
-export declare class WebLockProvider extends LockProvider {
-    private readonly _prefix;
-    constructor(prefix?: string);
-    prefix(prefix: string): LockProvider;
-    get(resource: string): Lock;
-}

package/types/logger/logger.d.ts

@@ -1,41 +0,0 @@
-import type { Resolvable } from '../../injector/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
-import { LogLevel } from './level.js';
-export type LogEntry = string;
-export type LogEntryProvider = () => LogEntry;
-export type LogEntryOrProvider = LogEntry | LogEntryProvider;
-export type LoggerStatic = new (level: LogLevel) => Logger;
-export type LogErrorOptions = {
-    includeRest?: boolean;
-    includeStack?: boolean;
-};
-/** Either string as a module shorthand or object */
-export type LoggerArgument = string | undefined | {
-    level?: LogLevel;
-    module?: string | string[];
-    prefix?: string;
-};
-export type LoggerForkOptions = {
-    subModule?: string;
-    prefix?: string;
-    level?: LogLevel;
-};
-export declare abstract class Logger implements Resolvable<LoggerArgument> {
-    readonly level: LogLevel;
-    readonly module?: string[];
-    readonly logPrefix: string;
-    readonly [resolveArgumentType]: LoggerArgument;
-    constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    error(entry: LogEntryOrProvider): void;
-    error(error: unknown, options?: LogErrorOptions): void;
-    warn(entry: LogEntryOrProvider): void;
-    info(entry: LogEntryOrProvider): void;
-    verbose(entry: LogEntryOrProvider): void;
-    debug(entry: LogEntryOrProvider): void;
-    trace(entry: LogEntryOrProvider): void;
-    private _log;
-    abstract fork(options: LoggerForkOptions): Logger;
-    abstract subModule(subModule: string): Logger;
-    abstract prefix(prefix: string): Logger;
-    protected abstract log(level: LogLevel, entry: LogEntry | Error, errorOptions?: LogErrorOptions): void;
-}

package/types/logger/tokens.d.ts

@@ -1,2 +0,0 @@
-import type { LogLevel } from './level.js';
-export declare const LOG_LEVEL: import("../../injector/token.js").InjectionToken<LogLevel, never>;

package/types/mail/clients/nodemailer.mail-client.d.ts

@@ -1,13 +0,0 @@
-import type { Disposable } from '../../../disposable/disposable.js';
-import { MailClient, MailClientConfig } from '../mail.client.js';
-import type { MailData, MailSendResult } from '../models/index.js';
-export declare class NodemailerMailClient extends MailClient implements Disposable {
-    #private;
-    [Symbol.dispose](): void;
-    send(data: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-    private getTransport;
-}
-/**
- * @param register whether to register for {@link MailClient}
- */
-export declare function configureNodemailerMailClient(register?: boolean): void;

package/types/mail/mail.client.d.ts

@@ -1,17 +0,0 @@
-import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
-import type { MailData, MailSendResult } from './models/index.js';
-export declare class MailClientAuthConfig {
-    user: string;
-    password: string;
-}
-export declare class MailClientConfig {
-    host: string;
-    port: number;
-    /** Enable TLS (if not defined it is automatically set depending on port) */
-    secure?: boolean;
-    auth?: MailClientAuthConfig;
-}
-export declare abstract class MailClient implements Resolvable<MailClientConfig> {
-    readonly [resolveArgumentType]: MailClientConfig;
-    abstract send(data: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-}

package/types/mail/mail.service.d.ts

@@ -1,10 +0,0 @@
-import type { TypedOmit } from '../../types.js';
-import { MailClientConfig } from './mail.client.js';
-import { type MailData, type MailSendResult, type MailTemplate } from './models/index.js';
-export declare class MailService {
-    #private;
-    send(mailData: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-    /** @deprecated internal */
-    send(mailData: MailData, clientConfig?: MailClientConfig, templateName?: string): Promise<MailSendResult>;
-    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-}

package/types/mail/models/mail-data.model.d.ts

@@ -1,21 +0,0 @@
-import type { OneOrMany } from '../../../types.js';
-import type { MailAddress } from './mail-address.model.js';
-import type { MailContent } from './mail-content.model.js';
-export type MailData = {
-    content: MailContent;
-    from?: MailAddress;
-    to?: OneOrMany<MailAddress>;
-    subject?: string;
-    sender?: MailAddress;
-    cc?: OneOrMany<MailAddress>;
-    bcc?: OneOrMany<MailAddress>;
-    replyTo?: MailAddress;
-    inReplyTo?: MailAddress;
-    returnPath?: MailAddress;
-    references?: OneOrMany<string>;
-    /**
-     * If a header has an string array as its value, the header is added multiple times.
-     */
-    headers?: Record<string, string | string[]>;
-};
-export type DefaultMailData = Partial<MailData>;

package/types/mail/models/mail-log.model.d.ts

@@ -1,10 +0,0 @@
-import { Entity, Json, Timestamp } from '../../../orm/index.js';
-import type { MailData } from './mail-data.model.js';
-import type { MailSendResult } from './mail-send-result.model.js';
-export declare class MailLog extends Entity {
-    timestamp: Timestamp;
-    template: string | null;
-    data: Json<MailData>;
-    sendResult: Json<MailSendResult> | null;
-    errors: string[] | null;
-}

package/types/mail/models/mail-template.model.d.ts

@@ -1,14 +0,0 @@
-import type { Template, TemplateField } from '../../../templates/template.model.js';
-import type { Record } from '../../../types.js';
-export type MailTemplate<Context extends Record = any> = Template<{
-    subject: false;
-    html: false;
-    text: false;
-}, undefined, Context>;
-type MailTemplateFields<Context extends Record> = {
-    subject?: TemplateField<string, string, any, Context>;
-    html?: TemplateField<string, string, any, Context>;
-    text?: TemplateField<string, string, any, Context>;
-};
-export declare function mailTemplate<Context extends Record>(name: string, fields: MailTemplateFields<Context>): MailTemplate<Context>;
-export {};

package/types/mail/models/schemas.d.ts

@@ -1,3 +0,0 @@
-import { MailLog } from './mail-log.model.js';
-export declare const mailSchema: import("../../../orm/server/database-schema.js").DatabaseSchema<"mail">;
-export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<typeof MailLog, "mail">;

package/types/mail/module.d.ts

@@ -1,15 +0,0 @@
-import { type DatabaseConfig } from '../../orm/server/index.js';
-import type { Type } from '../../types.js';
-import { MailClient, MailClientConfig } from './mail.client.js';
-import type { DefaultMailData } from './models/index.js';
-export declare class MailModuleConfig {
-    database?: DatabaseConfig;
-    defaultClientConfig?: MailClientConfig;
-    client?: Type<MailClient>;
-    defaultData?: DefaultMailData;
-}
-/**
- * configure mail module
- */
-export declare function configureMail(config: MailModuleConfig): void;
-export declare function migrateMailSchema(): Promise<void>;

package/types/mail/tokens.d.ts

@@ -1 +0,0 @@
-export declare const MAIL_DEFAULT_DATA: import("../../injector/index.js").InjectionToken<Partial<import("./models/mail-data.model.js").MailData>, never>;

package/types/message-bus/broadcast-channel/broadcast-channel-message-bus-provider.d.ts

@@ -1,8 +0,0 @@
-import { Logger } from '../../../logger/index.js';
-import type { MessageBusProvider } from '../message-bus-provider.js';
-import type { MessageBus } from '../message-bus.js';
-export declare class BroadcastChannelMessageBusProvider implements MessageBusProvider {
-    private readonly logger;
-    constructor(logger: Logger);
-    get<T>(channel: string): MessageBus<T>;
-}

package/types/message-bus/broadcast-channel/broadcast-channel-message-bus.d.ts

@@ -1,19 +0,0 @@
-import type { Observable } from 'rxjs';
-import { Logger } from '../../../logger/index.js';
-import { MessageBusBase } from '../message-bus-base.js';
-import type { MessageBus } from '../message-bus.js';
-/** return values wrapped in Promise for polyfills which returns promises */
-interface PromisifiedBroadcastChannel extends BroadcastChannel {
-    close(...args: Parameters<BroadcastChannel['close']>): void | Promise<void>;
-    postMessage(...args: Parameters<BroadcastChannel['postMessage']>): void | Promise<void>;
-}
-export declare class BroadcastChannelMessageBus<T> extends MessageBusBase<T> implements MessageBus<T> {
-    private readonly channelProvider;
-    private _channel;
-    protected readonly _messages$: Observable<T>;
-    get channel(): PromisifiedBroadcastChannel;
-    constructor(channelProvider: () => BroadcastChannel, logger: Logger);
-    protected _publish(message: T): Promise<void>;
-    protected _dispose(): Promise<void>;
-}
-export {};

package/types/message-bus/local/local-message-bus-provider.d.ts

@@ -1,9 +0,0 @@
-import { Logger } from '../../../logger/index.js';
-import { MessageBusProvider } from '../message-bus-provider.js';
-import { LocalMessageBus } from './local-message-bus.js';
-export declare class LocalMessageBusProvider extends MessageBusProvider {
-    private readonly logger;
-    private readonly channelSubjectsMap;
-    constructor(logger: Logger);
-    get<T>(channel: string): LocalMessageBus<T>;
-}

package/types/message-bus/local/local-message-bus.d.ts

@@ -1,14 +0,0 @@
-import type { Observable } from 'rxjs';
-import { Subject } from 'rxjs';
-import { Logger } from '../../../logger/index.js';
-import { MessageBusBase } from '../message-bus-base.js';
-import type { MessageBus } from '../message-bus.js';
-import type { LocalMessageBusItem } from './types.js';
-export declare class LocalMessageBus<T> extends MessageBusBase<T> implements MessageBus<T> {
-    private readonly subject;
-    private readonly source;
-    protected _messages$: Observable<T>;
-    constructor(subject: Subject<LocalMessageBusItem<T>>, logger: Logger);
-    _publish(message: T): void;
-    _dispose(): void;
-}

package/types/message-bus/message-bus-base.d.ts

@@ -1,26 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { Logger } from '../../logger/index.js';
-import { CancellationToken } from '../cancellation/token.js';
-import { disposeAsync } from '../disposable/disposable.js';
-import { MessageBus } from './message-bus.js';
-export declare abstract class MessageBusBase<T> extends MessageBus<T> {
-    private readonly logger;
-    private readonly publishSubject;
-    protected readonly disposeToken: CancellationToken;
-    readonly messages$: Observable<T>;
-    readonly allMessages$: Observable<T>;
-    /**
-     * observable which emits all messages from *other* instances, but *none* published from itself
-     */
-    protected abstract _messages$: Observable<T>;
-    constructor(logger: Logger);
-    publishAndForget(message: T): void;
-    publish(message: T): Promise<void>;
-    [disposeAsync](): Promise<void>;
-    /**
-     * publish messages to other instances
-     * @param message message to send to other instances
-     */
-    protected abstract _publish(message: T): void | Promise<void>;
-    protected abstract _dispose(): void | Promise<void>;
-}

package/types/message-bus/message-bus.d.ts

@@ -1,15 +0,0 @@
-import type { Observable } from 'rxjs';
-import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import { type AsyncDisposable, disposeAsync } from '../disposable/disposable.js';
-export type MessageBusArgument = string;
-export declare abstract class MessageBus<T> implements AsyncDisposable, Resolvable<MessageBusArgument> {
-    readonly [resolveArgumentType]: string;
-    /** Messages from other instances */
-    abstract readonly messages$: Observable<T>;
-    /** Messages from other instances and itself */
-    abstract readonly allMessages$: Observable<T>;
-    dispose(): Promise<void>;
-    abstract publish(message: T): Promise<void>;
-    abstract publishAndForget(message: T): void;
-    abstract [disposeAsync](): Promise<void>;
-}

package/types/migration/migration-state-repository.d.ts

@@ -1,4 +0,0 @@
-import { EntityRepository } from '../../database/index.js';
-import type { MigrationState } from './migration-state.js';
-export declare abstract class MigrationStateRepository extends EntityRepository<MigrationState> {
-}

package/types/migration/migration-state.d.ts

@@ -1,6 +0,0 @@
-import type { Entity, NewEntity } from '../../database/index.js';
-export type MigrationState = Entity & {
-    name: string;
-    revision: number;
-};
-export type NewMigrationState = NewEntity<MigrationState>;

package/types/migration/mongo/migration-state-repository.d.ts

@@ -1,11 +0,0 @@
-import type { Resolvable } from '../../../injector/index.js';
-import { resolveArgumentType } from '../../../injector/index.js';
-import { Logger } from '../../../logger/index.js';
-import type { MigrationState, MigrationStateRepository } from '../../../migration/index.js';
-import type { CollectionArgument } from '../../database/mongo/classes.js';
-import { Collection } from '../../database/mongo/classes.js';
-import { MongoEntityRepository } from '../../database/mongo/mongo-entity-repository.js';
-export declare class MongoMigrationStateRepository extends MongoEntityRepository<MigrationState> implements MigrationStateRepository, Resolvable<CollectionArgument<MigrationState>> {
-    readonly [resolveArgumentType]: CollectionArgument<MigrationState>;
-    constructor(collection: Collection<MigrationState>, logger: Logger);
-}

package/types/migration/mongo/module.d.ts

@@ -1,12 +0,0 @@
-import type { MongoRepositoryConfig } from '../../../database/mongo/index.js';
-import type { MigrationState } from '../../../migration/migration-state.js';
-export type MongoMigrationStateRepositoryModuleConfig = {
-    defaultMigrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState> | undefined;
-};
-export declare const mongoMigrationStateRepositoryModuleConfig: MongoMigrationStateRepositoryModuleConfig;
-/**
- * configure mongo migration state repository module
- * @param migrationStateRepositoryConfig repository configuration for states
- * @param register whether to register for {@link MigrationStateRepository}
- */
-export declare function configureMongoMigrationStateRepository(migrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState>, register?: boolean): void;

package/types/module/module-base.d.ts

@@ -1,18 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/index.js';
-import { CancellationToken } from '../../cancellation/index.js';
-import type { StringMap } from '../../types.js';
-import type { Module, ModuleMetric } from './module.js';
-import { ModuleState } from './module.js';
-export declare abstract class ModuleBase implements Module {
-    private runPromise;
-    private _state;
-    protected readonly cancellationToken: CancellationToken;
-    readonly name: string;
-    abstract readonly metrics: StringMap<ModuleMetric>;
-    get state(): ModuleState;
-    private get stateString();
-    constructor(name: string);
-    run(): Promise<void>;
-    stop(): Promise<void>;
-    protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;
-}

package/types/module/module-metric-reporter.d.ts

@@ -1,29 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/index.js';
-import type { MetricAggregation, MetricAggregationOptions } from '../../utils/moving-metric.js';
-import { MovingMetric } from '../../utils/moving-metric.js';
-import type { ModuleMetric } from './module.js';
-export type MetricReport<Aggregation extends MetricAggregation> = {
-    displayName: string;
-    aggregation: Aggregation;
-    aggregationOptions?: MetricAggregationOptions<Aggregation>;
-};
-export type MetricReportRegistration = {
-    metric: ModuleMetric;
-    moving: MovingMetric;
-    reports: MetricReport<MetricAggregation>[];
-};
-export declare class ModuleMetricReporter {
-    private readonly metricGroups;
-    private readonly sampleInterval;
-    private readonly sampleCount;
-    private readonly reportEveryNthSample;
-    private longestGroupName;
-    private longestDisplayName;
-    constructor(sampleInterval: number, sampleCount: number, reportEveryNthSample: number);
-    register(groupName: string, ...metrics: {
-        metric: ModuleMetric;
-        reports: MetricReport<MetricAggregation>[];
-    }[]): void;
-    run(cancellationSignal: CancellationSignal): Promise<void>;
-    private updateNameLengths;
-}

package/types/module/module.d.ts

@@ -1,23 +0,0 @@
-import type { StringMap } from '../../types.js';
-export declare enum ModuleMetricType {
-    Counter = 0,
-    Gauge = 1
-}
-export type ModuleMetric = {
-    type: ModuleMetricType;
-    labels?: string[];
-    getValue(): number;
-};
-export declare enum ModuleState {
-    Running = 0,
-    Stopping = 1,
-    Stopped = 2,
-    Erroneous = 3
-}
-export interface Module {
-    readonly name: string;
-    readonly state: ModuleState;
-    readonly metrics: StringMap<ModuleMetric>;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}

package/types/module/modules/function.module.d.ts

@@ -1,10 +0,0 @@
-import type { CancellationSignal } from '../../../cancellation/index.js';
-import { ModuleBase } from '../module-base.js';
-import type { Module } from '../module.js';
-export type FunctionModuleFunction = (cancellationToken: CancellationSignal) => void | Promise<void>;
-export declare class FunctionModule extends ModuleBase implements Module {
-    private readonly fn;
-    readonly metrics: {};
-    constructor(fn: FunctionModuleFunction, name?: string);
-    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
-}

package/types/module/modules/web-server.module.d.ts

@@ -1,27 +0,0 @@
-import type { CancellationSignal } from '../../../cancellation/index.js';
-import type { Resolvable, resolveArgumentType } from '../../../injector/interfaces.js';
-import { ModuleBase } from '../module-base.js';
-import type { Module } from '../module.js';
-import { ModuleMetricType } from '../module.js';
-export type WebServerModuleConfiguration = {
-    port: number;
-};
-export declare const webServerModuleConfiguration: WebServerModuleConfiguration;
-export declare class WebServerModule extends ModuleBase implements Module, Resolvable<WebServerModuleConfiguration> {
-    private readonly config;
-    private readonly httpServer;
-    private readonly apiGateway;
-    private readonly apiControllers;
-    private initialized;
-    readonly metrics: {
-        connectedSockets: {
-            type: ModuleMetricType;
-            getValue: () => number;
-        };
-    };
-    readonly [resolveArgumentType]: WebServerModuleConfiguration;
-    constructor();
-    initialize(): void;
-    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
-}
-export declare function configureWebServerModule(config?: Partial<WebServerModuleConfiguration>): void;

package/types/module/utils.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from '../../logger/index.js';
-import type { Module } from './module.js';
-export declare function runModules(modules: Module[], logger?: Logger): Promise<void>;
-export declare function stopModules(modules: Module[], logger?: Logger): Promise<void>;

package/types/object-storage/object-storage.d.ts

@@ -1,75 +0,0 @@
-import { resolveArgumentType, type Resolvable } from '../../injector/interfaces.js';
-import type { ObjectMetadata, ObjectStorageObject } from './object.js';
-export type UploadObjectOptions = {
-    contentLength?: number;
-    metadata?: ObjectMetadata;
-};
-export type ObjectStorageArgument = string;
-export declare abstract class ObjectStorage implements Resolvable<ObjectStorageArgument> {
-    /** Object storage module */
-    readonly module: string;
-    readonly [resolveArgumentType]: ObjectStorageArgument;
-    constructor(module: string);
-    /**
-     * Checks if an object exists
-     * @param key object key
-     */
-    abstract exists(key: string): Promise<boolean>;
-    /**
-     * Uploads an object
-     * @param key object key
-     * @param content content of object
-     */
-    abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
-    /**
-     * Get an url which can be used to upload the object without further authorization
-     * @param key object key
-     * @param expirationTimestamp timestamp when the url expires and can no longer be used
-     */
-    abstract getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
-    /**
-     * Get all objects
-     */
-    abstract getObjects(): Promise<ObjectStorageObject[]>;
-    /**
-     * Get all objects
-     */
-    abstract getObjectsCursor(): AsyncIterable<ObjectStorageObject>;
-    /**
-     * Get object
-     * @param key object key
-     */
-    abstract getObject(key: string): Promise<ObjectStorageObject>;
-    /**
-     * Get object resource uri
-     * @param key object key
-     */
-    abstract getResourceUri(key: string): Promise<string>;
-    /**
-     * Get object content
-     * @param key object key
-     */
-    abstract getContent(key: string): Promise<Uint8Array>;
-    /**
-     * Get stream of object content
-     * @param key object key
-     */
-    abstract getContentStream(key: string): ReadableStream<Uint8Array>;
-    /**
-     * Get an url which can be used to download the object without further authorization
-     * @param key object key
-     * @param expirationTimestamp timestamp when the url expires and can no longer be used
-     * @param responseHeaders headers used for download response
-     */
-    abstract getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
-    /**
-     * Deletes an object
-     * @param key object key
-     */
-    abstract deleteObject(key: string): Promise<void>;
-    /**
-     * Deletes objects
-     * @param keys object key
-     */
-    abstract deleteObjects(keys: string[]): Promise<void>;
-}

package/types/object-storage/object.d.ts

@@ -1,12 +0,0 @@
-import type { Record } from '../../types.js';
-export type ObjectMetadata = Record<string>;
-export declare abstract class ObjectStorageObject {
-    readonly module: string;
-    readonly key: string;
-    constructor(module: string, key: string);
-    abstract getResourceUri(): Promise<string>;
-    abstract getContentLength(): Promise<number>;
-    abstract getMetadata(): Promise<ObjectMetadata>;
-    abstract getContent(): Promise<Uint8Array>;
-    abstract getContentStream(): ReadableStream<Uint8Array>;
-}

package/types/object-storage/s3/s3.object-storage-provider.d.ts

@@ -1,41 +0,0 @@
-import { ObjectStorageProvider } from '../../../object-storage/index.js';
-import { S3ObjectStorage } from './s3.object-storage.js';
-export declare class S3ObjectStorageProviderConfig {
-    /**
-     * S3 endpoint
-     */
-    endpoint: string;
-    /**
-     * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
-     *
-     * mutually exclusive with bucketPerModule
-     */
-    bucket?: string;
-    /**
-     * Use an own bucket for every module
-     *
-     * mutually exclusive with bucket
-     */
-    bucketPerModule?: boolean;
-    /**
-     * S3 access key
-     */
-    accessKey: string;
-    /**
-     * S3 secret key
-     */
-    secretKey: string;
-}
-export declare const bucketPerModule: unique symbol;
-export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
-    private readonly client;
-    private readonly bucket;
-    constructor(config: S3ObjectStorageProviderConfig);
-    get(module: string): S3ObjectStorage;
-}
-/**
- * Configure s3 object storage provider
- * @param config s3 config
- * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
- */
-export declare function configureS3ObjectStorage(config: S3ObjectStorageProviderConfig, register?: boolean): void;