@tstdl/base 0.86.0-beta9 → 0.86.1

package/injector/provider.d.ts

@@ -1,23 +1,23 @@
 import type { Constructor, Record, TypedOmit } from '../types.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
-import type { ResolveContext } from './types.js';
-export type Factory<T, A = any, C extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<C>) => T;
+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 ProviderWithArgument<T, A> = {
     defaultArgument?: ResolveArgument<T, A>;
     defaultArgumentProvider?: () => ResolveArgument<T, A>;
 };
-export type ProviderWithInitializer<T, A, C extends Record> = {
-    afterResolve?: (value: T, argument: A, context: C) => void | Promise<void>;
+export type ProviderWithInitializer<T, A, D extends Record> = {
+    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
 };
-export type Provider<T = any, A = any, C extends Record = Record> = ClassProvider<T, A, C> | ValueProvider<T> | TokenProvider<T, A, C> | FactoryProvider<T, A, C>;
-export type ClassProvider<T = any, A = any, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & {
+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 ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useClass: Constructor<T>;
 };
 export type ValueProvider<T = any> = {
     useValue: T;
 };
-export type TokenProvider<T = any, A = any, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & ({
+export type TokenProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & ({
     useToken: InjectionToken<T, A>;
     useTokenProvider?: undefined;
 } | {
@@ -29,13 +29,13 @@ export type TokenProvider<T = any, A = any, C extends Record = Record> = Provide
      */
     resolveAll?: boolean;
 };
-export type FactoryProvider<T = any, A = unknown, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & {
-    useFactory: Factory<T, A, C>;
+export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+    useFactory: Factory<T, A, D>;
 };
-export declare function classProvider<T, A, C extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, C>, 'useClass'>): ClassProvider<T, A, C>;
+export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;
 export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
-export declare function tokenProvider<T, A, C extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, C>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
-export declare function factoryProvider<T, A, C extends Record>(factory: Factory<T, A, C>, options?: TypedOmit<FactoryProvider<T, A, C>, 'useFactory'>): FactoryProvider<T, A, C>;
+export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
+export declare function factoryProvider<T, A, D extends Record>(factory: Factory<T, A, D>, options?: TypedOmit<FactoryProvider<T, A, D>, 'useFactory'>): FactoryProvider<T, A, D>;
 export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;
 export declare function isClassProvider<T, A>(value: unknown): value is ClassProvider<T, A>;
 export declare function isValueProvider<T>(value: Provider<T>): value is ValueProvider<T>;

package/injector/resolve.error.d.ts

@@ -1,5 +1,5 @@
 import { CustomError } from '../error/custom.error.js';
-import { ResolveChain } from './resolve-chain.js';
+import type { ResolveChain } from './resolve-chain.js';
 export declare class ResolveError extends CustomError {
     constructor(message: string, chain: ResolveChain, cause?: Error);
 }

package/injector/types.d.ts

@@ -1,5 +1,6 @@
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
+import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { Injector } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
@@ -10,12 +11,18 @@ import type { InjectionToken } from './token.js';
  * singleton: one resolution at injector where token is registered
  */
 export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
-export type ResolveContext<C extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
-    context: ResolutionContext<C>;
+export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationToken: ReadonlyCancellationToken;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type AfterResolveContext<D extends Record> = {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationToken: ReadonlyCancellationToken;
     addDisposeHandler(handler: AsyncDisposeHandler): void;
 };
 export type Mapper<T = any, U = unknown> = (value: T) => U;
-export type ArgumentProvider<T = unknown, C extends Record = Record> = (context: ResolveContext<C>) => T;
+export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
 export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
 export type ResolveOptions = {
     optional?: boolean;
@@ -25,13 +32,13 @@ export type ResolveOptions = {
 /**
  * data to store between different stages like resolve and afterResolve
  */
-export type ResolutionContext<T extends Record> = T;
-export type RegistrationOptions<T, A = unknown, C extends Record = Record> = {
+export type ResolveContextData<T extends Record> = T;
+export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     lifecycle?: Lifecycle;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
     defaultArgument?: ResolveArgument<T, A>;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, C>;
+    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, D>;
     /**
      * Value to distinguish scoped and singleton instances based on argument
      * by default it uses strict equality (===) on the original argument,
@@ -43,7 +50,9 @@ export type RegistrationOptions<T, A = unknown, C extends Record = Record> = {
      */
     argumentIdentityProvider?: Mapper<ResolveArgument<T, A>>;
     /** Function which gets called after a resolve */
-    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: ResolutionContext<C>) => any;
+    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
     /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
     multi?: boolean;
+    /** custom metadata */
+    metadata?: Record;
 };

package/logger/console/logger.js

@@ -79,9 +79,9 @@ ConsoleLogger = ConsoleLogger_1 = __decorate([
     provider: {
       useFactory: (argument, context) => {
         if ((0, import_type_guards.isObject)(argument)) {
-          return new ConsoleLogger_1(argument.level ?? context.resolve(import_level.LogLevel), argument.module, argument.prefix);
+          return new ConsoleLogger(argument.level ?? context.resolve(import_level.LogLevel), argument.module, argument.prefix);
         }
-        return new ConsoleLogger_1(context.resolve(import_level.LogLevel), argument, void 0);
+        return new ConsoleLogger(context.resolve(import_level.LogLevel), argument, void 0);
       }
     }
   }),

package/module/modules/web-server.module.js

@@ -24,7 +24,6 @@ __export(web_server_module_exports, {
 });
 module.exports = __toCommonJS(web_server_module_exports);
 var import_server = require("../../api/server/index.js");
-var import_log = require("../../decorators/log.js");
 var import_disposable = require("../../disposable/disposable.js");
 var import_http_server = require("../../http/server/http-server.js");
 var import_decorators = require("../../injector/decorators.js");
@@ -87,7 +86,6 @@ let WebServerModule = class WebServerModule2 extends import_module_base.ModuleBa
 };
 WebServerModule = __decorate([
   (0, import_decorators.Singleton)({ defaultArgumentProvider: () => webServerModuleConfiguration }),
-  (0, import_log.Log)(),
   __metadata("design:paramtypes", [])
 ], WebServerModule);
 function configureWebServerModule(config) {

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

@@ -4,5 +4,5 @@ export declare abstract class ObjectStorageProvider<T extends ObjectStorage = Ob
      * get an object storage instance
      * @param module name for object container (module) to store objects in. Can be used to isolate objects like profile pictures and log files
      */
-    abstract get(module: string): T | Promise<T>;
+    abstract get(module: string): T;
 }

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

@@ -17,10 +17,6 @@ export declare class S3ObjectStorageProviderConfig {
      * mutually exclusive with bucket
      */
     bucketPerModule?: boolean;
-    /**
-     * create bucket for requested storage module if it does not exist
-     */
-    autoCreateBucket?: boolean;
     /**
      * s3 access key
      */
@@ -34,9 +30,8 @@ export declare const bucketPerModule: unique symbol;
 export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
     private readonly client;
     private readonly bucket;
-    private readonly createBucket;
     constructor(config: S3ObjectStorageProviderConfig);
-    get(module: string): Promise<S3ObjectStorage>;
+    get(module: string): S3ObjectStorage;
 }
 /**
  * configure s3 object storage provider

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

@@ -61,10 +61,6 @@ class S3ObjectStorageProviderConfig {
    * mutually exclusive with bucket
    */
   bucketPerModule;
-  /**
-   * create bucket for requested storage module if it does not exist
-   */
-  autoCreateBucket;
   /**
    * s3 access key
    */
@@ -78,14 +74,12 @@ const bucketPerModule = Symbol("bucket per module");
 let S3ObjectStorageProvider = class S3ObjectStorageProvider2 extends import_object_storage.ObjectStorageProvider {
   client;
   bucket;
-  createBucket;
   constructor(config) {
     super();
     const { hostname, port, protocol } = new URL(config.endpoint);
     if ((0, import_type_guards.isDefined)(config.bucket) && config.bucketPerModule == true) {
       throw new Error("bucket and bucketPerModule is mutually exclusive");
     }
-    this.createBucket = config.autoCreateBucket ?? false;
     this.client = new import_minio.Client({
       endPoint: hostname,
       port: port.length > 0 ? parseInt(port, 10) : void 0,
@@ -95,14 +89,10 @@ let S3ObjectStorageProvider = class S3ObjectStorageProvider2 extends import_obje
     });
     this.bucket = (0, import_type_guards.assertDefinedPass)(config.bucketPerModule == true ? true : config.bucket, "either bucket or bucketPerModule must be specified");
   }
-  async get(module2) {
+  get(module2) {
     const bucket = this.bucket == true ? module2 : (0, import_type_guards.assertStringPass)(this.bucket);
     const prefix = this.bucket == true ? "" : module2 == "" ? "" : `${module2}/`;
-    const objectStorage = new import_s3_object_storage.S3ObjectStorage(this.client, bucket, module2, prefix);
-    if (this.createBucket) {
-      await objectStorage.ensureBucketExists();
-    }
-    return objectStorage;
+    return new import_s3_object_storage.S3ObjectStorage(this.client, bucket, module2, prefix);
   }
 };
 S3ObjectStorageProvider = __decorate([

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

@@ -152,7 +152,10 @@ let S3ObjectStorage = class S3ObjectStorage2 extends import_object_storage.Objec
 S3ObjectStorage = __decorate([
   (0, import_decorators.Singleton)({
     provider: {
-      useFactory: async (argument, context) => context.resolve(import_s3_object_storage_provider.S3ObjectStorageProvider).get((0, import_type_guards.assertStringPass)(argument, "resolve argument must be a string (object storage module)"))
+      useFactory: (argument, context) => context.resolve(import_s3_object_storage_provider.S3ObjectStorageProvider).get((0, import_type_guards.assertStringPass)(argument, "resolve argument must be a string (object storage module)")),
+      async afterResolve(value) {
+        await value.ensureBucketExists();
+      }
     }
   }),
   __metadata("design:paramtypes", [import_minio.Client, String, String, String])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.86.0-beta9",
+  "version": "0.86.1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -20,10 +20,11 @@
     "tsc-alias:watch": "tsc-alias --watch"
   },
   "dependencies": {
+    "disposablestack": "^1.1.1",
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^4.2"
+    "type-fest": "^4.3"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",
@@ -37,17 +38,17 @@
     "@typescript-eslint/parser": "6.4",
     "concurrently": "8.2",
     "esbuild": "0.19",
-    "eslint": "8.47",
+    "eslint": "8.48",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.28",
     "tsc-alias": "1.8",
-    "typedoc": "0.24",
-    "typescript": "5.1"
+    "typedoc": "0.25",
+    "typescript": "5.2"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.9",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.85",
+    "@tstdl/angular": "^0.86",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",

package/polyfills.d.ts

@@ -0,0 +1,159 @@
+import 'disposablestack/auto';
+declare global {
+    interface SymbolConstructor {
+        /**
+         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+         */
+        readonly dispose: unique symbol;
+        /**
+         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+         */
+        readonly asyncDispose: unique symbol;
+    }
+    interface Disposable {
+        [Symbol.dispose](): void;
+    }
+    interface AsyncDisposable {
+        [Symbol.asyncDispose](): PromiseLike<void>;
+    }
+    interface SuppressedError extends Error {
+        error: any;
+        suppressed: any;
+    }
+    interface SuppressedErrorConstructor extends ErrorConstructor {
+        new (error: any, suppressed: any, message?: string): SuppressedError;
+        (error: any, suppressed: any, message?: string): SuppressedError;
+        readonly prototype: SuppressedError;
+    }
+    var SuppressedError: SuppressedErrorConstructor;
+    interface DisposableStack {
+        /**
+         * Returns a value indicating whether this stack has been disposed.
+         */
+        readonly disposed: boolean;
+        /**
+         * Disposes each resource in the stack in the reverse order that they were added.
+         */
+        dispose(): void;
+        /**
+         * Adds a disposable resource to the stack, returning the resource.
+         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
+         * @returns The provided {@link value}.
+         */
+        use<T extends Disposable | null | undefined>(value: T): T;
+        /**
+         * Adds a value and associated disposal callback as a resource to the stack.
+         * @param value The value to add.
+         * @param onDispose The callback to use in place of a `[Symbol.dispose]()` method. Will be invoked with `value`
+         * as the first parameter.
+         * @returns The provided {@link value}.
+         */
+        adopt<T>(value: T, onDispose: (value: T) => void): T;
+        /**
+         * Adds a callback to be invoked when the stack is disposed.
+         */
+        defer(onDispose: () => void): void;
+        /**
+         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
+         * @example
+         * ```ts
+         * class C {
+         *   #res1: Disposable;
+         *   #res2: Disposable;
+         *   #disposables: DisposableStack;
+         *   constructor() {
+         *     // stack will be disposed when exiting constructor for any reason
+         *     using stack = new DisposableStack();
+         *
+         *     // get first resource
+         *     this.#res1 = stack.use(getResource1());
+         *
+         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+         *     this.#res2 = stack.use(getResource2());
+         *
+         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
+         *     // when constructor exits
+         *     this.#disposables = stack.move();
+         *   }
+         *
+         *   [Symbol.dispose]() {
+         *     this.#disposables.dispose();
+         *   }
+         * }
+         * ```
+         */
+        move(): DisposableStack;
+        [Symbol.dispose](): void;
+        readonly [Symbol.toStringTag]: string;
+    }
+    interface DisposableStackConstructor {
+        new (): DisposableStack;
+        readonly prototype: DisposableStack;
+    }
+    var DisposableStack: DisposableStackConstructor;
+    interface AsyncDisposableStack {
+        /**
+         * Returns a value indicating whether this stack has been disposed.
+         */
+        readonly disposed: boolean;
+        /**
+         * Disposes each resource in the stack in the reverse order that they were added.
+         */
+        disposeAsync(): Promise<void>;
+        /**
+         * Adds a disposable resource to the stack, returning the resource.
+         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
+         * @returns The provided {@link value}.
+         */
+        use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
+        /**
+         * Adds a value and associated disposal callback as a resource to the stack.
+         * @param value The value to add.
+         * @param onDisposeAsync The callback to use in place of a `[Symbol.asyncDispose]()` method. Will be invoked with `value`
+         * as the first parameter.
+         * @returns The provided {@link value}.
+         */
+        adopt<T>(value: T, onDisposeAsync: (value: T) => PromiseLike<void> | void): T;
+        /**
+         * Adds a callback to be invoked when the stack is disposed.
+         */
+        defer(onDisposeAsync: () => PromiseLike<void> | void): void;
+        /**
+         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
+         * @example
+         * ```ts
+         * class C {
+         *   #res1: Disposable;
+         *   #res2: Disposable;
+         *   #disposables: DisposableStack;
+         *   constructor() {
+         *     // stack will be disposed when exiting constructor for any reason
+         *     using stack = new DisposableStack();
+         *
+         *     // get first resource
+         *     this.#res1 = stack.use(getResource1());
+         *
+         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+         *     this.#res2 = stack.use(getResource2());
+         *
+         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
+         *     // when constructor exits
+         *     this.#disposables = stack.move();
+         *   }
+         *
+         *   [Symbol.dispose]() {
+         *     this.#disposables.dispose();
+         *   }
+         * }
+         * ```
+         */
+        move(): AsyncDisposableStack;
+        [Symbol.asyncDispose](): Promise<void>;
+        readonly [Symbol.toStringTag]: string;
+    }
+    interface AsyncDisposableStackConstructor {
+        new (): AsyncDisposableStack;
+        readonly prototype: AsyncDisposableStack;
+    }
+    var AsyncDisposableStack: AsyncDisposableStackConstructor;
+}

package/polyfills.js

@@ -0,0 +1,2 @@
+"use strict";
+var import_auto = require("disposablestack/auto");

package/queue/mongo/mongo-job.repository.js

@@ -45,7 +45,6 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MongoJobRepository_1;
 const indexes = [
   { key: { queue: 1, jobId: 1 }, unique: true },
   { key: { queue: 1, priority: 1, enqueueTimestamp: 1, lastDequeueTimestamp: 1, tries: 1 } },
@@ -53,7 +52,7 @@ const indexes = [
   { key: { queue: 1, batch: 1 } },
   { key: { queue: 1, tries: 1 } }
 ];
-let MongoJobRepository = MongoJobRepository_1 = class MongoJobRepository2 extends import_mongo.MongoEntityRepository {
+let MongoJobRepository = class MongoJobRepository2 extends import_mongo.MongoEntityRepository {
   constructor(collection, logger) {
     super(collection, import_mongo.noopTransformer, { indexes, logger });
   }
@@ -72,9 +71,9 @@ let MongoJobRepository = MongoJobRepository_1 = class MongoJobRepository2 extend
     await bulk.execute(false);
   }
 };
-MongoJobRepository = MongoJobRepository_1 = __decorate([
+MongoJobRepository = __decorate([
   (0, import_injector.Singleton)(),
   __param(0, (0, import_injector.ForwardArg)()),
-  __param(1, (0, import_injector.ResolveArg)(MongoJobRepository_1.name)),
+  __param(1, (0, import_injector.ResolveArg)(MongoJobRepository.name)),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], MongoJobRepository);

package/search-index/elastic/module.js

@@ -43,14 +43,14 @@ function configureElasticsearch(config = {}) {
 import_injector.Injector.registerSingleton(import_elasticsearch.Client, {
   useFactory: (argument, context) => {
     (0, import_type_guards.assertDefined)(argument, "missing elasticsearch client options");
-    context.context.logger = (0, import_inject.inject)(import_logger.Logger, elasticsearchModuleConfig.logPrefix);
+    context.data.logger = (0, import_inject.inject)(import_logger.Logger, elasticsearchModuleConfig.logPrefix);
     const client = new import_elasticsearch.Client(argument);
-    context.addDisposeHandler(async () => client.close().then(() => context.context.logger.info("closed connection")));
+    context.addDisposeHandler(async () => client.close().then(() => context.data.logger.info("closed connection")));
     return client;
   },
-  async afterResolve(client, options, context) {
+  async afterResolve(client, options, { cancellationToken, data: { logger } }) {
     const url = getUrl(options.node ?? options.nodes);
-    await (0, import_core.connect)(`elasticsearch (${url})`, async () => client.ping().then((alive) => (0, import_type_guards.assert)(alive, "failed to connect")), context.logger);
+    await (0, import_core.connect)(`elasticsearch (${url})`, async () => client.ping().then((alive) => (0, import_type_guards.assert)(alive, "failed to connect")), logger, cancellationToken);
   },
   defaultArgumentProvider() {
     return elasticsearchModuleConfig.defaultOptions;

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compileOnSave": false,
   "compilerOptions": {
-    "module": "esnext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "lib": ["esnext", "dom"],
     "target": "es2022",

package/utils/cancellation-token.d.ts

@@ -1,4 +1,4 @@
-import type { Observable, Observer, Subscribable, Subscription } from 'rxjs';
+import type { Observable, Observer, Subscribable, Subscription, Unsubscribable } from 'rxjs';
 export type ConnectConfig = {
     /**
      * Propagate parent set to child.
@@ -31,59 +31,61 @@ export type ConnectConfig = {
      */
     once?: boolean;
 };
-export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribable<void> {
+export declare abstract class ReadonlyCancellationToken implements PromiseLike<void>, Subscribable<void> {
     /**
      * Returns whether this token set.
      */
-    readonly isSet: boolean;
+    abstract readonly isSet: boolean;
     /**
      * Returns whether this token unset.
      */
-    readonly isUnset: boolean;
+    abstract readonly isUnset: boolean;
     /**
      * Observable which emits the current state and every state change.
      */
-    readonly state$: Observable<boolean>;
+    abstract readonly state$: Observable<boolean>;
     /**
      * Observable which emits when this token is set.
      */
-    readonly set$: Observable<void>;
+    abstract readonly set$: Observable<void>;
     /**
      * Observable which emits when this token is unset.
      */
-    readonly unset$: Observable<void>;
+    abstract readonly unset$: Observable<void>;
     /**
      * Returns a promise which is resolved when this token is set.
      */
-    readonly $set: Promise<void>;
+    abstract readonly $set: Promise<void>;
     /**
      * Returns a promise which is resolved when this token is unset.
      */
-    readonly $unset: Promise<void>;
+    abstract readonly $unset: Promise<void>;
     /**
      * Returns a promise which is resolved when this token changes its state.
      */
-    readonly $state: Promise<boolean>;
+    abstract readonly $state: Promise<boolean>;
     /**
      * Returns an AbortSignal.
      */
-    asAbortSignal(): AbortSignal;
+    abstract asAbortSignal(): AbortSignal;
     /**
      * Create a new token and connect it to this instance.
      * @see {@link connect}
      */
-    createChild(config?: ConnectConfig): CancellationToken;
+    abstract createChild(config?: ConnectConfig): CancellationToken;
     /**
      * Propagate events from this instance to the `child`. Events from the `child` are *not* propagated to this instance.
      * @param child child to connect
      */
-    connect(child: CancellationToken, config?: ConnectConfig): void;
+    abstract connect(child: CancellationToken, config?: ConnectConfig): void;
+    abstract subscribe(observer: Partial<Observer<void>>): Unsubscribable;
+    abstract then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
 }
-export declare class CancellationToken implements ReadonlyCancellationToken {
-    private readonly stateSubject;
+export declare class CancellationToken extends ReadonlyCancellationToken {
+    #private;
     readonly state$: Observable<boolean>;
-    readonly set$: Observable<void>;
-    readonly unset$: Observable<void>;
+    readonly set$: Observable<undefined>;
+    readonly unset$: Observable<undefined>;
     get isSet(): boolean;
     get isUnset(): boolean;
     get $set(): Promise<void>;