@tstdl/base 0.92.160 → 0.92.162

package/api/types.d.ts

@@ -92,9 +92,9 @@ export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> =
 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 typeof DataStream<infer U> ? AsyncIterable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
-export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array> : T extends typeof DataStream<infer U> ? Observable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream;
+export type ApiInputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array<ArrayBuffer>> : T extends ApiBinaryType ? InstanceType<T> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends typeof DataStream<infer U> ? AsyncIterable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array<ArrayBuffer>> : T extends typeof DataStream<infer U> ? Observable<U> : 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>>;

package/authentication/models/authentication-credentials.model.d.ts

@@ -5,9 +5,9 @@ export declare class AuthenticationCredentials extends Entity {
     /**
      * The salt used to hash the secret.
      */
-    salt: Uint8Array;
+    salt: Uint8Array<ArrayBuffer>;
     /**
      * The hashed secret.
      */
-    hash: Uint8Array;
+    hash: Uint8Array<ArrayBuffer>;
 }

package/authentication/models/authentication-session.model.d.ts

@@ -8,9 +8,9 @@ export declare class AuthenticationSession extends Entity {
     /**
      * The salt used to hash the refresh token.
      */
-    refreshTokenSalt: Uint8Array;
+    refreshTokenSalt: Uint8Array<ArrayBuffer>;
     /**
      * The hashed refresh token.
      */
-    refreshTokenHash: Uint8Array;
+    refreshTokenHash: Uint8Array<ArrayBuffer>;
 }

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

@@ -34,10 +34,10 @@ export declare class AuthenticationServiceOptions {
      * Secrets used for signing tokens and refreshTokens.
      * If single secret is provided, multiple secrets are derived internally.
      */
-    secret: string | BinaryData | {
-        tokenSigningSecret: Uint8Array;
-        refreshTokenSigningSecret: Uint8Array;
-        secretResetTokenSigningSecret: Uint8Array;
+    secret: string | BinaryData<ArrayBuffer> | {
+        tokenSigningSecret: Uint8Array<ArrayBuffer>;
+        refreshTokenSigningSecret: Uint8Array<ArrayBuffer>;
+        secretResetTokenSigningSecret: Uint8Array<ArrayBuffer>;
     };
     /**
      * Token version, forces refresh on mismatch (useful if payload changes).
@@ -108,8 +108,8 @@ type CreateTokenResult<AdditionalTokenPayload extends Record> = {
 type CreateRefreshTokenResult = {
     token: string;
     jsonToken: RefreshToken;
-    salt: Uint8Array;
-    hash: Uint8Array;
+    salt: Uint8Array<ArrayBuffer>;
+    hash: Uint8Array<ArrayBuffer>;
 };
 /**
  * Handles authentication on server side.

package/authentication/server/authentication.service.js

@@ -325,7 +325,7 @@ let AuthenticationService = class AuthenticationService {
     async changeSecret(subject, currentSecret, newSecret) {
         const authenticationResult = await this.authenticate(subject, currentSecret);
         if (!authenticationResult.success) {
-            throw new ForbiddenError('Invalid credentials.');
+            throw new InvalidCredentialsError();
         }
         await this.hooks.beforeChangeSecret.trigger({ subject });
         await this.setCredentials(subject, newSecret);

package/authentication/server/helper.d.ts

@@ -17,7 +17,7 @@ export declare function tryGetAuthorizationTokenStringFromRequest(request: HttpS
  * @returns The token or undefined if not found.
  * @throws {InvalidTokenError} If the token is invalid.
  */
-export declare function tryGetTokenFromRequest<AdditionalTokenPayload extends Record = Record<never>>(request: HttpServerRequest, tokenVersion: number, secret: string | BinaryData): Promise<Token<AdditionalTokenPayload> | undefined>;
+export declare function tryGetTokenFromRequest<AdditionalTokenPayload extends Record = Record<never>>(request: HttpServerRequest, tokenVersion: number, secret: string | BinaryData<ArrayBuffer>): Promise<Token<AdditionalTokenPayload> | undefined>;
 /**
  * Gets a token from a request.
  * @param request The request to get the token from.
@@ -26,7 +26,7 @@ export declare function tryGetTokenFromRequest<AdditionalTokenPayload extends Re
  * @returns The token.
  * @throws {InvalidTokenError} If the token is invalid or not found.
  */
-export declare function getTokenFromRequest<AdditionalTokenPayload extends Record = Record<never>>(request: HttpServerRequest, tokenVersion: number, secret: string | BinaryData): Promise<Token<AdditionalTokenPayload>>;
+export declare function getTokenFromRequest<AdditionalTokenPayload extends Record = Record<never>>(request: HttpServerRequest, tokenVersion: number, secret: string | BinaryData<ArrayBuffer>): Promise<Token<AdditionalTokenPayload>>;
 /**
  * Gets a token from a token string.
  * @param tokenString The token string to get the token from.
@@ -35,7 +35,7 @@ export declare function getTokenFromRequest<AdditionalTokenPayload extends Recor
  * @returns The token.
  * @throws {InvalidTokenError} If the token is invalid.
  */
-export declare function getTokenFromString<AdditionalTokenPayload extends Record = Record<never>>(tokenString: string, tokenVersion: number, secret: string | BinaryData): Promise<Token<AdditionalTokenPayload>>;
+export declare function getTokenFromString<AdditionalTokenPayload extends Record = Record<never>>(tokenString: string, tokenVersion: number, secret: string | BinaryData<ArrayBuffer>): Promise<Token<AdditionalTokenPayload>>;
 /**
  * Gets a refresh token from a token string.
  * @param tokenString The token string to get the refresh token from.
@@ -43,7 +43,7 @@ export declare function getTokenFromString<AdditionalTokenPayload extends Record
  * @returns The refresh token.
  * @throws {InvalidTokenError} If the refresh token is invalid.
  */
-export declare function getRefreshTokenFromString(tokenString: string, secret: string | BinaryData): Promise<RefreshToken>;
+export declare function getRefreshTokenFromString(tokenString: string, secret: string | BinaryData<ArrayBuffer>): Promise<RefreshToken>;
 /**
  * Gets a secret reset token from a token string.
  * @param tokenString The token string to get the secret reset token from.
@@ -51,4 +51,4 @@ export declare function getRefreshTokenFromString(tokenString: string, secret: s
  * @returns The secret reset token.
  * @throws {InvalidTokenError} If the secret reset token is invalid.
  */
-export declare function getSecretResetTokenFromString(tokenString: string, secret: string | BinaryData): Promise<SecretResetToken>;
+export declare function getSecretResetTokenFromString(tokenString: string, secret: string | BinaryData<ArrayBuffer>): Promise<SecretResetToken>;

package/authentication/server/helper.js

@@ -38,7 +38,7 @@ export async function tryGetTokenFromRequest(request, tokenVersion, secret) {
     if (isUndefined(tokenString)) {
         return undefined;
     }
-    return getTokenFromString(tokenString, tokenVersion, secret);
+    return await getTokenFromString(tokenString, tokenVersion, secret);
 }
 /**
  * Gets a token from a request.

package/document-management/server/services/document-file.service.d.ts

@@ -21,11 +21,11 @@ export declare class DocumentFileService extends Transactional {
         uploadId: string;
         uploadUrl: string;
     }>;
-    store(documentId: string, content: Uint8Array | ReadableStream<Uint8Array>): Promise<DocumentFileMetadata>;
+    store(documentId: string, content: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>>): Promise<DocumentFileMetadata>;
     store(documentId: string, content: {
         uploadId: string;
         uploadKey: string;
-    }): Promise<[DocumentFileMetadata, Uint8Array]>;
+    }): Promise<[DocumentFileMetadata, Uint8Array<ArrayBuffer>]>;
     getContent(document: Document): Promise<Uint8Array>;
     getContentStream(document: Document): ReadableStream<Uint8Array>;
     getContentUrl(document: Document, download?: boolean): Promise<string>;

package/document-management/server/services/document.service.d.ts

@@ -5,7 +5,7 @@ import type { CreateDocumentParameters, SetDocumentPropertyParameters, UpdateDoc
 export declare class DocumentService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
-    create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array | ReadableStream<Uint8Array> | {
+    create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>> | {
         uploadId: string;
         uploadKey: string;
     }, { createUserId }: {

package/errors/errors.localization.js

@@ -8,65 +8,65 @@ export const germanTstdlErrorsLocalization = {
         tstdl: {
             errors: {
                 ApiError: {
-                    header: 'API Fehler',
-                    message: 'Bitte versuchen Sie es später noch einmal.'
+                    header: 'Ein Serverfehler ist aufgetreten',
+                    message: 'Bitte versuchen Sie es in einem Moment erneut. Sollte das Problem weiterhin bestehen, kontaktieren Sie bitte den Support.',
                 },
                 BadRequestError: {
-                    header: 'Ungültige Anfrage',
-                    message: getErrorMessage
+                    header: 'Ungültige Eingabe',
+                    message: 'Bitte überprüfen Sie die eingegebenen Daten und versuchen Sie es erneut.',
                 },
                 ForbiddenError: {
-                    header: 'Zugriff nicht erlaubt',
-                    message: getErrorMessage
+                    header: 'Zugriff verweigert',
+                    message: 'Sie haben nicht die erforderlichen Berechtigungen, um diese Aktion auszuführen.',
                 },
                 InvalidCredentialsError: {
                     header: 'Ungültige Zugangsdaten',
-                    message: 'Überprüfen Sie Ihre Eingaben'
+                    message: 'Der Benutzername oder das Passwort ist falsch. Bitte überprüfen Sie Ihre Eingaben.',
                 },
                 InvalidTokenError: {
-                    header: 'Anmeldung abgelaufen oder ungültig',
-                    message: 'Bitte melden Sie sich erneut an'
+                    header: 'Sitzung abgelaufen',
+                    message: 'Ihre Sitzung ist abgelaufen oder ungültig. Bitte melden Sie sich erneut an.',
                 },
                 MaxBytesExceededError: {
-                    header: 'Daten größer als erlaubt',
-                    message: getErrorMessage
+                    header: 'Datei zu groß',
+                    message: 'Die ausgewählte Datei überschreitet die maximal zulässige Größe.',
                 },
                 MethodNotAllowedError: {
-                    header: 'Anfrage nicht erlaubt',
-                    message: getErrorMessage
+                    header: 'Unerwarteter Fehler',
+                    message: 'Ein interner Fehler ist aufgetreten. Bitte versuchen Sie es später erneut.',
                 },
                 NotFoundError: {
                     header: 'Nicht gefunden',
-                    message: getErrorMessage
+                    message: 'Das gesuchte Element konnte nicht gefunden werden. Möglicherweise wurde es verschoben oder gelöscht.',
                 },
                 NotImplementedError: {
-                    header: 'Funktion nicht implementiert',
-                    message: getErrorMessage
+                    header: 'Funktion nicht verfügbar',
+                    message: 'Diese Funktion ist noch nicht verfügbar. Bitte versuchen Sie es zu einem späteren Zeitpunkt erneut.',
                 },
                 NotSupportedError: {
-                    header: 'Nicht unterstützt',
-                    message: getErrorMessage
+                    header: 'Aktion nicht unterstützt',
+                    message: 'Die angeforderte Aktion wird nicht unterstützt.',
                 },
                 TimeoutError: {
-                    header: 'Zeitüberschreitung',
-                    message: getErrorMessage
+                    header: 'Zeitüberschreitung der Anfrage',
+                    message: 'Der Server hat zu lange für eine Antwort gebraucht. Bitte überprüfen Sie Ihre Internetverbindung und versuchen Sie es erneut.',
                 },
                 UnauthorizedError: {
-                    header: 'Unautorisiert',
-                    message: getErrorMessage
+                    header: 'Anmeldung erforderlich',
+                    message: 'Sie müssen angemeldet sein, um diese Aktion auszuführen. Bitte melden Sie sich an.',
                 },
                 HttpError: {
                     header: (error) => ((isDefined(error.response) && error.response.statusCode != 0)
-                        ? `Http Fehler - ${error.response.statusCode.toString()}`
-                        : 'Http Fehler'),
-                    message: getHttpErrorMessage
+                        ? `Fehler ${error.response.statusCode.toString()}`
+                        : 'Verbindungsfehler'),
+                    message: getHttpErrorMessage,
                 },
                 SecretRequirementsError: {
-                    header: 'Passwortanforderungen nicht erfüllt',
-                    message: getErrorMessage
-                }
-            }
-        }
+                    header: 'Passwort zu schwach',
+                    message: getErrorMessage,
+                },
+            },
+        },
     },
     enums: [
         enumerationLocalization(HttpErrorReason, {
@@ -77,9 +77,9 @@ export const germanTstdlErrorsLocalization = {
             [HttpErrorReason.StatusCode]: 'Antwort enthielt einen Fehler',
             [HttpErrorReason.ErrorResponse]: 'Antwort enthielt einen Fehler',
             [HttpErrorReason.ResponseError]: 'Fehler beim Empfang der Antwort',
-            [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
-        })
-    ]
+            [HttpErrorReason.Timeout]: 'Zeitüberschreitung',
+        }),
+    ],
 };
 export const englishTstdlErrorsLocalization = {
     language: { code: 'en', name: 'English' },
@@ -87,65 +87,65 @@ export const englishTstdlErrorsLocalization = {
         tstdl: {
             errors: {
                 ApiError: {
-                    header: 'API error',
-                    message: 'Please try again later'
+                    header: 'A Server Error Occurred',
+                    message: 'Please try again in a moment. If the problem persists, please contact support.',
                 },
                 BadRequestError: {
-                    header: 'Bad Request',
-                    message: getErrorMessage
+                    header: 'Invalid Information',
+                    message: 'Please check the information you entered and try again.',
                 },
                 ForbiddenError: {
-                    header: 'Access forbidden',
-                    message: getErrorMessage
+                    header: 'Permission Denied',
+                    message: 'You do not have the necessary permissions to perform this action.',
                 },
                 InvalidCredentialsError: {
-                    header: 'Invalid credentials',
-                    message: 'Check your inputs'
+                    header: 'Invalid Credentials',
+                    message: 'The username or password you entered is incorrect. Please check your details.',
                 },
                 InvalidTokenError: {
-                    header: 'Login expired or invalid',
-                    message: 'Please log in again'
+                    header: 'Session Expired',
+                    message: 'Your session has expired or is invalid. Please log in again.',
                 },
                 MaxBytesExceededError: {
-                    header: 'Data larger than allowed',
-                    message: getErrorMessage
+                    header: 'File Too Large',
+                    message: 'The selected file exceeds the maximum allowed size.',
                 },
                 MethodNotAllowedError: {
-                    header: 'Request not allowed',
-                    message: getErrorMessage
+                    header: 'Unexpected Error',
+                    message: 'An internal error occurred. Please try again later.',
                 },
                 NotFoundError: {
-                    header: 'Not found',
-                    message: getErrorMessage
+                    header: 'Not Found',
+                    message: 'The item you are looking for could not be found. It may have been moved or deleted.',
                 },
                 NotImplementedError: {
-                    header: 'Function not implemented',
-                    message: getErrorMessage
+                    header: 'Feature Not Available',
+                    message: 'This feature is not yet available. Please check back later.',
                 },
                 NotSupportedError: {
-                    header: 'Not supported',
-                    message: getErrorMessage
+                    header: 'Unsupported Action',
+                    message: 'The requested action is not supported.',
                 },
                 TimeoutError: {
-                    header: 'Timeout',
-                    message: getErrorMessage
+                    header: 'Request Timed Out',
+                    message: 'The server took too long to respond. Please check your internet connection and try again.',
                 },
                 UnauthorizedError: {
-                    header: 'Unauthorized',
-                    message: getErrorMessage
+                    header: 'Authentication Required',
+                    message: 'You must be logged in to perform this action. Please log in.',
                 },
                 HttpError: {
                     header: (error) => ((isDefined(error.response) && error.response.statusCode != 0)
-                        ? `Http error - ${error.response.statusCode.toString()}`
-                        : 'Http error'),
-                    message: getHttpErrorMessage
+                        ? `Error ${error.response.statusCode.toString()}`
+                        : 'Connection Error'),
+                    message: getHttpErrorMessage,
                 },
                 SecretRequirementsError: {
-                    header: 'Secret requirements not met',
-                    message: getErrorMessage
-                }
-            }
-        }
+                    header: 'Password Is Too Weak',
+                    message: getErrorMessage,
+                },
+            },
+        },
     },
     enums: [
         enumerationLocalization(HttpErrorReason, {
@@ -156,14 +156,15 @@ export const englishTstdlErrorsLocalization = {
             [HttpErrorReason.StatusCode]: 'Response contained an error',
             [HttpErrorReason.ErrorResponse]: 'Response contained an error',
             [HttpErrorReason.ResponseError]: 'Error while receiving the response',
-            [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
-        })
-    ]
+            [HttpErrorReason.Timeout]: 'Timeout',
+        }),
+    ],
 };
 function getHttpErrorMessage(error, context) {
-    return (isDefined(error.response) && (isNotNull(error.response.statusMessage)))
-        ? error.response.statusMessage
-        : context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason });
+    if (isDefined(error.response) && isNotNull(error.response.statusMessage)) {
+        return error.response.statusMessage;
+    }
+    return context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason });
 }
 function getErrorMessage(error) {
     return error.message.replace(/\.$/u, '');

package/http/client/http-client-request.d.ts

@@ -22,7 +22,7 @@ export type HttpRequestAuthorization = {
     bearer?: string;
     token?: string;
 };
-export type HttpFormDataObjectValue = string | number | boolean | Uint8Array | Blob;
+export type HttpFormDataObjectValue = string | number | boolean | Uint8Array<ArrayBuffer> | Blob;
 export type HttpFormDataObject = Record<string, OneOrMany<HttpFormDataObjectValue>>;
 export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortSignal' | 'abort' | 'headers' | 'query' | 'body'>> & {
     urlParameter?: HttpUrlParametersObject | HttpUrlParameters;

package/http/http-body.d.ts

@@ -2,7 +2,7 @@ import type { UndefinableJson } from '../types/index.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import type { HttpHeaders } from './http-headers.js';
 import type { ReadBodyOptions } from './utils.js';
-export type HttpBodySource = undefined | Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
+export type HttpBodySource = undefined | Uint8Array<ArrayBuffer> | Blob | AnyIterable<Uint8Array<ArrayBuffer>> | ReadableStream<Uint8Array<ArrayBuffer>>;
 export declare class HttpBody {
     private readonly body;
     private readonly headers;
@@ -10,7 +10,7 @@ export declare class HttpBody {
     get available(): boolean;
     get byteLength(): number | undefined;
     constructor(body: HttpBodySource, headers: HttpHeaders);
-    readAsBuffer(options?: ReadBodyOptions): Promise<Uint8Array>;
+    readAsBuffer(options?: ReadBodyOptions): Promise<Uint8Array<ArrayBuffer>>;
     readAsText(options?: ReadBodyOptions): Promise<string>;
     readAsJson<T = UndefinableJson>(options?: ReadBodyOptions): Promise<T>;
     read(options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;

package/http/server/node/node-http-server.js

@@ -145,7 +145,7 @@ function writeHeaders(response, httpResponse) {
 }
 async function writeResponseBody(response, httpResponse) {
     const simpleData = match(response.body)
-        .with({ json: P.select(P.nonNullable) }, (json) => JSON.stringify(json))
+        .with({ json: P.select(P.when(isDefined)) }, (json) => JSON.stringify(json))
         .with({ text: P.select(P.nonNullable) }, (text) => text)
         .with({ buffer: P.select(P.nonNullable) }, (buffer) => buffer)
         .otherwise(() => undefined);

package/http/utils.d.ts

@@ -1,15 +1,15 @@
 import type { HttpHeaders } from '../http/http-headers.js';
 import type { UndefinableJson } from '../types/index.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
-type Body = Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
+type Body = Uint8Array<ArrayBuffer> | Blob | AnyIterable<Uint8Array<ArrayBuffer>> | ReadableStream<Uint8Array<ArrayBuffer>>;
 export type ReadBodyOptions = {
     maxBytes?: number;
 };
 export type ReadBodyAsJsonOptions = ReadBodyOptions & {
     fallbackToText?: boolean;
 };
-export declare function readBodyAsBinaryStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<Uint8Array>;
-export declare function readBodyAsBuffer(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<Uint8Array>;
+export declare function readBodyAsBinaryStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function readBodyAsBuffer(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<Uint8Array<ArrayBuffer>>;
 export declare function readBodyAsText(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string>;
 export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string>;
 export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;

package/image-service/imgproxy/imgproxy-image-service.js

@@ -58,7 +58,7 @@ let ImgproxyImageService = class ImgproxyImageService extends ImageService {
 };
 ImgproxyImageService = __decorate([
     Singleton({
-        defaultArgumentProvider: (context) => context.resolve(IMGPROXY_IMAGE_SERVICE_CONFIG)
+        defaultArgumentProvider: (context) => context.resolve(IMGPROXY_IMAGE_SERVICE_CONFIG),
     }),
     __param(0, InjectArg('endpoint')),
     __param(1, InjectArg('key')),

package/injector/injector.js

@@ -271,7 +271,7 @@ export class Injector {
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
             assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
+            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;
@@ -296,7 +296,7 @@ export class Injector {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
+            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;

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

@@ -87,12 +87,12 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * Get object content
      * @param key object key
      */
-    abstract getContent(key: string): Promise<Uint8Array>;
+    abstract getContent(key: string): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * Get stream of object content
      * @param key object key
      */
-    abstract getContentStream(key: string): ReadableStream<Uint8Array>;
+    abstract getContentStream(key: string): ReadableStream<Uint8Array<ArrayBuffer>>;
     /**
      * Get an url which can be used to download the object without further authorization
      * @param key object key

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

@@ -15,8 +15,8 @@ export declare class S3ObjectStorage extends ObjectStorage {
     uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     copyObject(source: string, destination: 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>;
+    getContent(key: string): Promise<Uint8Array<ArrayBuffer>>;
+    getContentStream(key: string): ReadableStream<Uint8Array<ArrayBuffer>>;
     getObjects(): Promise<S3Object[]>;
     getObjectsCursor(): AsyncIterable<S3Object>;
     getObject(key: string): Promise<S3Object>;

package/orm/server/encryption.d.ts

@@ -5,7 +5,7 @@
  * @param key The CryptoKey to use for encryption.
  * @returns A promise that resolves to the encrypted byte array (version + IV + ciphertext).
  */
-export declare function encryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+export declare function encryptBytes(bytes: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<Uint8Array>;
 /**
  * Decrypts a byte array encrypted with `encryptBytes`.
  * Reads the version and IV from the beginning of the array.
@@ -15,4 +15,4 @@ export declare function encryptBytes(bytes: Uint8Array, key: CryptoKey): Promise
  * @throws {DetailsError} If decryption fails (e.g., wrong key, corrupted data).
  * @throws {Error} If the encryption version is invalid.
  */
-export declare function decryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+export declare function decryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>;

package/orm/server/repository.d.ts

@@ -1,8 +1,7 @@
 import { SQL } from 'drizzle-orm';
 import type { PgColumn, PgInsertValue, PgUpdateSetSource } from 'drizzle-orm/pg-core';
 import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Type } from '../../types/index.js';
-import type { UntaggedDeep } from '../../types/index.js';
+import type { DeepPartial, OneOrMany, Paths, Type, UntaggedDeep } from '../../types/index.js';
 import { Entity, type EntityMetadataAttributes, type EntityType, type EntityWithoutMetadata } from '../entity.js';
 import type { Query } from '../query.js';
 import type { EntityMetadataUpdate, EntityUpdate, LoadManyOptions, LoadOptions, NewEntity, Order, TargetColumnPaths } from '../repository.types.js';
@@ -24,7 +23,7 @@ type EntityRepositoryContext = {
     table: PgTableFromType;
     columnDefinitions: ColumnDefinition[];
     columnDefinitionsMap: Map<string, ColumnDefinition>;
-    encryptionSecret: Uint8Array | undefined;
+    encryptionSecret: Uint8Array<ArrayBuffer> | undefined;
     transformContext: TransformContext | Promise<TransformContext> | undefined;
 };
 type InferSelect<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> = PgTableFromType<EntityType<T>>['$inferSelect'];

package/orm/server/tokens.d.ts

@@ -1 +1 @@
-export declare const ENCRYPTION_SECRET: import("../../injector/token.js").InjectionToken<Uint8Array<ArrayBufferLike>, never>;
+export declare const ENCRYPTION_SECRET: import("../../injector/token.js").InjectionToken<Uint8Array<ArrayBuffer>, never>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.160",
+  "version": "0.92.162",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -165,9 +165,9 @@
     "mongodb": "^6.18",
     "nodemailer": "^7.0",
     "pg": "^8.16",
-    "playwright": "^1.54",
+    "playwright": "^1.55",
     "preact": "^10.27",
-    "preact-render-to-string": "^6.5",
+    "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
     "undici": "^7.14",
     "urlpattern-polyfill": "^10.1"
@@ -196,7 +196,7 @@
     "typedoc-github-wiki-theme": "2.1",
     "typedoc-plugin-markdown": "4.8",
     "typedoc-plugin-missing-exports": "4.1",
-    "typescript": "5.8",
+    "typescript": "5.9",
     "typescript-eslint": "8.40"
   },
   "overrides": {

package/process/spawn.js

@@ -33,16 +33,16 @@ export async function spawnCommand(command, args) {
         });
     }
     async function readOutputBytes() {
-        return readBinaryStream(readable);
+        return await readBinaryStream(readable);
     }
     async function readOutput() {
-        return readTextStream(readable.pipeThrough(decodeTextStream()));
+        return await readTextStream(readable.pipeThrough(decodeTextStream()));
     }
     async function readErrorBytes() {
-        return readBinaryStream(stderr);
+        return await readBinaryStream(stderr);
     }
     async function readError() {
-        return readTextStream(stderr.pipeThrough(decodeTextStream()));
+        return await readTextStream(stderr.pipeThrough(decodeTextStream()));
     }
     const signalPromise = new Promise((resolve) => process.on('close', (code, signal) => resolve({ code, signal })));
     const nonZeroExitCodeError = new LazyPromise(async () => {

package/types/types.d.ts

@@ -190,7 +190,7 @@ export type DeepPartialObject<T> = {
 };
 export type DeepPartialArray<T> = DeepPartial<T>[];
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export type BinaryData = ArrayBuffer | ArrayBufferView;
+export type BinaryData<T extends ArrayBufferLike = ArrayBufferLike> = ArrayBufferView<T> | T;
 export type Paths<T extends Record> = T extends object ? {
     [K in keyof T]-?: K extends string | number ? `${K}` | `${K}.${Paths<T[K]>}` : never;
 }[keyof T] : never;

package/utils/base64.d.ts

@@ -1,9 +1,9 @@
 import type { BinaryData } from '../types/index.js';
 export declare function encodeBase64(array: BinaryData, bytesOffset?: number, bytesLength?: number): string;
-export declare function decodeBase64(base64: string): Uint8Array;
+export declare function decodeBase64(base64: string): Uint8Array<ArrayBuffer>;
 export declare function encodeBase64Url(array: BinaryData, bytesOffset?: number, length?: number): string;
-export declare function decodeBase64Url(base64Url: string): Uint8Array;
+export declare function decodeBase64Url(base64Url: string): Uint8Array<ArrayBuffer>;
 export declare function base64ToBase64Url(input: string): string;
 export declare function base64UrlToBase64(input: string): string;
 export declare function utf8ArrayToString(bytes: Uint8Array): string;
-export declare function stringToUtf8Array(string: string): Uint8Array;
+export declare function stringToUtf8Array(string: string): Uint8Array<ArrayBuffer>;

package/utils/base64.js

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-magic-numbers, no-bitwise */
 import { supportsBuffer } from '../supports.js';
 import { toUint8Array } from './binary.js';
-import { isArrayBuffer, isDefined } from './type-guards.js';
+import { isArrayBufferLike, isDefined } from './type-guards.js';
 export function encodeBase64(array, bytesOffset, bytesLength) {
     let arrayBuffer;
     let offset;
     let length;
-    if (isArrayBuffer(array)) {
+    if (isArrayBufferLike(array)) {
         arrayBuffer = array;
     }
     else {

package/utils/binary.js

@@ -1,12 +1,12 @@
 import { supportsBuffer } from '../supports.js';
-import { assert, isArrayBuffer, isUint8Array } from './type-guards.js';
+import { assert, isArrayBufferLike, isUint8Array } from './type-guards.js';
 /**
  * Get ArrayBuffer from binary data
  * @param data data to get ArrayBuffer from
  * @param clone force cloning (might still clone if datas underlying buffer is larger than its view)
  */
 export function toArrayBuffer(data, clone = false) {
-    if (isArrayBuffer(data)) {
+    if (isArrayBufferLike(data)) {
         return clone ? data.slice(0) : data;
     }
     if (!clone && (data.byteOffset == 0) && (data.byteLength == data.buffer.byteLength)) {
@@ -20,7 +20,7 @@ export function toArrayBuffer(data, clone = false) {
  * @param clone whether to clone buffer or not
  */
 export function toUint8Array(data, clone = false) {
-    if (isArrayBuffer(data)) {
+    if (isArrayBufferLike(data)) {
         return clone
             ? new Uint8Array(data.slice(0))
             : new Uint8Array(data);

package/utils/compression.d.ts

@@ -1,7 +1,7 @@
 import type * as NodeStream from 'node:stream';
 import type * as NodeZlib from 'node:zlib';
 export interface CompressionResult {
-    toBuffer(): Promise<Uint8Array>;
+    toBuffer(): Promise<Uint8Array<ArrayBuffer>>;
     toHex(): Promise<string>;
     toBase64(): Promise<string>;
     toBase64Url(): Promise<string>;
@@ -23,6 +23,6 @@ export declare function decompressString(input: string, encoding: BufferEncoding
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): DecompressionResult;
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): DecompressionResult;
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult;
-export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): ReadableStream<Uint8Array>;
-export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;
-export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array<ArrayBuffer>>;

package/utils/cryptography.d.ts

@@ -10,7 +10,7 @@ export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
 export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
 export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
 export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-export type Key = JsonWebKey | BinaryData;
+export type Key = JsonWebKey | BinaryData<ArrayBuffer>;
 export type ScryptOptions = {
     cost?: number;
     blockSize?: number;
@@ -35,27 +35,27 @@ export type SignResult = CryptionResult;
  * @param key key
  * @param data data to encrypt. Encodes string to utf8
  */
-export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData | string): CryptionResult;
+export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): CryptionResult;
 /**
  * Decrypt data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to decrypt
  */
-export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData): DecryptionResult;
+export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData<ArrayBuffer>): DecryptionResult;
 /**
  * Hashes data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param data data to encrypt. Encodes string to utf8
  */
-export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData | string): DigestResult;
+export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData<ArrayBuffer> | string): DigestResult;
 /**
  * Signs data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to sign
  */
-export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData | string): SignResult;
+export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): SignResult;
 /**
  * Verifies data
  * @param algorithm algorithm as supported by Web Crypto API
@@ -63,7 +63,7 @@ export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: Bin
  * @param signature signature
  * @param data data to verify using provided signature
  */
-export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData | string, data: BinaryData | string): Promise<boolean>;
+export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData<ArrayBuffer> | string, data: BinaryData<ArrayBuffer> | string): Promise<boolean>;
 /**
  * Imports a HMAC CryptoKey
  * @param algorithm hash algorithm
@@ -91,7 +91,7 @@ export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, ext
  * @param key binary key
  * @param extractable whether the key can be used for exportKey
  */
-export declare function importPbkdf2Key(key: BinaryData | string, extractable?: boolean): Promise<CryptoKey>;
+export declare function importPbkdf2Key(key: BinaryData<ArrayBuffer> | string, extractable?: boolean): Promise<CryptoKey>;
 /**
  * Generates a new ECDSA CryptoKeyPair
  * @param curve ECDSA cruve to use
@@ -118,5 +118,5 @@ export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoK
  * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
  * @param count how many Uint8Arrays to derive
  */
-export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array, Lengths['length']>>;
-export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array, C>>;
+export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, Lengths['length']>>;
+export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, C>>;

package/utils/encoding.d.ts

@@ -4,11 +4,11 @@ import type { BinaryData } from '../types/index.js';
  * @param text text to encode
  * @returns utf8 encoded text
  */
-export declare function encodeUtf8(text: string): Uint8Array;
+export declare function encodeUtf8(text: string): Uint8Array<ArrayBuffer>;
 /**
  * Encodes text stream to utf8 bytes stream
  */
-export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
+export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array<ArrayBuffer>>;
 /**
  * Decodes buffer to string
  * @param buffer buffer to decode
@@ -33,4 +33,4 @@ export declare function encodeHex(buffer: BinaryData): string;
  * @param hex hex string to decode
  * @returns decoded buffer
  */
-export declare function decodeHex(hex: string): Uint8Array;
+export declare function decodeHex(hex: string): Uint8Array<ArrayBuffer>;

package/utils/jwt.d.ts

@@ -18,9 +18,9 @@ export type JwtTokenParseResult<T extends JwtToken = JwtToken> = {
         signature: string;
     };
     bytes: {
-        header: Uint8Array;
-        payload: Uint8Array;
-        signature: Uint8Array;
+        header: Uint8Array<ArrayBuffer>;
+        payload: Uint8Array<ArrayBuffer>;
+        signature: Uint8Array<ArrayBuffer>;
     };
     string: {
         header: string;

package/utils/random.d.ts

@@ -7,7 +7,7 @@
  * @param count number of bytes to get
  * @param allowUnsafe whether to allow sharing the underlying pool
  */
-export declare function getRandomBytes(count: number, allowUnsafe?: boolean): Uint8Array;
+export declare function getRandomBytes(count: number, allowUnsafe?: boolean): Uint8Array<ArrayBuffer>;
 /**
  * Generate a cryptographically secure random string (in terms of source of randomness).
  * @param length length of string

package/utils/stream/slice.js

@@ -31,7 +31,7 @@ export function sliceStream(stream, offset, length, type = 'bytes') {
             },
             async cancel(reason) {
                 await reader.cancel(reason);
-            }
+            },
         });
     }
     const byobReader = toBytesStream(stream).getReader({ mode: 'byob' });
@@ -70,6 +70,6 @@ export function sliceStream(stream, offset, length, type = 'bytes') {
         },
         async cancel(reason) {
             await byobReader.cancel(reason);
-        }
+        },
     });
 }

package/utils/stream/to-bytes-stream.d.ts

@@ -1,4 +1,4 @@
 export type ToBytesStreamOptions = {
     ignoreCancel?: boolean;
 };
-export declare function toBytesStream(stream: ReadableStream<ArrayBufferView>, options?: ToBytesStreamOptions): ReadableStream<Uint8Array>;
+export declare function toBytesStream(stream: ReadableStream<ArrayBufferView<ArrayBuffer>>, options?: ToBytesStreamOptions): ReadableStream<Uint8Array>;

package/utils/stream/to-bytes-stream.js

@@ -23,7 +23,7 @@ export function toBytesStream(stream, options) {
                 else {
                     await byobReader.cancel(reason);
                 }
-            }
+            },
         });
     }
     catch { /* Ignore */ }
@@ -72,6 +72,6 @@ export function toBytesStream(stream, options) {
             else {
                 await reader.cancel(reason);
             }
-        }
+        },
     });
 }

package/utils/type-guards.d.ts

@@ -131,6 +131,18 @@ export declare const assertArrayBuffer: AssertFunction<ArrayBuffer>;
 export declare const assertNotArrayBuffer: AssertNotFunction<ArrayBuffer>;
 export declare const assertArrayBufferPass: AssertPassFunction<ArrayBuffer>;
 export declare const assertNotArrayBufferPass: AssertNotPassFunction<ArrayBuffer>;
+export declare const isSharedArrayBuffer: IsFunction<SharedArrayBuffer>;
+export declare const isNotSharedArrayBuffer: IsNotFunction<SharedArrayBuffer>;
+export declare const assertSharedArrayBuffer: AssertFunction<SharedArrayBuffer>;
+export declare const assertNotSharedArrayBuffer: AssertNotFunction<SharedArrayBuffer>;
+export declare const assertSharedArrayBufferPass: AssertPassFunction<SharedArrayBuffer>;
+export declare const assertNotSharedArrayBufferPass: AssertNotPassFunction<SharedArrayBuffer>;
+export declare const isArrayBufferLike: IsFunction<ArrayBufferLike>;
+export declare const isNotArrayBufferLike: IsNotFunction<ArrayBufferLike>;
+export declare const assertArrayBufferLike: AssertFunction<ArrayBufferLike>;
+export declare const assertNotArrayBufferLike: AssertNotFunction<ArrayBufferLike>;
+export declare const assertArrayBufferLikePass: AssertPassFunction<ArrayBufferLike>;
+export declare const assertNotArrayBufferLikePass: AssertNotPassFunction<ArrayBufferLike>;
 export declare const isArrayBufferView: IsFunction<ArrayBufferView>;
 export declare const isNotArrayBufferView: IsNotFunction<ArrayBufferView>;
 export declare const assertArrayBufferView: AssertFunction<ArrayBufferView>;

package/utils/type-guards.js

@@ -188,6 +188,20 @@ export const assertArrayBuffer = arrayBufferGuards.assertArrayBuffer;
 export const assertNotArrayBuffer = arrayBufferGuards.assertNotArrayBuffer;
 export const assertArrayBufferPass = arrayBufferGuards.assertArrayBufferPass;
 export const assertNotArrayBufferPass = arrayBufferGuards.assertNotArrayBufferPass;
+const sharedArrayBufferGuards = createInstanceGuards('SharedArrayBuffer', SharedArrayBuffer);
+export const isSharedArrayBuffer = sharedArrayBufferGuards.isSharedArrayBuffer;
+export const isNotSharedArrayBuffer = sharedArrayBufferGuards.isNotSharedArrayBuffer;
+export const assertSharedArrayBuffer = sharedArrayBufferGuards.assertSharedArrayBuffer;
+export const assertNotSharedArrayBuffer = sharedArrayBufferGuards.assertNotSharedArrayBuffer;
+export const assertSharedArrayBufferPass = sharedArrayBufferGuards.assertSharedArrayBufferPass;
+export const assertNotSharedArrayBufferPass = sharedArrayBufferGuards.assertNotSharedArrayBufferPass;
+const arrayBufferLikeGuards = createGuards('ArrayBufferLike', (value) => isArrayBuffer(value) || isSharedArrayBuffer(value));
+export const isArrayBufferLike = arrayBufferLikeGuards.isArrayBufferLike;
+export const isNotArrayBufferLike = arrayBufferLikeGuards.isNotArrayBufferLike;
+export const assertArrayBufferLike = arrayBufferLikeGuards.assertArrayBufferLike;
+export const assertNotArrayBufferLike = arrayBufferLikeGuards.assertNotArrayBufferLike;
+export const assertArrayBufferLikePass = arrayBufferLikeGuards.assertArrayBufferLikePass;
+export const assertNotArrayBufferLikePass = arrayBufferLikeGuards.assertNotArrayBufferLikePass;
 const arrayBufferViewGuards = createGuards('ArrayBufferView', (value) => ArrayBuffer.isView(value));
 export const isArrayBufferView = arrayBufferViewGuards.isArrayBufferView;
 export const isNotArrayBufferView = arrayBufferViewGuards.isNotArrayBufferView;
@@ -195,7 +209,7 @@ export const assertArrayBufferView = arrayBufferViewGuards.assertArrayBufferView
 export const assertNotArrayBufferView = arrayBufferViewGuards.assertNotArrayBufferView;
 export const assertArrayBufferViewPass = arrayBufferViewGuards.assertArrayBufferViewPass;
 export const assertNotArrayBufferViewPass = arrayBufferViewGuards.assertNotArrayBufferViewPass;
-const binaryDataGuards = createGuards('BinaryData', (value) => (isArrayBuffer(value) || isArrayBufferView(value)));
+const binaryDataGuards = createGuards('BinaryData', (value) => (isArrayBufferLike(value) || isArrayBufferView(value)));
 export const isBinaryData = binaryDataGuards.isBinaryData;
 export const isNotBinaryData = binaryDataGuards.isNotBinaryData;
 export const assertBinaryData = binaryDataGuards.assertBinaryData;