@ibgib/core-gib 0.0.8 → 0.0.11

package/dist/witness/space/metaspace/metaspace-base.d.mts

@@ -0,0 +1,795 @@
+import { Observable, ReplaySubject, Subscription } from 'rxjs';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+import { IbGibAddr, TransformResult } from '@ibgib/ts-gib';
+import { DeleteIbGibOpts, DeleteIbGibResult, GetIbGibOpts, GetIbGibResult, PutIbGibOpts, PutIbGibResult } from '../../../common/other/other-types.mjs';
+import { TagIbGib_V1 } from '../../../common/tag/tag-types.mjs';
+import { ParticipantInfo, SyncSagaInfo, SyncSpaceResultIbGib, SyncStatusIbGib } from '../../../witness/space/outer-space/outer-space-types.mjs';
+import { SpaceId } from '../../../witness/space/space-types.mjs';
+import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
+import { IbGibTimelineUpdateInfo, SpecialIbGibType } from '../../../common/other/other-types.mjs';
+import { RootData } from '../../../common/root/root-types.mjs';
+import { CiphertextIbGib_V1, EncryptionData_V1, EncryptionIbGib, SecretData_V1, SecretIbGib_V1 } from '../../../common/encrypt/encrypt-types.mjs';
+import { RobbotIbGib_V1 } from '../../../witness/robbot/robbot-types.mjs';
+import { AppIbGib_V1 } from '../../../witness/app/app-types.mjs';
+import { GetDependencyGraphOptions } from '../../../common/other/graph-helper.mjs';
+import { IbGibCacheService } from '../../../common/cache/cache-types.mjs';
+import { MetaspaceInitializeOptions, CreateLocalSpaceOptions, LocalSpaceFactoryFunction, MetaspaceFactory } from './metaspace-types.mjs';
+import { MetaspaceService, TempCacheEntry } from './metaspace-types.mjs';
+/**
+ * All-purpose mega service (todo: which we'll need to break up!) to interact
+ * with ibgibs at the app/device level.
+ *
+ * This works with the local app user space.
+ *
+ * ## regarding special ibgibs
+ *
+ * Special ibgibs' behaviors are what hold in other apps configuration data.
+ * Of course the difference is that most special ibgibs can leverage the "on-chain"
+ * functionality of "regular" ibgibs.
+ *
+ * There are a couple meta ibgibs (which I also call "special"):
+ *   * roots^gib
+ *     * tracks other special root^gib ibgibs, which are like local app-level indexes.
+ *   * tags^gib
+ *     * tracks other special tag^gib ibgibs, which you can apply to any ibgib
+ *   * latest^gib
+ *     * tracks mappings between tjp -> latest ib^gib address
+ *     * ephemeral (deletes past rel8ns and past ibGib frames)
+ *   * ...
+ *
+ * ## regarding latest ibgibs
+ *
+ * The tjp (temporal junction point) defines atow the beginning of an ibGib
+ * timeline.  it's like the birthday for an ibGib. (Or you can think if it as
+ * the id for the stream of ibgib frames in a given timeline.)
+ *
+ * The latest ibGib in that timeline is also special, because it's often what
+ * you want to work with.
+ *
+ * So ideally, when an ibgib, A, has a tjp A1, and it is updated to A2, A3, An
+ * via `mut8` and/or `rel8` transforms, that ibgib creates a single timeline.
+ * This service attempts to track the relationship between that starting tjp
+ * address and its corresponding latest frame in that timeline, i.e., A1 -> An.
+ *
+ * ### mapping persistence implementation details
+ *
+ * The latest ibGib service is backed by a special ibgib that maintains the
+ * mapping index.  It does this by rel8-ing that special backing ibgib via the
+ * tjp pointer, e.g. [special latest ibgib^XXX000].rel8ns[A^TJP123] ===
+ * [A^N12345] . It does this via the ib^gib content address pointer, so this
+ * becomes a mapping from A^TJP123 to A^N12345.
+ *
+ * This backing ibGib is special (even for special ibGibs) in that:
+ *   * it does not relate itself with the current root of the application
+ *   * it does not maintain references to its past (i.e. rel8ns['past'] === [])
+ *   * it DELETES its previous incarnation from the files service
+ *
+ * In other words, this service is meant to be as ephemeral as possible. I am
+ * keeping it as an ibGib and not some other data format (like straight in
+ * storage/some other db) because I've found this is often useful and what I end
+ * up doing anyway to leverage other ibgib behavior. For example, in the future
+ * it may be good to take snapshots, which is a simple copy operation of the
+ * file persistence.
+ *
+ * ### current naive implementation notes
+ *
+ * questions:
+ *   * What do we want to do if we can't locate an ibGib record?
+ *   * How/when do we want to alert the user/our own code that we've found
+ *     multiple timelines for an ibGib with a tjp (usually a thing we want to
+ *     avoid)?
+ *   * Who do we want to notify when new ibGibs arrive?
+ *   * How often do we want to check external sources for latest?
+ *   * When do we get to merging ibGib timelines?
+ *
+ * This is behavior that is somewhat taken care of, e.g. in git, with the HEAD
+ * pointer for a repo.  But we're talking about here basically as a metarepo or
+ * "repo of repos", and unlike git, we don't want our HEAD metadata living "off
+ * chain" (outside of the DLT itself that it's modifying).  So eventually, what
+ * we want is just like what we want with ALL ibGibs: perspective. From "the
+ * app"'s perspective, the latest is mapped. But really, apps can't view slices
+ * of ibGib graphs in all sorts of interesting ways and still be productive &
+ * beneficial to the ecosystem as a whole.
+ */
+export declare abstract class MetaspaceBase implements MetaspaceService {
+    protected cacheSvc: IbGibCacheService | undefined;
+    protected lc: string;
+    instanceId: string;
+    protected _initialized: boolean;
+    get initialized(): boolean;
+    protected _initializedSubj: ReplaySubject<void>;
+    initialized$: Observable<void>;
+    protected _initializing: boolean;
+    get initializing(): boolean;
+    protected _latestSubj: ReplaySubject<IbGibTimelineUpdateInfo>;
+    latestObs: Observable<IbGibTimelineUpdateInfo>;
+    /**
+     * gets the current local user space
+     */
+    getLocalUserSpace({ lock, localSpaceId, }: {
+        /**
+         * If true, then we lock by bootstrap/spaceId before trying to retrieve.
+         *
+         * @default true
+         */
+        lock?: boolean;
+        /**
+         * If provided, will look for the space via this id in the bootstrap ibgib.
+         * If not provided, will use the bootstrap ibgib's default spaceId.
+         */
+        localSpaceId?: SpaceId;
+    }): Promise<IbGibSpaceAny | undefined>;
+    /**
+     * gets all local user spaces known in bootstrap ibgib, according to
+     * spaceIds property
+     *
+     * (`bootstrapIbGib.data[BOOTSTRAP_DATA_KNOWN_SPACE_IDS_KEY]` atow)
+     *
+     * ## example bootstrap ibgib atow
+     *
+      ```json
+      {
+          "ib":"bootstrap",
+          "gib":"gib",
+          "data":{
+              "defaultSpaceId":"d455d9a72807617634ccbf1e532b71037c45762f824ec85fcd9a4c2275562f33",
+              "spaceIds":["d455d9a72807617634ccbf1e532b71037c45762f824ec85fcd9a4c2275562f33"]
+          },
+          "rel8ns":{
+              "d455d9a72807617634ccbf1e532b71037c45762f824ec85fcd9a4c2275562f33":[
+                  "witness space IonicSpace_V1 oij d455d9a72807617634ccbf1e532b71037c45762f824ec85fcd9a4c2275562f33^B336251655E8C56B38E9E86F20E0E42E6C153785F1A0A798ADE6916E71CF055B"
+              ]
+          }
+      }
+      ```
+     *
+     * so this enumerates `data.spaceIds` and gets the corresponding addrs in the `rel8ns`.
+     * it then gets the space ibgibs themselves via the local zero space.
+     *
+     * @returns array of known local user spaces
+     *
+     * @throws if no local user spaces found (there should be at least one atow i think)
+     */
+    getLocalUserSpaces({ lock, }: {
+        /**
+         * If true, then we lock by bootstrap/spaceId before trying to retrieve.
+         *
+         * @default true
+         */
+        lock?: boolean;
+    }): Promise<IbGibSpaceAny[]>;
+    abstract get zeroSpace(): IbGibSpaceAny;
+    /**
+     * Just to prevent plaintext passwords from just sitting in memory,
+     * this is a slight layer of indirection for caching.
+     */
+    protected passwordCache: {
+        [addr: string]: TempCacheEntry;
+    };
+    protected _syncing: boolean;
+    /**
+     * should only syncIbGibs when not already syncing.
+     */
+    get syncing(): boolean;
+    protected sagaInfoMap: {
+        [sagaId: string]: SyncSagaInfo;
+    };
+    /**
+     * unique set of tjp addresses that will auto sync to sync spaces.
+     */
+    protected _alwaysAutosyncTjpAddrsCache: Set<string>;
+    /**
+     * Hmm, hacky way of tracking if we're prompt the user for something.
+     * We don't want to prompt while we're already prompting, and this
+     * is a straight-forward approach.
+     *
+     * @see {@link getPasswordForSecrets}
+     */
+    protected isPrompting: boolean;
+    /**
+     * getUUID is async. there are many times we want a throwaway id
+     * synchronously. So we'll prepopulate them here.
+     */
+    protected _precalculatedIds: string[];
+    getUUIDSync(): string;
+    precalculateSomeUUIDsPlease(): Promise<void>;
+    protected metaspaceFactory: MetaspaceFactory;
+    /**
+     * used in alerting user of things... carryover of mvp. should be in initialize
+     */
+    protected getFnAlert: (() => (arg: {
+        title: string;
+        msg: string;
+    }) => Promise<void>) | undefined;
+    /**
+     * used in prompting user for passwords... carryover of mvp. should be in initialize
+     */
+    protected getFnPrompt: (() => ((arg: {
+        title: string;
+        msg: string;
+    }) => Promise<string>)) | undefined;
+    /**
+     * used in prompting user for passwords... carryover of mvp. should be in initialize
+     */
+    protected getFnPromptPassword: (() => (title: string, msg: string) => Promise<string | null>) | undefined;
+    constructor(cacheSvc: IbGibCacheService | undefined);
+    protected initializeMetaspaceFactory({ metaspaceFactory }: {
+        metaspaceFactory: MetaspaceFactory;
+    }): Promise<void>;
+    initialize({ spaceName, metaspaceFactory, getFnAlert, getFnPrompt, getFnPromptPassword, }: MetaspaceInitializeOptions): Promise<void>;
+    protected initializeSpecialIbGibs_required({ timerName }: {
+        timerName: string;
+    }): Promise<void>;
+    protected initializeSpecialIbGibs_outerspaces({ timerName }: {
+        timerName: string;
+    }): Promise<void>;
+    protected initializeSpecialIbGibs_other({ timerName }: {
+        timerName: string;
+    }): Promise<void>;
+    /**
+     * Make sure we have a bootstrapped space. This is like a node...kinda in peer
+     * to peer systems.
+     *
+     * For all intents and purposes here to begin with, I'm using this initially
+     * as where to put the settings ibGib that will contain pointers for this app, be it an
+     * ionic android/web app or a browser extension. This is because the initial
+     * intent of doing the spaces, besides it being necessary for the distributed
+     * nature of the architecture, is to obviate the use of ionic Storage.
+     * That is currently where we are storing things like the pointers to special
+     * ibGibs like tags^ibgib, roots ibgibs, etc.
+     */
+    protected initializeLocalSpaces({ spaceName, }: {
+        spaceName: string | undefined;
+    }): Promise<void>;
+    /**
+     * wrapping dispatch factory function for creating local spaces.  If a factory
+     * functionis provided, will use that. If not, then will use
+     * this.fnDefaultLocalSpaceFactory function. Ifthat is also falsy, then this
+     * will default to the NodeFSSpace factory function
+     * `fnCreateNewLocalSpace_NodeFSSpace`.
+     *
+     * @returns newly created local space, or undefined if there was a problem.
+     */
+    createNewLocalSpace({ opts, fnLocalSpaceFactory, }: {
+        opts: CreateLocalSpaceOptions;
+        fnLocalSpaceFactory?: LocalSpaceFactoryFunction;
+    }): Promise<IbGibSpaceAny | undefined>;
+    createLocalSpaceAndUpdateBootstrap({ zeroSpace, allowCancel, createBootstrap, spaceName, }: {
+        zeroSpace: IbGibSpaceAny;
+        allowCancel: boolean;
+        createBootstrap: boolean;
+        spaceName: string | undefined;
+    }): Promise<IbGibSpaceAny | undefined>;
+    createTagIbGib({ text, icon, description, space, }: {
+        text: string;
+        icon?: string;
+        description?: string;
+        space?: IbGibSpaceAny;
+    }): Promise<{
+        newTagIbGib: TagIbGib_V1;
+        newTagsAddr: string;
+    }>;
+    trash({ ibGib_Context, rel8nName_Context, addr, space, }: {
+        ibGib_Context: IbGib_V1;
+        rel8nName_Context: IbGibAddr;
+        addr: IbGibAddr;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    archive({ ibGib_Context, rel8nName_Context, addr, space, }: {
+        ibGib_Context: IbGib_V1;
+        rel8nName_Context: IbGibAddr;
+        addr: IbGibAddr;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    /**
+     * Gets a config addr from the current space via the given key
+     * as the space's rel8n name.
+     *
+     * For example, for `key = tags`, a space may look like:
+     *
+     * ```json
+     * {
+     *    ib: space xyz,
+     *    gib: e89ff8a1c4954db28432007615a78952,
+     *    rel8ns: {
+     *      past: [space xyz^21cb29cc353f45a491d2b49ff2f130db],
+     *      ancestor: [space^gib],
+     *      tags: [tags^99b388355f8f4a979ca30ba284d3a686], // <<< rel8n with name specified by key
+     *    }
+     * }
+     * ```
+     *
+     * @param key config key
+     * @returns addr in config if exists, else undefined
+     */
+    getConfigAddr({ key, space, }: {
+        key: string;
+        space?: IbGibSpaceAny;
+    }): Promise<string | undefined>;
+    fnUpdateBootstrap: (newSpace: IbGibSpaceAny) => Promise<void>;
+    fnBroadcast: (info: IbGibTimelineUpdateInfo) => void;
+    /**
+     * Takes the given `key`, which should be unique in the given space (or
+     * zerospace), and uses that to persist the given `addr` in that space.
+     *
+     * # notes
+     *
+     * configuration is stored in "special" ibgibs, and so we need only to persist
+     * the address of that configuration.
+     */
+    setConfigAddr({ key, addr, space, }: {
+        key: string;
+        addr: string;
+        space?: IbGibSpaceAny;
+    }): Promise<IbGibSpaceAny>;
+    getCurrentRoot({ space, }: {
+        space?: IbGibSpaceAny;
+    }): Promise<IbGib_V1<RootData> | undefined>;
+    setCurrentRoot({ root, space, }: {
+        root: IbGib_V1<RootData>;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    /**
+     * Every tjp should be related to one of the roots in a space.
+     *
+     * You should NOT relate every ibgib frame of a given ibGib.
+     */
+    rel8ToCurrentRoot({ ibGib, linked, rel8nName, space, }: {
+        ibGib: IbGib_V1;
+        linked?: boolean;
+        rel8nName?: string;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    /**
+     * rel8s given ibgibs to special ibgib.
+     * @see {@link rel8ToSpecialIbGib}
+     * @returns new special ibgib addr
+     */
+    rel8ToSpecialIbGib({ type, rel8nName, ibGibsToRel8, ibGibsToUnRel8, linked, severPast, deletePreviousSpecialIbGib, space, }: {
+        type: SpecialIbGibType;
+        rel8nName: string;
+        /**
+         * multiple ibgibs to rel8
+         */
+        ibGibsToRel8?: IbGib_V1[];
+        /**
+         * multiple ibgibs to remove rel8n.
+         */
+        ibGibsToUnRel8?: IbGib_V1[];
+        linked?: boolean;
+        /**
+         * Clears out the special.rel8ns.past array to an empty array.
+         *
+         * {@see deletePreviousSpecialIbGib} for driving use case.
+         */
+        severPast?: boolean;
+        /**
+         * Deletes the previous special ibGib.
+         *
+         * ## driving use case
+         *
+         * the latest ibGib is one that is completely ephemeral. It doesn't get attached
+         * to the current root, and it only has the current instance. So we don't want to
+         * keep around past incarnations.
+         */
+        deletePreviousSpecialIbGib?: boolean;
+        space?: IbGibSpaceAny;
+    }): Promise<IbGibAddr>;
+    /**
+     * Used for tracking tjpAddr -> latest ibGibAddr.
+     *
+     * Call this when you create a new ibGib.
+     *
+     * Need to put this in another service at some point, but crunch crunch
+     * like pacman's lunch.
+     */
+    registerNewIbGib({ ibGib, space, }: {
+        ibGib: IbGib_V1;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    /**
+     * Will trigger a latest info event to be fired.
+     * @param param0
+     */
+    pingLatest_Local({ ibGib, tjpIbGib, space, useCache, }: {
+        ibGib: IbGib_V1<any>;
+        tjpIbGib: IbGib_V1<any> | undefined;
+        space?: IbGibSpaceAny;
+        /**
+         * If true, then will check the latest ibgib cache first. if found, will
+         * just return that.
+         */
+        useCache: boolean;
+    }): Promise<void>;
+    /**
+     * Convenience function for persisting a transform result, which has
+     * a newIbGib and optionally intermediate ibGibs and/or dnas.
+     *
+     * it persists these ibgibs into the given space, else the current space.
+     */
+    persistTransformResult({ resTransform, isMeta, force, space, }: {
+        resTransform: TransformResult<IbGib_V1>;
+        isMeta?: boolean;
+        force?: boolean;
+        space?: IbGibSpaceAny;
+    }): Promise<void>;
+    /**
+     * Wrapper for retrieving ibgib from a given space, else the current space.
+     */
+    get({ addr, addrs, isMeta, isDna, space, }: GetIbGibOpts): Promise<GetIbGibResult>;
+    /**
+     * Wrapper for saving ibgib in a given space, else the current space.
+     */
+    put({ ibGib, ibGibs, isMeta, isDna, force, space, }: PutIbGibOpts): Promise<PutIbGibResult>;
+    /**
+     * Wrapper for removing ibgib from the a given space, else the current space.
+     */
+    delete({ addr, isMeta, isDna, space, }: DeleteIbGibOpts): Promise<DeleteIbGibResult>;
+    /**
+     * Wrapper for `getDependencyGraph` fn in `helper/space.ts`, but using
+     * `this.localUserSpace` as default space.
+     *
+     * (refactoring!)
+     *
+     * ## note on space
+     *
+     * pass in `null` for space if you want to
+     *
+     * ## warning
+     *
+     * This does not (YET) have a flag that gets the latest ibgibs for the graph.
+     * It only climbs the current graph, which may not cover all ibgibs when you
+     * deal with ibGibs with tjps (timelines). We're going to eventually
+     * combat this with auto-updating our rel8ns, but for now we're just going
+     * to earmark this for the future.
+     *
+     * todo: auto-update or better
+     *
+     * @returns map of addr => ibGib
+     */
+    getDependencyGraph(opts: GetDependencyGraphOptions): Promise<{
+        [addr: string]: IbGib_V1;
+    }>;
+    /**
+     * Wrapper for getting the latest addr in the given space.
+     *
+     * ## warnings
+     *
+     * * This was written early and makes many assumptions.
+     * * Meant to work with Ionic space atow.
+     *
+     * @returns latest addr in a given space (or localUserSpace)
+     */
+    getLatestAddr({ ibGib, addr, tjpAddr, tjp, space, }: {
+        ibGib?: IbGib_V1<any>;
+        addr?: IbGibAddr;
+        tjpAddr?: IbGibAddr;
+        tjp?: IbGib_V1<any>;
+        space?: IbGibSpaceAny;
+    }): Promise<IbGibAddr | undefined>;
+    /**
+     * Gets the tjpIbGib for the given `ibGib` in the given `space`.
+     * atow, naive must be true.
+     *
+     *
+     *
+     * @returns tjpIbGib for the given `ibGib`
+     */
+    getTjpIbGib({ ibGib, naive, space, }: {
+        ibGib: IbGib_V1<any>;
+        naive?: boolean;
+        space?: IbGibSpaceAny;
+    }): Promise<IbGib_V1<any> | undefined>;
+    /**
+     * Gets one of the app's special ibGibs, e.g., TagsIbGib.
+     *
+     * When initializing tags, this will generate some boilerplate tags.
+     * I'm going to be doing roots here also, and who knows what else, but each
+     * one will have its own initialize specifics.
+     *
+     * @param initialize initialize (i.e. create) ONLY IF IbGib not found. Used for initializing app (first run).
+     *
+     * @see {@link createSpecial}
+     * @see {@link createTags}
+     */
+    getSpecialIbGib({ type, initialize, space, lock, }: {
+        type: SpecialIbGibType;
+        initialize?: boolean;
+        space?: IbGibSpaceAny;
+        lock?: boolean;
+    }): Promise<IbGib_V1 | null>;
+    getSpecialRel8dIbGibs<TIbGib extends IbGib_V1 = IbGib_V1>({ type, rel8nName, space, }: {
+        type: SpecialIbGibType;
+        rel8nName: string;
+        space?: IbGibSpaceAny;
+    }): Promise<TIbGib[]>;
+    /**
+     * Feels klugy.
+     */
+    getPasswordForSecrets({ secretIbGibs, fnPromptPassword, dontPrompt, checkCacheFirst, cacheAfter, }: {
+        secretIbGibs: IbGib_V1<SecretData_V1>[];
+        fnPromptPassword: (title: string, msg: string) => Promise<string | null>;
+        dontPrompt?: boolean;
+        checkCacheFirst?: boolean;
+        cacheAfter?: boolean;
+    }): Promise<string | null>;
+    getCiphertextIbGib<TEncryptionIbGib extends IbGib_V1<EncryptionData_V1>, TMetadata = any>({ plaintext, password, encryptionIbGib, confirm, persist, ibRoot, publicIbMetadata, publicMetadata, }: {
+        /**
+         * Um...data...to...erm...encrypt...(as a string)
+         */
+        plaintext: string;
+        /**
+         * Password to perform the encryption.
+         */
+        password: string;
+        /**
+         * Information about encryption, i.e. encryption settings.
+         */
+        encryptionIbGib: TEncryptionIbGib;
+        /**
+         * Decrypts and checks against original data
+         */
+        confirm?: boolean;
+        /**
+         * If true, will persist the ibgib
+         */
+        persist?: boolean;
+        /**
+         * If you provide this, the resulting ibgib will have the following format:
+         * `${ibRoot} ${publicIbMetadata}`. Otherwise, this will default to:
+         * `ciphertext ${publicIbMetadata}`, or just `ciphertext` if
+         * `publicIbMetadata` is falsy.
+         */
+        ibRoot?: string;
+        /**
+         * If you want to include metadata in the ib itself of the
+         * ciphertext ibgib. This will of course make this metadata
+         * available without loading the full ibgib, but will increase
+         * storage size because every address linking to the ibgib will
+         * include this as well.
+         */
+        publicIbMetadata?: string;
+        /**
+         * If you want to include public, unencrypted metadata in the ibgib's
+         * data body itself.
+         */
+        publicMetadata?: TMetadata;
+    }): Promise<TransformResult<CiphertextIbGib_V1>>;
+    /**
+     * Brings together a ciphertext and secretIbGibs to decrypt
+     * the `ciphertextIbGib.data.ciphertext`
+     * @returns plaintext string of `ciphertextIbGib.data.ciphertext`
+     */
+    getPlaintextString({ ciphertextIbGib, secretIbGibs, fnPromptPassword, dontPrompt, space, }: {
+        ciphertextIbGib: CiphertextIbGib_V1;
+        secretIbGibs: SecretIbGib_V1[];
+        fnPromptPassword: (title: string, msg: string) => Promise<string | null>;
+        dontPrompt?: boolean;
+        space: IbGibSpaceAny;
+    }): Promise<string>;
+    unwrapEncryptedSyncSpace({ encryptedSpace, fnPromptPassword, dontPrompt, space, fnSpaceFactory, }: {
+        encryptedSpace: IbGibSpaceAny;
+        fnPromptPassword: (title: string, msg: string) => Promise<string | null>;
+        dontPrompt?: boolean;
+        space?: IbGibSpaceAny;
+        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>;
+    }): Promise<IbGibSpaceAny>;
+    /**
+     * Caching user password secret in memory only.
+     *
+     * Just to prevent plaintext passwords from just sitting in memory,
+     * this is a slight layer of indirection for caching
+     *
+     * @returns user password
+     */
+    protected getCachedSecretPassword({ cacheKey, }: {
+        cacheKey: string;
+    }): Promise<string | undefined>;
+    protected setCachedSecretPassword({ cacheKey, secretPassword, force, }: {
+        cacheKey: string;
+        secretPassword: string;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * If we don't have outerspaces/cloud endpoints, we'll do that here.
+     *
+     * @returns true if creation was successfully created, else false.
+     */
+    protected _createOuterspaceAndRequiredIbGibs({ space, fnPromptSecret, fnPromptEncryption, fnPromptOuterSpace, }: {
+        space: IbGibSpaceAny;
+        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>;
+        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib | undefined>;
+        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>;
+    }): Promise<boolean>;
+    protected _createSecret({ space, fnPromptSecret, }: {
+        space: IbGibSpaceAny;
+        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>;
+    }): Promise<boolean>;
+    protected _createEncryption({ space, fnPromptEncryption, }: {
+        space: IbGibSpaceAny;
+        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib | undefined>;
+    }): Promise<boolean>;
+    protected _createOuterspace({ space, fnPromptOuterSpace, }: {
+        space: IbGibSpaceAny;
+        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>;
+    }): Promise<boolean>;
+    getAppSyncSpaces({ unwrapEncrypted, createIfNone, dontPrompt, space, fnSpaceFactory, fnPromptSecret, fnPromptEncryption, fnPromptOuterSpace, }: {
+        unwrapEncrypted: boolean;
+        createIfNone: boolean;
+        /**
+         * If true, don't prompt the user if we don't have it already cached.
+         *
+         * We don't want the user to hit the page and then always have to type in
+         * the password, just because my password code sucks atow.
+         */
+        dontPrompt?: boolean;
+        space?: IbGibSpaceAny;
+        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>;
+        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>;
+        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib | undefined>;
+        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>;
+    }): Promise<IbGibSpaceAny[]>;
+    getAppRobbotIbGibs({ createIfNone, space, }: {
+        createIfNone: boolean;
+        space?: IbGibSpaceAny;
+    }): Promise<RobbotIbGib_V1[]>;
+    getAppAppIbGibs({ createIfNone, space, }: {
+        createIfNone: boolean;
+        space?: IbGibSpaceAny;
+    }): Promise<AppIbGib_V1[]>;
+    protected subSagaSyncTimeLog: Subscription | undefined;
+    syncIbGibs({ dependencyGraphIbGibs, watch, fnPreSyncProgress, fnSpaceFactory, fnPromptSecret, fnPromptEncryption, fnPromptOuterSpace, }: {
+        dependencyGraphIbGibs?: IbGib_V1[];
+        /**
+         * If true, will watch ibgibs in dependency graph that have timelines
+         * (tjps).
+         */
+        watch?: boolean;
+        /**
+         * The meat of the sync process is tracked via a status within the sync
+         * spaces themselves. I'm addign this fn to track the pre and post progress
+         * stuff, since decrypting takes some time, and building the dependency
+         * graphs takes time. Both of these happen before the actual syncing occurs
+         * in the spaces.
+         */
+        fnPreSyncProgress?: (msg: string) => Promise<void>;
+        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>;
+        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>;
+        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib | undefined>;
+        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>;
+    }): Promise<SyncSagaInfo[] | undefined>;
+    protected finalizeSyncSaga({ sagaInfo, error, }: {
+        sagaInfo: SyncSagaInfo;
+        error?: any;
+    }): void;
+    protected finalizeAllSyncSagas_NoThrow({ error, }: {
+        error?: any;
+    }): void;
+    protected _updateSagaInfoMapAndIsSyncingFlag(): void;
+    protected _createNewSyncSagaInfo({ multiSpaceOpId, allIbGibsToSync, syncSpace, participants, sagaId, syncStatus$, }: {
+        multiSpaceOpId: string;
+        allIbGibsToSync: IbGib_V1[];
+        syncSpace: IbGibSpaceAny;
+        participants: ParticipantInfo[];
+        /**
+         * have to make this early to enable the console.time/Log calls.
+         */
+        sagaId: string;
+        /**
+         * have to make this early to enable the console.time/Log calls.
+         */
+        syncStatus$: ReplaySubject<SyncStatusIbGib>;
+    }): Promise<SyncSagaInfo>;
+    /**
+     * this {@link IbGibsService} acts as the local app space intermediary,
+     * a broker between the local space and the sync space(s). So this
+     * function's job is to coordinate sending the given ibgibs
+     * to a single sync space and return the observable (subject)
+     * corresponding to the multi-step sync process.
+     *
+     * The caller will be responsible for coordinating among sync
+     * space results and handling updates to local space ibgib's,
+     * such as rebasing/updating/etc.
+     *
+     * @returns
+     */
+    protected _startSync({ syncSagaInfo, watch, syncTimelogName, }: {
+        syncSagaInfo: SyncSagaInfo;
+        watch?: boolean;
+        /**
+         * Will confirm via checking existence of ibgibs in sync space after
+         * writing them.
+         *
+         * NOTE: IGNORED ATM
+         */
+        syncTimelogName: string;
+    }): Promise<SyncSpaceResultIbGib>;
+    /**
+     * Coming in to this function, we have results from one or more
+     * sync spaces. Here are the combinations of expected outcomes:
+     *
+     * 1. All success, each returns the exact same new ib^gib address(es).
+     * 2. All success, but different spaces return different ib^gib address(es).
+     * 3. Some success, which returns exact same new ib^gib, some error.
+     * 4. Some success, more than one ib^gib address(es), some error.
+     * 5. All error.
+     *
+     * For the first naive implementation, we will always be optimistic,
+     * assuming that errors will be resolved with enough attempts. This
+     * is closely related to our initial optimistic strategy of
+     * "access is authorization" + "unordered dna equivalence". These
+     * strategies mean that we are simply, optimistically, and
+     * naively applying incoming dna transforms to ibgib timelines.
+     * So failure should only result from a failure at the communication
+     * layer, assuming non-adversarial conditions.
+     *
+     * ## future
+     *
+     * The handling of this should absolutely be generalized to the
+     * requirements for interspatial relationships. This is the language
+     * that must be implemented to deal with this in a dynamic fashion.
+     *
+     * This does not equate to only "ad hoc" in the sense of untested/untried.
+     * This means that we have an "on-chain", public linked requirement
+     * for consensus as opposed to a hard-coded consensus as is defined
+     * in this function.
+     *
+     * It is in this generalization that byzantine resolution can be
+     * achieved through whichever mechanism is correct for the use case.
+     */
+    protected _handleSagaUpdates(): Promise<void>;
+    protected _handleSyncStatusIbGib({ status, sagaInfo, }: {
+        status: SyncStatusIbGib;
+        sagaInfo: SyncSagaInfo;
+    }): Promise<void>;
+    protected handleSyncStatus_Merged({ status, }: {
+        status: SyncStatusIbGib;
+    }): Promise<void>;
+    protected handleSyncStatus_Complete({ sagaInfo, }: {
+        sagaInfo: SyncSagaInfo;
+    }): Promise<void>;
+    /**
+     * Searches through timelines and gets every single one of them
+     * in the local space. (ideally)
+     *
+     * ## notes
+     *
+     * So if you pass in an ibgib with a reference to old ibgibs that
+     * have not been updated to the latest, this will get those latest.
+     *
+     * @returns all ibgibs related to given ibgibs
+     */
+    protected _getLatestIbGibsWithTjps({ ibGibs, warnIfMultipleLocalTimelines, }: {
+        ibGibs: IbGib_V1[];
+        /**
+         * I've already written the code to check for this. But I think
+         * this will be normal when put/merging.
+         */
+        warnIfMultipleLocalTimelines?: boolean;
+    }): Promise<IbGib_V1[]>;
+    protected handleWatchTjpUpdates({ updates, outerSpace, localUserSpace, }: {
+        updates: {
+            [tjpAddr: string]: IbGibAddr;
+        };
+        outerSpace: IbGibSpaceAny;
+        localUserSpace: IbGibSpaceAny;
+    }): Promise<void>;
+    enableAutosync({ tjpIbGibs, }: {
+        tjpIbGibs: IbGib_V1[];
+    }): Promise<void>;
+    disableAutosync({ tjpIbGibs, }: {
+        tjpIbGibs: IbGib_V1[];
+    }): Promise<void>;
+    protected loadAutoSyncs(): Promise<void>;
+    /**
+     * checks to see if autosync is enabled for a given `tjp`.
+     *
+     * NOTE: this only checks cache atm.
+     *
+     * @returns true if autosync is enabled for the given tjp, else false
+     */
+    autosyncIsEnabled({ tjp, }: {
+        tjp: IbGib_V1;
+    }): boolean;
+}
+//# sourceMappingURL=metaspace-base.d.mts.map