@sussudio/platform/userDataSync/common/userDataSyncService.d.mts

Internal APIs for VS Code's service injection the base services.

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { CancellationToken } from '@sussudio/base/common/cancellation.mjs';
import { Event } from '@sussudio/base/common/event.mjs';
import { Disposable, IDisposable } from '@sussudio/base/common/lifecycle.mjs';
import { URI } from '@sussudio/base/common/uri.mjs';
import { IConfigurationService } from '../../configuration/common/configuration.mjs';
import { IExtensionGalleryService } from '../../extensionManagement/common/extensionManagement.mjs';
import { IInstantiationService } from '../../instantiation/common/instantiation.mjs';
import { IStorageService } from '../../storage/common/storage.mjs';
import { ITelemetryService } from '../../telemetry/common/telemetry.mjs';
import { IUserDataProfile, IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.mjs';
import {
	IUserDataManualSyncTask,
	IUserDataSyncResourceConflicts,
	IUserDataSyncResourceError,
	IUserDataSyncResource,
	ISyncResourceHandle,
	IUserDataSyncTask,
	ISyncUserDataProfile,
	IUserDataManifest,
	IUserDataSyncEnablementService,
	IUserDataSynchroniser,
	IUserDataSyncLogService,
	IUserDataSyncService,
	IUserDataSyncStoreManagementService,
	IUserDataSyncStoreService,
	SyncResource,
	SyncStatus,
	UserDataSyncError,
	IUserDataSyncResourceProviderService,
} from './userDataSync.mjs';
export declare class UserDataSyncService extends Disposable implements IUserDataSyncService {
	private readonly userDataSyncStoreService;
	private readonly userDataSyncStoreManagementService;
	private readonly instantiationService;
	private readonly logService;
	private readonly telemetryService;
	private readonly storageService;
	private readonly userDataSyncEnablementService;
	private readonly userDataProfilesService;
	private readonly userDataSyncResourceProviderService;
	_serviceBrand: any;
	private _status;
	get status(): SyncStatus;
	private _onDidChangeStatus;
	readonly onDidChangeStatus: Event<SyncStatus>;
	private _onDidChangeLocal;
	readonly onDidChangeLocal: Event<SyncResource>;
	private _conflicts;
	get conflicts(): IUserDataSyncResourceConflicts[];
	private _onDidChangeConflicts;
	readonly onDidChangeConflicts: Event<IUserDataSyncResourceConflicts[]>;
	private _syncErrors;
	private _onSyncErrors;
	readonly onSyncErrors: Event<IUserDataSyncResourceError[]>;
	private _lastSyncTime;
	get lastSyncTime(): number | undefined;
	private _onDidChangeLastSyncTime;
	readonly onDidChangeLastSyncTime: Event<number>;
	private _onDidResetLocal;
	readonly onDidResetLocal: Event<void>;
	private _onDidResetRemote;
	readonly onDidResetRemote: Event<void>;
	private activeProfileSynchronizers;
	constructor(
		userDataSyncStoreService: IUserDataSyncStoreService,
		userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
		instantiationService: IInstantiationService,
		logService: IUserDataSyncLogService,
		telemetryService: ITelemetryService,
		storageService: IStorageService,
		userDataSyncEnablementService: IUserDataSyncEnablementService,
		userDataProfilesService: IUserDataProfilesService,
		userDataSyncResourceProviderService: IUserDataSyncResourceProviderService,
	);
	createSyncTask(manifest: IUserDataManifest | null, disableCache?: boolean): Promise<IUserDataSyncTask>;
	createManualSyncTask(): Promise<IUserDataManualSyncTask>;
	private sync;
	private syncRemoteProfiles;
	private applyManualSync;
	private syncProfile;
	private stop;
	resolveContent(resource: URI): Promise<string | null>;
	replace(syncResourceHandle: ISyncResourceHandle): Promise<void>;
	accept(
		syncResource: IUserDataSyncResource,
		resource: URI,
		content: string | null | undefined,
		apply:
			| boolean
			| {
					force: boolean;
			  },
	): Promise<void>;
	getRemoteProfiles(): Promise<ISyncUserDataProfile[]>;
	getRemoteSyncResourceHandles(
		syncResource: SyncResource,
		profile?: ISyncUserDataProfile,
	): Promise<ISyncResourceHandle[]>;
	getLocalSyncResourceHandles(syncResource: SyncResource, profile?: IUserDataProfile): Promise<ISyncResourceHandle[]>;
	getAssociatedResources(syncResourceHandle: ISyncResourceHandle): Promise<
		{
			resource: URI;
			comparableResource: URI;
		}[]
	>;
	getMachineId(syncResourceHandle: ISyncResourceHandle): Promise<string | undefined>;
	hasLocalData(): Promise<boolean>;
	hasPreviouslySynced(): Promise<boolean>;
	reset(): Promise<void>;
	resetRemote(): Promise<void>;
	resetLocal(): Promise<void>;
	cleanUpRemoteData(): Promise<void>;
	private performAction;
	private performActionWithProfileSynchronizer;
	private setStatus;
	private updateConflicts;
	private updateLastSyncTime;
	getOrCreateActiveProfileSynchronizer(
		profile: IUserDataProfile,
		syncProfile: ISyncUserDataProfile | undefined,
	): ProfileSynchronizer;
	private getActiveProfileSynchronizers;
	private clearActiveProfileSynchronizers;
	private checkEnablement;
}
declare class ProfileSynchronizer extends Disposable {
	readonly profile: IUserDataProfile;
	readonly collection: string | undefined;
	private readonly userDataSyncEnablementService;
	private readonly instantiationService;
	private readonly extensionGalleryService;
	private readonly userDataSyncStoreManagementService;
	private readonly telemetryService;
	private readonly logService;
	private readonly userDataProfilesService;
	private readonly configurationService;
	private _enabled;
	get enabled(): IUserDataSynchroniser[];
	get disabled(): SyncResource[];
	private _status;
	get status(): SyncStatus;
	private _onDidChangeStatus;
	readonly onDidChangeStatus: Event<SyncStatus>;
	private _onDidChangeLocal;
	readonly onDidChangeLocal: Event<SyncResource>;
	private _conflicts;
	get conflicts(): IUserDataSyncResourceConflicts[];
	private _onDidChangeConflicts;
	readonly onDidChangeConflicts: Event<IUserDataSyncResourceConflicts[]>;
	constructor(
		profile: IUserDataProfile,
		collection: string | undefined,
		userDataSyncEnablementService: IUserDataSyncEnablementService,
		instantiationService: IInstantiationService,
		extensionGalleryService: IExtensionGalleryService,
		userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
		telemetryService: ITelemetryService,
		logService: IUserDataSyncLogService,
		userDataProfilesService: IUserDataProfilesService,
		configurationService: IConfigurationService,
	);
	private onDidChangeResourceEnablement;
	protected registerSynchronizer(syncResource: SyncResource): void;
	private deRegisterSynchronizer;
	createSynchronizer(syncResource: SyncResource): IUserDataSynchroniser & IDisposable;
	sync(
		manifest: IUserDataManifest | null,
		merge: boolean,
		executionId: string,
		token: CancellationToken,
	): Promise<[SyncResource, UserDataSyncError][]>;
	apply(executionId: string, token: CancellationToken): Promise<void>;
	stop(): Promise<void>;
	resetLocal(): Promise<void>;
	private getUserDataSyncConfiguration;
	private setStatus;
	private updateStatus;
	private updateConflicts;
	private getOrder;
}
export {};