@teambit/objects 0.0.0-00042bc99514ea12d897f81bcd0181e2b034c615

package/dist/objects/raw-object.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.utils");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.scope");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class BitRawObject {
+  constructor(buffer, ref, type, content, parsedContent) {
+    _defineProperty(this, "headers", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "content", void 0);
+    _defineProperty(this, "parsedContent", void 0);
+    _defineProperty(this, "_ref", void 0);
+    let headers;
+    let contentFromBuffer;
+    if (buffer) {
+      const firstNullByteLocation = buffer.indexOf(_legacy().NULL_BYTE);
+      headers = buffer.slice(0, firstNullByteLocation).toString();
+      contentFromBuffer = buffer.slice(firstNullByteLocation + 1, buffer.length);
+    }
+    this.content = content || contentFromBuffer;
+    this.headers = headers ? headers.split(_legacy().SPACE_DELIMITER) : undefined;
+    const typeFromHeader = this.headers ? this.headers[0] : undefined;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this.type = type || typeFromHeader;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this._ref = ref;
+    this.parsedContent = parsedContent || this.getParsedContent();
+  }
+  getParsedContent() {
+    if (this.parsedContent) return this.parsedContent;
+    let parsedContent;
+    switch (this.type) {
+      case 'Version':
+      case 'Component':
+      case 'Symlink':
+      case 'ScopeMeta':
+      case 'VersionHistory':
+        parsedContent = JSON.parse(this.content.toString());
+        break;
+      default:
+        parsedContent = this.content;
+    }
+    return parsedContent;
+  }
+  getString(pretty) {
+    const args = (0, _legacy2().getStringifyArgs)(pretty);
+    switch (this.type) {
+      case 'Version':
+      case 'Component':
+      case 'Symlink':
+      case 'ScopeMeta':
+      case 'VersionHistory':
+        return JSON.stringify(this.parsedContent, ...args);
+      case 'Source':
+        return pretty ? JSON.stringify(JSON.parse(this.content.toString()), ...args) : this.content;
+      default:
+        return this.content;
+    }
+  }
+  set ref(ref) {
+    this._ref = ref;
+  }
+  get ref() {
+    return this._ref;
+  }
+  get id() {
+    switch (this.type) {
+      case 'Version':
+        return 'component version';
+      case 'Component':
+        return this.parsedContent.scope ? [this.parsedContent.scope, this.parsedContent.name].join('/') : this.parsedContent.name;
+      case 'Symlink':
+        return this.parsedContent.name;
+      case 'ScopeMeta':
+        return this.parsedContent.name;
+      default:
+        return 'component source file';
+    }
+  }
+  refs() {
+    if (this.type === 'Component') {
+      return Object.values(this.parsedContent.versions);
+    }
+    if (this.type === 'Version') {
+      const files = this.parsedContent.files ? this.parsedContent.files.map(file => file.file) : [];
+      const dists = this.parsedContent.dists ? this.parsedContent.dists.map(dist => dist.file) : [];
+      return [...dists, ...files].filter(ref => ref);
+    }
+    return [];
+  }
+  static async fromDeflatedBuffer(fileContents, ref) {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return (0, _legacy2().inflate)(fileContents).then(buffer => new BitRawObject(buffer, ref));
+  }
+
+  /**
+   * Build a real object (model) from a parsed content (can be the original parsed conents or a provided one)
+   * We use the provided version during the migration process when we change the parsed content outside
+   * @param {Any} parsedContent
+   */
+  toRealObject() {
+    return _legacy3().typesObj[this.type].from(this.parsedContent || this.getParsedContent(), this.headers[1]);
+  }
+  clone() {
+    const parsedContent = this.parsedContent ? (0, _lodash().clone)(this.parsedContent) : undefined;
+    // TODO: Should also clone the buffers (content)
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return new BitRawObject(undefined, this._ref, this.type, this.content, parsedContent);
+  }
+}
+exports.default = BitRawObject;
+
+//# sourceMappingURL=raw-object.js.map

package/dist/objects/raw-object.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_legacy","data","require","_legacy2","_legacy3","_lodash","_defineProperty","e","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","BitRawObject","constructor","buffer","ref","type","content","parsedContent","headers","contentFromBuffer","firstNullByteLocation","indexOf","NULL_BYTE","slice","toString","length","split","SPACE_DELIMITER","undefined","typeFromHeader","_ref","getParsedContent","JSON","parse","getString","pretty","args","getStringifyArgs","stringify","id","scope","name","join","refs","values","versions","files","map","file","dists","dist","filter","fromDeflatedBuffer","fileContents","inflate","then","toRealObject","types","from","clone","exports","default"],"sources":["raw-object.ts"],"sourcesContent":["import { NULL_BYTE, SPACE_DELIMITER } from '@teambit/legacy.constants';\nimport { getStringifyArgs, inflate } from '@teambit/legacy.utils';\nimport { typesObj as types } from '@teambit/legacy.scope';\nimport type BitObject from './object';\nimport { clone } from 'lodash';\n\nexport default class BitRawObject {\n  headers: string[];\n  type: string;\n  content: Buffer;\n  parsedContent: any;\n  _ref: string;\n\n  constructor(\n    buffer: Buffer,\n    ref: string | null | undefined,\n    type: string | null | undefined,\n    content: Buffer | null | undefined,\n    parsedContent: any | null | undefined\n  ) {\n    let headers;\n    let contentFromBuffer;\n    if (buffer) {\n      const firstNullByteLocation = buffer.indexOf(NULL_BYTE);\n      headers = buffer.slice(0, firstNullByteLocation).toString();\n      contentFromBuffer = buffer.slice(firstNullByteLocation + 1, buffer.length);\n    }\n    this.content = content || contentFromBuffer;\n    this.headers = headers ? headers.split(SPACE_DELIMITER) : undefined;\n    const typeFromHeader = this.headers ? this.headers[0] : undefined;\n    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n    this.type = type || typeFromHeader;\n    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n    this._ref = ref;\n    this.parsedContent = parsedContent || this.getParsedContent();\n  }\n\n  getParsedContent() {\n    if (this.parsedContent) return this.parsedContent;\n    let parsedContent;\n    switch (this.type) {\n      case 'Version':\n      case 'Component':\n      case 'Symlink':\n      case 'ScopeMeta':\n      case 'VersionHistory':\n        parsedContent = JSON.parse(this.content.toString());\n        break;\n\n      default:\n        parsedContent = this.content;\n    }\n    return parsedContent;\n  }\n\n  getString(pretty: boolean) {\n    const args = getStringifyArgs(pretty);\n    switch (this.type) {\n      case 'Version':\n      case 'Component':\n      case 'Symlink':\n      case 'ScopeMeta':\n      case 'VersionHistory':\n        return JSON.stringify(this.parsedContent, ...args);\n      case 'Source':\n        return pretty ? JSON.stringify(JSON.parse(this.content.toString()), ...args) : this.content;\n\n      default:\n        return this.content;\n    }\n  }\n\n  set ref(ref: string) {\n    this._ref = ref;\n  }\n\n  get ref(): string {\n    return this._ref;\n  }\n\n  get id(): string {\n    switch (this.type) {\n      case 'Version':\n        return 'component version';\n      case 'Component':\n        return this.parsedContent.scope\n          ? [this.parsedContent.scope, this.parsedContent.name].join('/')\n          : this.parsedContent.name;\n      case 'Symlink':\n        return this.parsedContent.name;\n      case 'ScopeMeta':\n        return this.parsedContent.name;\n\n      default:\n        return 'component source file';\n    }\n  }\n\n  refs(): string[] {\n    if (this.type === 'Component') {\n      return Object.values(this.parsedContent.versions);\n    }\n    if (this.type === 'Version') {\n      const files = this.parsedContent.files ? this.parsedContent.files.map((file) => file.file) : [];\n      const dists = this.parsedContent.dists ? this.parsedContent.dists.map((dist) => dist.file) : [];\n      return [...dists, ...files].filter((ref) => ref);\n    }\n\n    return [];\n  }\n\n  static async fromDeflatedBuffer(fileContents: Buffer, ref: string | null | undefined): Promise<BitObject> {\n    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n    return inflate(fileContents).then((buffer) => new BitRawObject(buffer, ref));\n  }\n\n  /**\n   * Build a real object (model) from a parsed content (can be the original parsed conents or a provided one)\n   * We use the provided version during the migration process when we change the parsed content outside\n   * @param {Any} parsedContent\n   */\n  toRealObject() {\n    return types[this.type].from(this.parsedContent || this.getParsedContent(), this.headers[1]);\n  }\n\n  clone() {\n    const parsedContent = this.parsedContent ? clone(this.parsedContent) : undefined;\n    // TODO: Should also clone the buffers (content)\n    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n    return new BitRawObject(undefined, this._ref, this.type, this.content, parsedContent);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/objects/ref.d.ts

@@ -0,0 +1,14 @@
+import type BitObject from './object';
+import type Repository from './repository';
+export default class Ref {
+    hash: string;
+    constructor(hash: string);
+    toString(): string;
+    toShortString(numOfChars?: number): string;
+    load(repository: Repository, throws?: boolean): Promise<BitObject>;
+    loadSync(repo: Repository, throws?: boolean): BitObject;
+    loadRaw(repo: Repository): Promise<Buffer>;
+    isEqual(ref: Ref): boolean;
+    clone(): Ref;
+    static from(hash: string): Ref;
+}

package/dist/objects/ref.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class Ref {
+  constructor(hash) {
+    _defineProperty(this, "hash", void 0);
+    if (!hash) throw new Error('failed creating a Ref object, the hash argument is empty');
+    this.hash = hash;
+  }
+  toString() {
+    // reason for hash.toString() is when working with short hash, it's possible that all characters are numbers
+    // so it's needed to convert it to string
+    return this.hash.toString();
+  }
+  toShortString(numOfChars = 9) {
+    return this.hash.substring(0, numOfChars).toString();
+  }
+  load(repository, throws = false) {
+    return repository.load(this, throws);
+  }
+  loadSync(repo, throws = true) {
+    return repo.loadSync(this, throws);
+  }
+  loadRaw(repo) {
+    return repo.loadRaw(this);
+  }
+  isEqual(ref) {
+    return this.toString() === ref.toString();
+  }
+  clone() {
+    return new Ref(this.hash);
+  }
+  static from(hash) {
+    return new Ref(hash);
+  }
+}
+exports.default = Ref;
+
+//# sourceMappingURL=ref.js.map

package/dist/objects/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Ref","constructor","hash","_defineProperty","Error","toString","toShortString","numOfChars","substring","load","repository","throws","loadSync","repo","loadRaw","isEqual","ref","clone","from","exports","default"],"sources":["ref.ts"],"sourcesContent":["import type BitObject from './object';\nimport type Repository from './repository';\n\nexport default class Ref {\n  hash: string;\n\n  constructor(hash: string) {\n    if (!hash) throw new Error('failed creating a Ref object, the hash argument is empty');\n    this.hash = hash;\n  }\n\n  toString() {\n    // reason for hash.toString() is when working with short hash, it's possible that all characters are numbers\n    // so it's needed to convert it to string\n    return this.hash.toString();\n  }\n\n  toShortString(numOfChars = 9) {\n    return this.hash.substring(0, numOfChars).toString();\n  }\n\n  load(repository: Repository, throws = false): Promise<BitObject> {\n    return repository.load(this, throws);\n  }\n\n  loadSync(repo: Repository, throws = true): BitObject {\n    return repo.loadSync(this, throws);\n  }\n\n  loadRaw(repo: Repository): Promise<Buffer> {\n    return repo.loadRaw(this);\n  }\n\n  isEqual(ref: Ref): boolean {\n    return this.toString() === ref.toString();\n  }\n\n  clone() {\n    return new Ref(this.hash);\n  }\n\n  static from(hash: string): Ref {\n    return new Ref(hash);\n  }\n}\n"],"mappings":";;;;;;;;;AAGe,MAAMA,GAAG,CAAC;EAGvBC,WAAWA,CAACC,IAAY,EAAE;IAAAC,eAAA;IACxB,IAAI,CAACD,IAAI,EAAE,MAAM,IAAIE,KAAK,CAAC,0DAA0D,CAAC;IACtF,IAAI,CAACF,IAAI,GAAGA,IAAI;EAClB;EAEAG,QAAQA,CAAA,EAAG;IACT;IACA;IACA,OAAO,IAAI,CAACH,IAAI,CAACG,QAAQ,CAAC,CAAC;EAC7B;EAEAC,aAAaA,CAACC,UAAU,GAAG,CAAC,EAAE;IAC5B,OAAO,IAAI,CAACL,IAAI,CAACM,SAAS,CAAC,CAAC,EAAED,UAAU,CAAC,CAACF,QAAQ,CAAC,CAAC;EACtD;EAEAI,IAAIA,CAACC,UAAsB,EAAEC,MAAM,GAAG,KAAK,EAAsB;IAC/D,OAAOD,UAAU,CAACD,IAAI,CAAC,IAAI,EAAEE,MAAM,CAAC;EACtC;EAEAC,QAAQA,CAACC,IAAgB,EAAEF,MAAM,GAAG,IAAI,EAAa;IACnD,OAAOE,IAAI,CAACD,QAAQ,CAAC,IAAI,EAAED,MAAM,CAAC;EACpC;EAEAG,OAAOA,CAACD,IAAgB,EAAmB;IACzC,OAAOA,IAAI,CAACC,OAAO,CAAC,IAAI,CAAC;EAC3B;EAEAC,OAAOA,CAACC,GAAQ,EAAW;IACzB,OAAO,IAAI,CAACX,QAAQ,CAAC,CAAC,KAAKW,GAAG,CAACX,QAAQ,CAAC,CAAC;EAC3C;EAEAY,KAAKA,CAAA,EAAG;IACN,OAAO,IAAIjB,GAAG,CAAC,IAAI,CAACE,IAAI,CAAC;EAC3B;EAEA,OAAOgB,IAAIA,CAAChB,IAAY,EAAO;IAC7B,OAAO,IAAIF,GAAG,CAACE,IAAI,CAAC;EACtB;AACF;AAACiB,OAAA,CAAAC,OAAA,GAAApB,GAAA","ignoreList":[]}

package/dist/objects/repository.d.ts

@@ -0,0 +1,165 @@
+import { Mutex } from 'async-mutex';
+import type { ComponentID } from '@teambit/component-id';
+import type { PathOsBasedAbsolute } from '@teambit/legacy.utils';
+import type { Types, ScopeJson } from '@teambit/legacy.scope';
+import { UnmergedComponents, RemoteLanes } from '@teambit/legacy.scope';
+import type { IndexType } from './scope-index';
+import { ScopeIndex } from './scope-index';
+import BitObject from './object';
+import type { ObjectItem } from './object-list';
+import { ObjectList } from './object-list';
+import BitRawObject from './raw-object';
+import Ref from './ref';
+import type { InMemoryCache } from '@teambit/harmony.modules.in-memory-cache';
+type ContentTransformer = (content: Buffer) => Buffer;
+export default class Repository {
+    objects: {
+        [key: string]: BitObject;
+    };
+    objectsToRemove: Ref[];
+    scopeJson: ScopeJson;
+    onRead: ContentTransformer;
+    onPersist: ContentTransformer;
+    scopePath: string;
+    scopeIndex: ScopeIndex;
+    protected cache: InMemoryCache<BitObject>;
+    remoteLanes: RemoteLanes;
+    unmergedComponents: UnmergedComponents;
+    _persistMutex?: Mutex;
+    constructor(scopePath: string, scopeJson: ScopeJson);
+    get persistMutex(): Mutex;
+    static load({ scopePath, scopeJson }: {
+        scopePath: string;
+        scopeJson: ScopeJson;
+    }): Promise<Repository>;
+    init(): Promise<void>;
+    static create({ scopePath, scopeJson }: {
+        scopePath: string;
+        scopeJson: ScopeJson;
+    }): Promise<Repository>;
+    static reset(scopePath: string): Promise<void>;
+    static getPathByScopePath(scopePath: string): string;
+    static onPostObjectsPersist: () => Promise<void>;
+    /**
+     * Hook for transforming content before objects are persisted to the filesystem.
+     * Note: This function cannot be async because it's used by the synchronous `loadSync` method
+     * which needs to maintain sync behavior for compatibility with existing code.
+     */
+    static onPreObjectPersist: (content: Buffer) => Buffer;
+    /**
+     * Hook for transforming content after objects are read from the filesystem.
+     * Note: This function cannot be async because it's used by the synchronous `loadSync` method
+     * which needs to maintain sync behavior for compatibility with existing code.
+     */
+    static onPostObjectRead: (content: Buffer) => Buffer;
+    reLoadScopeIndex(): Promise<void>;
+    /**
+     * current scope index difference with <scope_folder>/index.json content, reload it
+     * @deprecated use Scope aspect `watchSystemFiles` instead, it's way more efficient.
+     */
+    reloadScopeIndexIfNeed(force?: boolean): Promise<void>;
+    ensureDir(): Promise<void>;
+    getPath(): string;
+    getBackupPath(dirName?: string): string;
+    getTrashDir(): string;
+    getLicense(): Promise<string>;
+    getScopeMetaObject(): Promise<ObjectItem>;
+    objectPath(ref: Ref): string;
+    has(ref: Ref): Promise<boolean>;
+    hasMultiple(refs: Ref[]): Promise<Ref[]>;
+    load(ref: Ref, throws?: boolean): Promise<BitObject>;
+    /**
+     * this is restricted to provide objects according to the given types. Otherwise, big scopes (>1GB) could crush.
+     * example usage: `this.list([ModelComponent, Symlink, Lane])`
+     */
+    list(types: Types): Promise<BitObject[]>;
+    loadRefDeleteIfInvalid(ref: Ref): Promise<BitObject | undefined>;
+    loadRefOnlyIfType(ref: Ref, types: Types): Promise<BitObject | null>;
+    listRefs(cwd?: string): Promise<Array<Ref>>;
+    listRefsStartWith(shortHash: Ref): Promise<Array<Ref>>;
+    listRawObjects(): Promise<any>;
+    listObjectsFromIndex(indexType: IndexType, filter?: Function): Promise<BitObject[]>;
+    getHashFromIndex(indexType: IndexType, filter: Function): string | null;
+    _getBitObjectsByHashes(hashes: string[]): Promise<BitObject[]>;
+    loadOptionallyCreateScopeIndex(): Promise<ScopeIndex>;
+    loadRaw(ref: Ref): Promise<Buffer>;
+    getFullRefFromShortHash(ref: Ref): Promise<Ref>;
+    loadManyRaw(refs: Ref[]): Promise<ObjectItem[]>;
+    loadManyRawIgnoreMissing(refs: Ref[]): Promise<ObjectItem[]>;
+    loadRawObject(ref: Ref): Promise<BitRawObject>;
+    /**
+     * prefer using `this.load()` for an async version, which also writes to the cache
+     */
+    loadSync(ref: Ref, throws?: boolean): BitObject;
+    setCache(object: BitObject): this;
+    getCache(ref: Ref): BitObject | undefined;
+    removeFromCache(ref: Ref): void;
+    clearCache(): Promise<void>;
+    clearObjectsFromCache(): void;
+    backup(dirName?: string): void;
+    add(object: BitObject | null | undefined): Repository;
+    addMany(objects: BitObject[]): Repository;
+    removeObject(ref: Ref): void;
+    removeManyObjects(refs: Ref[]): void;
+    findMany(refs: Ref[]): Promise<BitObject[]>;
+    /**
+     * important! use this method only for commands that are non running on an http server.
+     *
+     * it's better to remove/delete objects directly and not using the `objects` member.
+     * it helps to avoid multiple processes running concurrently on an http server.
+     *
+     * persist objects changes (added and removed) into the filesystem
+     * do not call this function multiple times in parallel, otherwise, it'll damage the index.json file.
+     * call this function only once after you added and removed all applicable objects.
+     */
+    persist(validate?: boolean): Promise<void>;
+    writeRemoteLanes(): Promise<void>;
+    /**
+     * this is especially critical for http server, where one process lives long and serves multiple
+     * exports. without this, the objects get accumulated over time and being rewritten over and over
+     * again.
+     */
+    private clearObjects;
+    /**
+     * normally, the validation step takes place just before the acutal writing of the file.
+     * however, this can be an issue where a component has an invalid version. the component could
+     * be saved before validating the version (see #1727). that's why we validate here before writing
+     * anything to the filesystem.
+     * the open question here is whether should we validate again before the actual writing or it
+     * should be enough to validate here?
+     * for now, it does validate again before saving, only to be 100% sure nothing happens in a few
+     * lines of code until the actual writing. however, if the performance penalty is noticeable, we
+     * can easily revert it by changing `bitObject.validateBeforePersist = false` line run regardless
+     * the `validate` argument.
+     */
+    validateObjects(validate: boolean, objects: BitObject[]): void;
+    deleteObjectsFromFS(refs: Ref[]): Promise<void>;
+    moveObjectsToDir(refs: Ref[], dir: string): Promise<void>;
+    moveObjectsToTrash(refs: Ref[]): Promise<void>;
+    listTrash(): Promise<Ref[]>;
+    getFromTrash(refs: Ref[]): Promise<BitObject[]>;
+    restoreFromTrash(refs: Ref[]): Promise<void>;
+    restoreFromDir(dir: string, overwrite?: boolean): Promise<void>;
+    private moveOneObjectToDir;
+    private moveOneObjectToTrash;
+    deleteRecordsFromUnmergedComponents(compIds: ComponentID[]): Promise<void>;
+    /**
+     * write all objects to the FS and index the components/lanes/symlink objects
+     */
+    writeObjectsToTheFS(objects: BitObject[]): Promise<void>;
+    /**
+     * do not call this method directly. always call this.removeObject() and once done with all objects,
+     * call this.persist()
+     */
+    _deleteOne(ref: Ref): Promise<boolean>;
+    /**
+     * always prefer this.persist() or this.writeObjectsToTheFS()
+     * this method doesn't write to scopeIndex. so using this method for ModelComponent or
+     * Symlink makes the index outdated.
+     */
+    _writeOne(object: BitObject): Promise<boolean>;
+    writeObjectsToPendingDir(objectList: ObjectList, pendingDir: PathOsBasedAbsolute): Promise<void>;
+    readObjectsFromPendingDir(pendingDir: PathOsBasedAbsolute): Promise<ObjectList>;
+    private hashPath;
+}
+export {};