@tstdl/base 0.92.131 → 0.92.134

package/examples/document-management/main.js

@@ -6,15 +6,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import '../../polyfills.js';
 import { configureAiService } from '../../ai/index.js';
+import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
 import { Application } from '../../application/application.js';
-import { AuthenticationApiRequestTokenProvider } from '../../authentication/server/authentication-api-request-token.provider.js';
 import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentManagementApiController, DocumentRequestService } from '../../document-management/server/index.js';
 import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
+import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { Injector, Singleton } from '../../injector/index.js';
 import { inject, injectManyAsync, runInInjectionContext } from '../../injector/inject.js';
 import { configureLocalMessageBus } from '../../message-bus/index.js';
+import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 import { configureOrm } from '../../orm/server/index.js';
 import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
@@ -47,9 +49,9 @@ const config = {
 };
 let ExampleDocumentManagementAncillaryService = class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
     _resolveMetadata(collections) {
-        return collections.map((collection) => ({ name: collection.id, group: null }));
+        return collections.map((collection) => ({ name: collection.id.split('-')[0], group: null }));
     }
-    getUserId(_token) { return 'user-id'; }
+    getSubject(_token) { return 'user-id'; }
     canCreateDocuments(_collectionId, _token) { return true; }
     canUpdateDocuments(_collectionId, _token) { return true; }
     canDeleteDocuments(_collectionId, _token) { return true; }
@@ -70,6 +72,7 @@ ExampleDocumentManagementAncillaryService = __decorate([
 export { ExampleDocumentManagementAncillaryService };
 async function bootstrap() {
     const injector = inject(Injector);
+    configureNodeHttpServer();
     configurePostgresQueue();
     configureLocalMessageBus();
     configureOrm({
@@ -84,6 +87,7 @@ async function bootstrap() {
     configureDocumentManagement({
         ancillaryService: ExampleDocumentManagementAncillaryService,
         fileObjectStorageModule: 'documents',
+        fileUploadObjectStorageModule: 'document-uploads',
         filePreviewObjectStorageModule: 'document-previews',
     });
     configureS3ObjectStorage({
@@ -95,7 +99,7 @@ async function bootstrap() {
     });
     configureApiServer({
         controllers: [DocumentManagementApiController],
-        requestTokenProvider: AuthenticationApiRequestTokenProvider,
+        requestTokenProvider: MockApiRequestTokenProvider,
         gatewayOptions: {
             prefix: null,
             cors: {
@@ -116,8 +120,13 @@ async function bootstrap() {
 async function main() {
     const [documentManagementService, documentCollectionService] = await injectManyAsync(DocumentManagementService, DocumentCollectionService, DocumentCategoryTypeService, DocumentRequestService);
     const { categories, types } = await documentManagementService.initializeCategoriesAndTypes(TstdlDocumentCategoryLabels, TstdlCategoryParents, TstdlDocumentTypeLabels, TstdlDocumentTypeCategories);
-    const collection = await documentCollectionService.createCollection(null);
-    const data = await documentManagementService.loadData([collection.id]);
-    console.log(data);
+    const collectionCount = await documentCollectionService.repository.count();
+    for (let i = 0; i < (3 - collectionCount); i++) {
+        await documentCollectionService.createCollection(null);
+    }
+    const collections = await documentCollectionService.repository.loadAll();
+    for (const collection of collections) {
+        console.log(`Collection: ${collection.id}`);
+    }
 }
-Application.run({ bootstrap }, main);
+Application.run({ bootstrap }, main, WebServerModule);

package/http/client/adapters/undici.adapter.js

@@ -56,7 +56,7 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
                 body,
                 headersTimeout: httpClientRequest.timeout,
                 bodyTimeout: httpClientRequest.timeout,
-                dispatcher: this.options.dispatcher
+                dispatcher: this.options.dispatcher,
             });
             const httpClientResponse = new HttpClientResponse({
                 request: httpClientRequest,
@@ -64,14 +64,14 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
                 statusMessage: '?',
                 headers: new HttpHeaders(response.headers),
                 body: response.body,
-                closeHandler: () => response.body.destroy()
+                closeHandler: () => response.body.destroy(),
             });
             return httpClientResponse;
         }
         catch (error) {
             if (error instanceof undiciErrors.UndiciError) {
                 const reason = getHttpErrorReason(error);
-                throw new HttpError(reason, httpClientRequest, undefined, undefined, error);
+                throw new HttpError(reason, httpClientRequest, { cause: error });
             }
             throw error;
         }

package/http/client/http-client.js

@@ -35,11 +35,11 @@ let HttpClient = class HttpClient {
     constructor() {
         this.internalStartMiddleware = [
             getBuildRequestUrlMiddleware(this.options.baseUrl),
-            ...((this.options.enableErrorHandling ?? true) ? [errorMiddleware] : [])
+            ...((this.options.enableErrorHandling ?? true) ? [errorMiddleware] : []),
         ];
         this.internalEndMiddleware = [
             getAddRequestHeadersMiddleware(this.headers),
-            getAdapterCallMiddleware(this.adapter)
+            getAdapterCallMiddleware(this.adapter),
         ];
         this.updateMiddleware();
     }
@@ -54,22 +54,22 @@ let HttpClient = class HttpClient {
         this.headers.remove(name);
     }
     async head(url, options) {
-        return this.request('HEAD', url, { ...options });
+        return await this.request('HEAD', url, { ...options });
     }
     async get(url, options) {
-        return this.request('GET', url, options);
+        return await this.request('GET', url, options);
     }
     async getText(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async getJson(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async getBuffer(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     getStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -90,19 +90,19 @@ let HttpClient = class HttpClient {
         });
     }
     async post(url, options) {
-        return this.request('POST', url, options);
+        return await this.request('POST', url, options);
     }
     async postText(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async postJson(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async postBuffer(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     postStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -111,19 +111,19 @@ let HttpClient = class HttpClient {
         });
     }
     async put(url, options) {
-        return this.request('PUT', url, options);
+        return await this.request('PUT', url, options);
     }
     async putText(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async putJson(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async putBuffer(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     putStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -132,19 +132,19 @@ let HttpClient = class HttpClient {
         });
     }
     async patch(url, options) {
-        return this.request('PATCH', url, options);
+        return await this.request('PATCH', url, options);
     }
     async patchText(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async patchJson(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async patchBuffer(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     patchStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -153,19 +153,19 @@ let HttpClient = class HttpClient {
         });
     }
     async delete(url, options) {
-        return this.request('DELETE', url, options);
+        return await this.request('DELETE', url, options);
     }
     async deleteText(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async deleteJson(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async deleteBuffer(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     deleteStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -175,7 +175,7 @@ let HttpClient = class HttpClient {
     }
     async request(method, url, options = {}) {
         const request = new HttpClientRequest(url, method, options);
-        return this.rawRequest(request);
+        return await this.rawRequest(request);
     }
     async rawRequest(request) {
         const context = { request };
@@ -197,7 +197,7 @@ function getBuildRequestUrlMiddleware(baseUrl) {
         if (request.mapParameters) {
             mapParameters(request, baseUrl);
         }
-        return next();
+        await next();
     }
     return buildUrlParametersMiddleware;
 }
@@ -238,7 +238,7 @@ function getAddRequestHeadersMiddleware(defaultHeaders) {
                 request.headers.authorization = `Token ${authorization.token}`;
             }
         }
-        return next();
+        await next();
     }
     return addRequestHeadersMiddleware;
 }
@@ -267,7 +267,6 @@ async function errorMiddleware(context, next) {
         throw error;
     }
 }
-// eslint-disable-next-line max-statements, max-lines-per-function, complexity
 function mapParameters(request, baseUrl) {
     const isGetOrHead = (request.method == 'GET') || (request.method == 'HEAD');
     let url;
@@ -299,7 +298,7 @@ function mapParameters(request, baseUrl) {
         }
     }
     if (parameterEntries.size > 0) {
-        throw new HttpError(HttpErrorReason.InvalidRequest, request, undefined, 'Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined');
+        throw new HttpError(HttpErrorReason.InvalidRequest, request, { cause: 'Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined' });
     }
     if (isDefined(request.query)) {
         for (const [key, valueOrValues] of request.query) {
@@ -315,8 +314,8 @@ function mapParameters(request, baseUrl) {
 }
 function getAdapterCallMiddleware(adapter) {
     async function adapterCallMiddleware(context, next) {
-        context.response = await adapter.call(context.request); // eslint-disable-line require-atomic-updates
-        return next();
+        context.response = await adapter.call(context.request);
+        await next();
     }
     return adapterCallMiddleware;
 }

package/http/http-body.js

@@ -17,19 +17,19 @@ export class HttpBody {
     }
     async readAsBuffer(options) {
         this.prepareBodyRead();
-        return readBodyAsBuffer(this.body, this.headers, options);
+        return await readBodyAsBuffer(this.body, this.headers, options);
     }
     async readAsText(options) {
         this.prepareBodyRead();
-        return readBodyAsText(this.body, this.headers, options);
+        return await readBodyAsText(this.body, this.headers, options);
     }
     async readAsJson(options) {
         this.prepareBodyRead();
-        return readBodyAsJson(this.body, this.headers, options);
+        return await readBodyAsJson(this.body, this.headers, options);
     }
     async read(options) {
         this.prepareBodyRead();
-        return readBody(this.body, this.headers, options);
+        return await readBody(this.body, this.headers, options);
     }
     readAsBinaryStream(options) {
         this.prepareBodyRead();

package/http/http.error.d.ts

@@ -22,7 +22,11 @@ export declare class HttpError extends CustomError implements ErrorExtraInfo {
     readonly responseBody: UndefinableJson | Uint8Array;
     readonly requestInstance: HttpClientRequest;
     readonly responseInstance: HttpClientResponse | undefined;
-    constructor(reason: HttpErrorReason, request: HttpClientRequest, response?: HttpClientResponse, responseBody?: UndefinableJson | Uint8Array, cause?: Error | string);
+    constructor(reason: HttpErrorReason, request: HttpClientRequest, { response, responseBody, cause }?: {
+        response?: HttpClientResponse;
+        responseBody?: UndefinableJson | Uint8Array;
+        cause?: Error | string;
+    });
     static create(reason: HttpErrorReason, request: HttpClientRequest, response: HttpClientResponse | undefined, cause?: Error | string): Promise<HttpError>;
     getExtraInfo(): UndefinableJson | undefined;
 }

package/http/http.error.js

@@ -22,8 +22,8 @@ export class HttpError extends CustomError {
     responseBody;
     requestInstance;
     responseInstance;
-    constructor(reason, request, response, responseBody, cause) {
-        super({ message: (isString(cause) ? cause : cause?.message) ?? 'An error occurred', cause: (isNotString(cause) ? cause : undefined) });
+    constructor(reason, request, { response, responseBody, cause } = {}) {
+        super({ message: (isString(cause) ? cause : cause?.message) ?? 'An error occurred', cause: (isNotString(cause) ? cause : new Error(cause)) });
         this.reason = reason;
         this.request = request.asObject();
         this.response = response?.asObject();
@@ -35,21 +35,21 @@ export class HttpError extends CustomError {
         }
         Object.defineProperty(this, propertyNameOf((instance) => instance.requestInstance), {
             value: request,
-            enumerable: false
+            enumerable: false,
         });
         Object.defineProperty(this, propertyNameOf((instance) => instance.responseInstance), {
             value: response,
-            enumerable: false
+            enumerable: false,
         });
     }
     static async create(reason, request, response, cause) {
         const body = (response?.body.available == true) ? await response.body.read() : undefined;
-        return new HttpError(reason, request, response, body, cause);
+        return new HttpError(reason, request, { response, responseBody: body, cause });
     }
     getExtraInfo() {
         const extraInfo = {
             url: this.request.url,
-            method: this.request.method
+            method: this.request.method,
         };
         if (isDefined(this.response)) {
             const responseExtraInfo = {};

package/http/utils.js

@@ -20,7 +20,7 @@ export function readBodyAsBinaryStream(body, headers, options = {}) {
                     start: (controller) => {
                         controller.enqueue(body);
                         controller.close();
-                    }
+                    },
                 })
                 : isAnyIterable(body)
                     ? getReadableStreamFromIterable(body)
@@ -83,12 +83,12 @@ export async function readBodyAsJson(body, headers, options) {
 }
 export async function readBody(body, headers, options) {
     if (headers.contentType?.includes('json') == true) {
-        return readBodyAsJson(body, headers, { ...options, fallbackToText: true });
+        return await readBodyAsJson(body, headers, { ...options, fallbackToText: true });
     }
     if (headers.contentType?.includes('text') == true) {
-        return readBodyAsText(body, headers, options);
+        return await readBodyAsText(body, headers, options);
     }
-    return readBodyAsBuffer(body, headers, options);
+    return await readBodyAsBuffer(body, headers, options);
 }
 export function readBodyAsStream(body, headers, options) {
     if ((headers.contentType?.includes('json') == true) || (headers.contentType?.includes('text') == true)) {

package/injector/decorators.d.ts

@@ -28,7 +28,7 @@ export declare function Injectable<T = any, A = any, C extends Record = Record>(
  * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
-export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+export declare function Singleton<T = any, A = undefined>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
 /**
  * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
  * @param options registration options

package/injector/injector.d.ts

@@ -49,7 +49,7 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerSingleton<T, A = ResolveArgument<T, any>, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    static registerSingleton<T, A = undefined, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     fork(name: string): Injector;

package/injector/interfaces.d.ts

@@ -4,7 +4,7 @@ import type { AfterResolveContext } from './types.js';
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
 export type ResolveArgumentType = typeof resolveArgumentType;
-export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Resolvable<infer U>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
+export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Pick<Required<Resolvable<infer U>>, typeof resolveArgumentType>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
 export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
     /**
      * Type of resolve argument

package/injector/provider.d.ts

@@ -2,15 +2,15 @@ import type { Constructor, Record, TypedOmit } from '../types.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { AfterResolveContext, ResolveContext } from './types.js';
-export type Factory<T, A = any, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
+export type Factory<T, A = undefined, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
 export type ProviderWithArgument<T, A> = {
     defaultArgument?: ResolveArgument<T, A>;
     defaultArgumentProvider?: () => ResolveArgument<T, A>;
 };
 export type ProviderWithInitializer<T, A, D extends Record> = {
-    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
+    afterResolve?: (value: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => void | Promise<void>;
 };
-export type Provider<T = any, A = any, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
+export type Provider<T = any, A = undefined, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
 export type ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useClass: Constructor<T>;
 };
@@ -34,7 +34,7 @@ export type TokenProvider<T = any, A = any, D extends Record = Record> = Provide
     useTokenProvider: () => InjectionToken<T extends (infer U)[] ? U : T, A>;
     resolveAll: true;
 });
-export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+export type FactoryProvider<T = any, A = undefined, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useFactory: Factory<T, A, D>;
 };
 export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;

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

@@ -4,7 +4,27 @@ export type UploadObjectOptions = {
     contentLength?: number;
     metadata?: ObjectMetadata;
 };
-export type ObjectStorageArgument = string;
+export type UploadUrlOptions = {
+    metadata?: ObjectMetadata;
+};
+export type CopyObjectOptions = {
+    metadata?: ObjectMetadata;
+};
+export type MoveObjectOptions = {
+    metadata?: ObjectMetadata;
+};
+export type ObjectStorageConfiguration = {
+    lifecycle?: {
+        expiration?: {
+            /** Expire (delete) objects after a certain number of seconds. Implementations may round up to supported intervals. */
+            after?: number;
+        };
+    };
+};
+export type ObjectStorageArgument = string | {
+    module: string;
+    configuration?: ObjectStorageConfiguration;
+};
 export declare abstract class ObjectStorage implements Resolvable<ObjectStorageArgument> {
     /** Object storage module */
     readonly module: string;
@@ -19,14 +39,29 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * Uploads an object
      * @param key object key
      * @param content content of object
+     * @param options options
      */
     abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    /**
+     * Copies an object
+     * @param sourceKey source object key
+     * @param destinationKey destination object key or destination storage and key
+     * @param options options
+     */
+    abstract copyObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<void>;
+    /**
+     * Moves an object
+     * @param sourceKey source object key
+     * @param destinationKey destination object key or destination storage and key
+     * @param options options
+     */
+    abstract moveObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: MoveObjectOptions): 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>;
+    abstract getUploadUrl(key: string, expirationTimestamp: number, options?: UploadUrlOptions): Promise<string>;
     /**
      * Get all objects
      */

package/object-storage/s3/s3.object-storage-provider.js

@@ -54,7 +54,7 @@ let S3ObjectStorageProvider = class S3ObjectStorageProvider extends ObjectStorag
             port: (port.length > 0) ? parseInt(port, 10) : undefined,
             useSSL: protocol == 'https:',
             accessKey: config.accessKey,
-            secretKey: config.secretKey
+            secretKey: config.secretKey,
         });
         this.bucket = assertDefinedPass((config.bucketPerModule == true) ? true : config.bucket, 'either bucket or bucketPerModule must be specified');
     }

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

@@ -1,5 +1,5 @@
-import type { BucketItemStat, Client } from 'minio';
-import { ObjectStorage, type UploadObjectOptions } from '../../object-storage/index.js';
+import { type BucketItemStat, type Client } from 'minio';
+import { ObjectStorage, type CopyObjectOptions, type MoveObjectOptions, type ObjectStorageConfiguration, type UploadObjectOptions, type UploadUrlOptions } from '../../object-storage/index.js';
 import { S3Object } from './s3.object.js';
 export declare class S3ObjectStorage extends ObjectStorage {
     private readonly client;
@@ -9,9 +9,12 @@ export declare class S3ObjectStorage extends ObjectStorage {
     ensureBucketExists(region?: string, options?: {
         objectLocking?: boolean;
     }): Promise<void>;
+    configureBucket(configuration: ObjectStorageConfiguration): Promise<void>;
     exists(key: string): Promise<boolean>;
     statObject(key: string): Promise<BucketItemStat>;
     uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    copyObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<void>;
+    moveObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<void>;
     getContent(key: string): Promise<Uint8Array>;
     getContentStream(key: string): ReadableStream<Uint8Array>;
     getObjects(): Promise<S3Object[]>;
@@ -19,7 +22,7 @@ export declare class S3ObjectStorage extends ObjectStorage {
     getObject(key: string): Promise<S3Object>;
     getResourceUri(key: string): Promise<string>;
     getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
-    getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    getUploadUrl(key: string, expirationTimestamp: number, options?: UploadUrlOptions): Promise<string>;
     deleteObject(key: string): Promise<void>;
     deleteObjects(keys: string[]): Promise<void>;
     private getResourceUriSync;