@cloudbitmaps/roaring 0.17.0 → 0.18.1

package/dist/index.d.ts

@@ -25,6 +25,7 @@
  */
 import type { BudgetOption, GenerationEntry, GenerationMetadata, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, ReapRegistryTombstonesOptions, ReapRegistryTombstonesResult, RollbackResult, Clock, StorageChunkSource, ConsistencyReport, CostReport, DropResult, EstimateInput, ExportManifest, ExportOptions, ExportSink, IAuditSink, IStorageDriver, IKeystore, IMetricsSink, StorageBackend, PricingProfile, RetentionPolicy, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, SetRetentionResult, PinnedAt, IdRange, SegmentRef, Workload } from '@cloudbitmaps/core';
 import type { SegmentInfo } from '@cloudbitmaps/core';
+import type { CombineExpr, CombineManyFeedRecord, CombineManyOperandStats, CombineManyOutputStats, CombineManyStats } from '@cloudbitmaps/core';
 import { deserializePortable } from './roaring-codec.js';
 /**
  * Wiring for a {@link CloudRoaring} store. **Only `storage` is required** — the minimal call is
@@ -298,6 +299,142 @@ export interface EraseSubjectResult {
  * in prose means the compiler enforces it, and a caller's exhaustive `switch` has no dead branch.
  */
 export type MaterializeRefusal = Exclude<LoadRefusal, 'superseded'>;
+/**
+ * An expression over the operands of a {@link CloudRoaring.materializeMany} call: a string names an operand; a node holds
+ * exactly one of `and`, `or` or `andNot` over a non-empty list of expressions. `andNot` subtracts every entry after the
+ * first from the first, so it takes at least two. Plain JSON, so it can be logged and sent between tasks.
+ */
+export type Expr = CombineExpr;
+/** What the call did to one operand: see {@link MaterializeManyStats.operands}. */
+export type MaterializeManyOperandStats = CombineManyOperandStats;
+/** What the call did to one output: see {@link MaterializeManyStats.outputs}. */
+export type MaterializeManyOutputStats = CombineManyOutputStats;
+/**
+ * What a {@link CloudRoaring.materializeMany} call did: the groups it ran, its requests by class, the chunk-read budget it
+ * used, the most it held resident, and, for each operand, the generation it was pinned at, began at and ended at.
+ */
+export type MaterializeManyStats = CombineManyStats;
+/** One output of a {@link CloudRoaring.materializeMany} call. */
+export interface MaterializeManyOutput {
+    /** The segment this output becomes a new generation of. Not an operand of the call, and named by no other output. */
+    readonly dest: Segment;
+    /** What to compute. */
+    readonly expr: Expr;
+    /** Subtracted from the result, as the entries of an `andNot` after the first are. Pinned operands it names are re-checked before the publish. */
+    readonly exclude?: Expr[];
+    /** As on {@link MaterializeOptions}. */
+    readonly guard?: LoadGuard;
+    /** As on {@link MaterializeOptions}. */
+    readonly allowEmpty?: boolean;
+    /** As on {@link MaterializeOptions}. */
+    readonly metadata?: GenerationMetadata;
+    /** As on {@link MaterializeOptions}. */
+    readonly audit?: IAuditSink;
+    /** Generations to keep below the new one, as on {@link MaterializeOptions}; overrides the call's `keep`. */
+    readonly keep?: number;
+}
+/**
+ * One record of the feed of {@link CloudRoaring.materializeMany}: the ids some of the fed operands hold at one chunk key.
+ * `key` is `id >>> 16`, an integer from 0 to 65,535, never below the previous record's; a key may arrive as several
+ * consecutive records, each carrying some of the operands, and one record per key is the usual shape. `operands` maps a
+ * declared fed name to its ids at the key: a real `Uint32Array` (not an `Int32Array`, `Buffer`, array or look-alike),
+ * strictly ascending, every id inside the key. A name is given at most once per key, and an empty array is the same as
+ * leaving the name out. The record is copied as it arrives, so the caller may drop or reuse its arrays once it has yielded it.
+ */
+export type MaterializeManyFeedRecord = CombineManyFeedRecord;
+/**
+ * Operands that arrive as records in chunk-key order instead of being stored, for {@link MaterializeManyOptions.feed}.
+ * Outputs name a fed operand as they name a stored one.
+ */
+export interface MaterializeManyFeed {
+    /** The fed operand names, declared up front. A name is either stored or fed, never both. */
+    readonly names: string[];
+    /** The records, read once, in key order. */
+    readonly records: AsyncIterable<MaterializeManyFeedRecord>;
+    /**
+     * How many ids each fed operand holds over the whole feed, **required**: an object keyed by exactly `names`, or a
+     * function returning one (or a promise of one), called once after the last record and before any fed output is
+     * published. A feed whose count of ids for any operand differs (one that ended early, or skipped a key) refuses every
+     * fed output; so does a count that is missing, extra, thrown or rejected.
+     */
+    readonly counts: (() => Record<string, number> | Promise<Record<string, number>>) | Record<string, number>;
+}
+/** The options of {@link CloudRoaring.materializeMany}. */
+export interface MaterializeManyOptions extends IdRange {
+    /**
+     * The operands the expressions name: stored segments, and operands held in memory from {@link CloudRoaring.memory}. A held
+     * operand is accepted here and nowhere else.
+     */
+    readonly operands: Record<string, Segment | MemoryOperand>;
+    /** The outputs, in the order their results come back. */
+    readonly outputs: ReadonlyArray<MaterializeManyOutput>;
+    /**
+     * Generations to keep below each new one: a non-negative integer, **required**, since a materialisation otherwise keeps
+     * every generation and a call of a thousand outputs would leave a thousand uncollected destinations on every refresh.
+     * An output's own `keep` overrides it.
+     */
+    readonly keep: number;
+    /**
+     * Read every stored operand at the generation it has when the call starts, for the whole call (default `true`): the call
+     * pins each one that is not already pinned. It is one generation per operand, **not one instant across operands**.
+     * `false` reads each live, as a combine does, which can describe two generations of one operand and break its pruning, and runs
+     * **no re-check** of an operand an output subtracts: an opt-out list can move during the call and the outputs that subtract it are
+     * published (`stats.operands` still reports, from one read at the end, that it moved).
+     * An operand passed already pinned is used as it is whatever this says.
+     */
+    readonly pin?: boolean;
+    /**
+     * The most resident bytes the call counts at once, default 256 MiB: the buffered outputs, the operand streams, the
+     * chunks being evaluated and the plan, counted as resident memory. Past it, outputs run in groups and the operands are read
+     * again for each group. Process memory is more than the count (measured 1.6 to 5 times; see the guide).
+     */
+    readonly maxBufferedBytes?: number;
+    /**
+     * The most chunk reads the call may make, counted over all its groups. Default: the store's own `budget` when it was built
+     * with one (a ceiling below the plan throws `BudgetExceededError` before any chunk is read), else what the plan needs,
+     * with headroom. `false` lifts it. The budget used is in the result's stats.
+     */
+    readonly budget?: BudgetOption;
+    /** Outputs published at once, default 8. */
+    readonly publishConcurrency?: number;
+    /** Range requests held ahead per operand, default 1. */
+    readonly concurrency?: number;
+    /** As on every combine. */
+    readonly allowAbsentOperands?: boolean;
+    /**
+     * Operands fed as records in chunk-key order, beside the stored ones; an output names a fed operand as it names a stored
+     * one. **A feed is read once, so a call with one runs its outputs as one group, and `maxBufferedBytes` is then required**:
+     * the feed's records and the fed outputs are counted against it as they arrive, and a fed call fails as soon as the count
+     * passes it. A fed output is published only after the whole feed was read and every end-of-feed check passed.
+     */
+    readonly feed?: MaterializeManyFeed;
+    /**
+     * Fed and held operand names allowed to hold no id. A declared fed name that appears in no record is refused at the end
+     * of the feed, and a held operand that holds no id is refused before any request, because an operand that is empty is
+     * usually an upstream query that failed quietly. Naming something that is neither a fed nor a held operand is a
+     * {@link ValidationError}.
+     */
+    readonly mayBeEmpty?: readonly string[];
+}
+/**
+ * What one output of {@link CloudRoaring.materializeMany} came to: exactly what its `*Into` would have returned (a
+ * {@link MaterializeResult}, published or refused with its `reason`), or `{ published: false, error }` for what it would
+ * have thrown, or for what stopped it: a lost race ({@link WriteConflictError}), a publish whose outcome is unknown
+ * ({@link TransientError}), a damaged operand ({@link IntegrityError}), a lapsed lease ({@link LeaseExpiredError}), a
+ * pinned exclude that moved ({@link StaleOperandError}), memory ({@link BudgetExceededError}), or, for an output that names a
+ * fed operand, a bad feed ({@link ValidationError}) or an erasure in this store while the call ran ({@link StaleOperandError}
+ * with `reason: 'erased'`).
+ */
+export type MaterializeManyOutcome = MaterializeResult | {
+    readonly published: false;
+    readonly error: Error;
+};
+/** The result of {@link CloudRoaring.materializeMany}. */
+export interface MaterializeManyRun {
+    /** One per output, in the order given: one output's refusal or error never stops another. */
+    readonly outputs: MaterializeManyOutcome[];
+    readonly stats: MaterializeManyStats;
+}
 /** What an `*Into` verb wrote: the new generation of the destination, and whether it became current. */
 export interface MaterializeResult {
     /**
@@ -351,6 +488,13 @@ export declare class CloudRoaring {
     private readonly requireEncryption;
     /** Resolved store-level per-op budget (null = disabled); the admin scans use it, with a per-op override. */
     private readonly budget;
+    /**
+     * Moved at the start and at the end of each `eraseSubject` this store runs. A `materializeMany` call with a feed records
+     * it when it begins and is refused once it has moved: it reads caller memory, which no erasure can reach.
+     */
+    private erasureEpoch;
+    /** How many `eraseSubject` calls of this store are running: while any is, every check of the counter counts as moved. */
+    private erasuresRunning;
     /**
      * Refuse any option key the store does not take, at the top level or inside a group, naming each one.
      *
@@ -409,6 +553,148 @@ export declare class CloudRoaring {
      * **And by default it collects nothing**, unlike `load()`. See the `keep` default below.
      */
     private materialize;
+    /**
+     * **Hold a set of ids in memory**, to be an operand of {@link CloudRoaring.materializeMany} and of no other verb.
+     *
+     * ```ts
+     * const vip = await store.memory([7, 42, 99_001]);
+     * await store.materializeMany({ operands: { vip, engaged: store.segment('cond-engaged') }, outputs: [...], keep: 12 });
+     * vip.release();
+     * ```
+     *
+     * It takes what {@link CloudRoaring.load} takes as input (ids as a sync or async iterable or a typed array, `{ bitmap }`
+     * or `{ serialized }`) and checks it the same way, with the same errors: the size cap, the structure, the safe
+     * deserializer and each id's range. **Only a real `Uint32Array` skips the per-id range check**; any other typed array goes
+     * through it, so `Int32Array([-1])` and `Float64Array([1.5])` throw {@link ValidationError}. An object with an `ascending`
+     * key is refused: ids that arrive in key order are a `feed`. An empty set is accepted here, and refused by
+     * `materializeMany` unless its name is in `mayBeEmpty`.
+     *
+     * The ids are held as the chunks a stored generation would hold, until {@link MemoryOperand.release}; between calls that
+     * memory is the caller's, and during a call it counts against `maxBufferedBytes`. There is no size option: the load's
+     * own cap applies to a serialized input.
+     *
+     * **Erasure.** Only `eraseSubject` moves the store's counter (at its start and at its end). One that started in this store
+     * since the handle began to be made, or is still running, makes a call that reads the handle fail the outputs that read it with
+     * {@link StaleOperandError} (`reason: 'erased'`), before any request and again just before each publish. An erasure in
+     * another store or another process is not seen, nor are `dropSegment`, `eraseNamespace`, `destroySegment` and the free
+     * function `eraseIdFromSegment`, which do not move it: the handle is the caller's copy, so build it from the source of truth at
+     * the start of each refresh and release it at the end.
+     *
+     * @throws {ValidationError} where a load of the same input would.
+     */
+    memory(input: LoadInput): Promise<MemoryOperand>;
+    /**
+     * **Many outputs, each operand read once per group.** Each output is an expression over named stored operands (`and`, `or`, `andNot`, nested
+     * to depth 64) published as a new generation of its own `dest`, exactly as an `*Into` would publish it, but computed
+     * together: each operand's chunks are read once for all the outputs that use them, instead of once per output and
+     * once more for every scratch segment a nested expression would otherwise need.
+     *
+     * ```ts
+     * const run = await store.materializeMany({
+     *   operands: { us: store.segment('us'), engaged: store.segment('engaged'), optOut: store.segment('opt-out') },
+     *   outputs: [
+     *     { dest: store.segment('send-1'), expr: { and: ['us', 'engaged'] }, exclude: ['optOut'] },
+     *     { dest: store.segment('send-2'), expr: { andNot: ['us', 'engaged'] } },
+     *   ],
+     *   keep: 3,
+     * });
+     * run.outputs[0]; // a MaterializeResult, or { published: false, error }
+     * ```
+     *
+     * **Results.** `run.outputs[i]` is index-aligned with `outputs` and is exactly what output `i`'s `*Into` would have
+     * returned (a {@link MaterializeResult}: published, or refused with its `reason`), or `{ published: false, error }` for
+     * what it would have thrown. One output's refusal or error never stops another. The call itself throws only for bad
+     * input ({@link ValidationError} naming the output index and path, before any request), an operand that names no
+     * segment (unless `allowAbsentOperands`), and a `budget` its own plan exceeds, the last two before any chunk is read.
+     *
+     * **One generation per operand.** By default every stored operand is pinned for the call: read at the generation it had
+     * when the call started, however long the call runs and whatever loads land meanwhile. That is one generation per
+     * operand, not one instant across operands (two pins are two registry reads). `pin: false` reads live, as a combine does.
+     *
+     * **Every pinned operand an output subtracts is re-checked.** An output subtracts an operand when it is in its `exclude`
+     * or under any entry of an `andNot` after the first, at any depth. Immediately before the publishes the call re-reads the
+     * registry row of each such operand and compares its generation and incarnation, and the fingerprint of the current
+     * object where both reads carry one, with what was pinned (a name deleted and created again is a replacement though it
+     * is generation 0 again). If one was replaced, each output that subtracts it is
+     * not published and carries {@link StaleOperandError}; the others publish. It costs one registry read per such operand per
+     * group, and `stats.operands` carries every operand's pinned, start and end generation and whether it moved.
+     *
+     * **Memory.** Everything the pass holds resident is counted against `maxBufferedBytes` (default 256 MiB): each output's
+     * buffered chunks, the operand streams' ranges, the chunks being evaluated, and the plan itself, and a call whose plan alone
+     * passes it is refused before any chunk is read. When the outputs do not fit, they run in groups, each reading its operands
+     * once (so the operand reads grow with the total output size over the budget), and a group's buffers are released only as
+     * its publishes settle. A chunk count the index understated does not grow a group past the budget: the largest buffer is
+     * dropped and that output re-runs alone. An output that cannot fit alone has `BudgetExceededError` as its result. The count
+     * is the pass's own: process memory is more, measured at 1.6 times the ledger's high water on Linux and 2.5 to 5 times on
+     * macOS on the in-memory backend (the guide has the shapes and what is not counted).
+     *
+     * **Untrusted bytes.** Every operand chunk is decoded through the checks on untrusted tier data. A key an operand's index
+     * lists whose bytes are missing is an error for the outputs that read the operand, never an empty chunk.
+     *
+     * **Handles.** An expired or released handle anywhere in the call (an operand or a `dest`) is refused before any request,
+     * as on the `*Into` verbs. A leased operand's lease, and an operand's deadline, are checked before each chunk key
+     * is read: a lapse fails only the outputs that read that operand, never reads empty. Each `dest`'s lease and deadline
+     * are checked again just before its publish.
+     *
+     * **The chunk cache is bypassed:** the pass reads through the storage source and never writes the decoded-chunk cache, so
+     * a batch does not evict other readers' hot chunks. Each publish still invalidates its `dest` as an `*Into` does.
+     *
+     * **A limit of the form.** An output cannot name another output of the same call: a `dest` that is also an operand is
+     * refused. Chain two calls.
+     *
+     * **Held operands.** An operand may be a {@link MemoryOperand} from {@link CloudRoaring.memory}: ids the caller holds,
+     * read beside the stored ones and giving the same output byte for byte. It is read from memory (no request, and the
+     * shared chunk cache never sees it), counts against `maxBufferedBytes` while the call runs, and is refused when empty
+     * unless its name is in `mayBeEmpty`. A handle from another store, or a released one, is a {@link ValidationError}. An
+     * erasure in this store since the handle was made fails the outputs that read it with {@link StaleOperandError}
+     * (`reason: 'erased'`).
+     *
+     * **A feed.** `feed: { names, records, counts }` adds operands that arrive as records in chunk-key order, for conditions
+     * too many to hold or store. Each record is checked before the pass sees it (see {@link MaterializeManyFeedRecord}): a bad
+     * feed is refused, never read as fewer members, and **a fed output is published only after the whole feed was read and every
+     * end-of-feed check passed**, so a bad feed refuses every fed output and publishes none of them; outputs that name only
+     * stored operands are unaffected. At the end of the feed `counts` must equal the ids the feed held for each name, and a
+     * name that appeared in no record is refused unless it is in `mayBeEmpty`. A feed is read once, so the call runs its outputs
+     * as one group and **`maxBufferedBytes` is required**: each record is converted to compressed bitmaps as it arrives, the key
+     * in hand and its fed outputs are counted against the budget, and the call fails as soon as the count passes it, with
+     * {@link BudgetExceededError} for every fed output. **Erasure:** a fed call is refused at its next record, and before each
+     * fed publish, once `eraseSubject` has started in this store ({@link StaleOperandError}, `reason: 'erased'`).
+     *
+     * ```ts
+     * await store.materializeMany({
+     *   operands: { unsub: store.segment('global-unsub') },
+     *   feed: {
+     *     names: ['us', 'engaged'],
+     *     records: warehouseRecords(), // yields { key, operands: { us: Uint32Array, engaged: Uint32Array } } by key
+     *     counts: () => warehouseCounts(),
+     *   },
+     *   maxBufferedBytes: 512 * 1024 * 1024,
+     *   outputs: [{ dest: store.segment('send-1'), expr: { and: ['us', 'engaged'] }, exclude: ['unsub'] }],
+     *   keep: 12,
+     * });
+     * ```
+     */
+    materializeMany(options: MaterializeManyOptions): Promise<MaterializeManyRun>;
+    private epochNow;
+    /**
+     * Whether an erasure has started in this store since `at` was read, or was running when it was: one that is still
+     * running is seen by the count of those running, and one that has ended since by the counter, which its end moved.
+     * The one check every call that reads caller memory uses.
+     */
+    private epochMoved;
+    /** A call's feed with the store's erasure counter: read once here, checked by the combine before any record is read. */
+    private feedOf;
+    /**
+     * The registry row of `ref`, read straight from the registry, not from a snapshot: a re-check must see a move. With
+     * `fingerprint`, the current generation's object is opened too (one tail read, as a pin of it makes), and its
+     * fingerprint is returned beside the row: a generation's number is identified by its row and its object, since a number
+     * can be taken again once its object is gone.
+     */
+    private currentRowOf;
+    /** Throw what a read of `handle` must throw now: its lease error, or a refusal for a deadline that has passed. */
+    private assertReadable;
+    /** {@link assertReadable} for a destination, named by where it sits in the call. */
+    private assertWritable;
     /**
      * **Subject access (GDPR Art. 15 / CCPA right-to-know): which segments is this id a member of?**
      *
@@ -499,6 +785,7 @@ export declare class CloudRoaring {
         concurrency?: number;
         budget?: BudgetOption;
     }): Promise<EraseSubjectResult>;
+    private eraseSubjectRun;
     /**
      * Every generation still in the bucket for this segment, ascending, with the current one marked.
      *
@@ -1185,6 +1472,26 @@ export interface SegmentStat {
     /** The metadata the generation was loaded with; absent when it has none. */
     readonly metadata?: GenerationMetadata;
 }
+/**
+ * A set of ids held in memory by {@link CloudRoaring.memory}, to be an operand of {@link CloudRoaring.materializeMany}
+ * and of no other verb. The bytes are the caller's until {@link MemoryOperand.release}.
+ *
+ * It belongs to the store that made it. `eraseSubject` in that store, started after the handle began to be made or still
+ * running when it was, fails the outputs of a `materializeMany` call that read it with {@link StaleOperandError}
+ * (`reason: 'erased'`): the call does not throw, and its outputs that do not read the handle publish. Nothing else is
+ * seen: an erasure in another store or process, and
+ * `dropSegment`, `eraseNamespace`, `destroySegment` and the free function `eraseIdFromSegment`, do not move the counter.
+ */
+export declare class MemoryOperand {
+    private readonly view;
+    /** Not constructible: a handle comes from {@link CloudRoaring.memory}. */
+    private constructor();
+    /**
+     * Zero and drop the bytes it holds. Any later use throws {@link ValidationError}; releasing twice does nothing. A call
+     * still reading it fails the outputs that read it.
+     */
+    release(): void;
+}
 /**
  * A handle bound to one segment — the read verbs, plus the three `*Into` verbs that write a **new generation**
  * of another segment.
@@ -1586,5 +1893,5 @@ export declare class Segment {
     }): Promise<CostReport>;
 }
 export { deserializePortable };
-export { MemoryStorage, LocalFsStorage, CrbmStorageChunkSource, destroySegment, eraseNamespace, excludingReservedRows, readRetentionPolicy, MIN_EXPIRES_AT_MS, LEASE_SKEW_MS, MAX_LEASE_MS, MAX_LEASES_PER_SEGMENT, InProcessKeystore, NodeAead, aadFor, CloudRoaringError, ValidationError, WriteConflictError, IntegrityError, NotFoundError, UnsupportedError, CapabilityError, TransientError, KeyUnavailableError, BudgetExceededError, LeaseExpiredError, LeaseLimitError, isCloudRoaringError, isWriteConflictError, isTransientError, isNotFoundError, isIntegrityError, isValidationError, isLeaseExpiredError, isLeaseLimitError, CrbmReader, BufferReader, CountingMetricsSink, RecordingAuditSink, DEFAULT_RETRY_POLICY, AWS_US_EAST_1_ONDEMAND, ELASTICACHE_REDIS_US_EAST_1_ONDEMAND, ONE_REDIS_HA_CLUSTER, } from '@cloudbitmaps/core';
+export { MemoryStorage, LocalFsStorage, CrbmStorageChunkSource, destroySegment, eraseNamespace, excludingReservedRows, readRetentionPolicy, MIN_EXPIRES_AT_MS, LEASE_SKEW_MS, MAX_LEASE_MS, MAX_LEASES_PER_SEGMENT, InProcessKeystore, NodeAead, aadFor, CloudRoaringError, ValidationError, WriteConflictError, IntegrityError, NotFoundError, UnsupportedError, CapabilityError, TransientError, KeyUnavailableError, BudgetExceededError, LeaseExpiredError, LeaseLimitError, StaleOperandError, isCloudRoaringError, isWriteConflictError, isTransientError, isNotFoundError, isIntegrityError, isValidationError, isLeaseExpiredError, isLeaseLimitError, isStaleOperandError, CrbmReader, BufferReader, CountingMetricsSink, RecordingAuditSink, DEFAULT_RETRY_POLICY, AWS_US_EAST_1_ONDEMAND, ELASTICACHE_REDIS_US_EAST_1_ONDEMAND, ONE_REDIS_HA_CLUSTER, } from '@cloudbitmaps/core';
 export type { Aead, AeadSealed, AuditEvent, BlobReader, BlobSink, Budget, BudgetOption, ChunkRef, Clock, CodecBitmap, CodecInterface, ConsistencyErrorEntry, ConsistencyIssue, ConsistencyReport, CostReport, CrbmCrypto, CrbmReaderOptions, CrbmStorageChunkSourceOptions, DestroyResult, ClearRegistrySummary, DropResult, EncodedChunk, EraseDeps, EstimateInput, ExportFailure, ExportFormat, ExportManifest, ExportOptions, ExportSink, ExportWriter, ExportedSegment, GenKey, GenerationEntry, GenerationMetadata, GovernanceMeta, IAuditSink, IKeystore, IMetricsSink, IRegistryDriver, IStorageDriver, IdRange, InProcessKeystoreOptions, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, LocalFsStorageOptions, MemoryStorageOptions, MetricEvent, MetricOpName, MetricsSnapshot, NewRegistryRecord, PinnedAt, PinnedObject, PortableBitmap, PricingProfile, RedisNodeType, RedisSizing, RegCaps, RegistryPatch, RegistryRecord, RegistryStatus, RegistrySummary, ReapRegistryTombstonesOptions, ReapRegistryTombstonesResult, RegistryWriteOptions, LeaseEntry, RetentionPolicy, RetireEntry, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, RollbackResult, SealedRegistrySummary, SegmentInfo, SegmentRef, SegmentSize, SegmentSizing, SetRetentionResult, StorageBackend, StorageCaps, StorageChunkSource, Token, Workload, WrappedDek, } from '@cloudbitmaps/core';