sussudio/platform/userDataSync/common/userDataSyncStoreService.d.mts

An unofficial VS Code Internal API

/*---------------------------------------------------------------------------------------------
 *  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 "../../../base/common/cancellation.mjs";
import { Event } from "../../../base/common/event.mjs";
import { Disposable } from "../../../base/common/lifecycle.mjs";
import { ConfigurationSyncStore } from "../../../base/common/product.mjs";
import { URI } from "../../../base/common/uri.mjs";
import { IHeaders, IRequestContext, IRequestOptions } from "../../../base/parts/request/common/request.mjs";
import { IConfigurationService } from "../../configuration/common/configuration.mjs";
import { IEnvironmentService } from "../../environment/common/environment.mjs";
import { IFileService } from "../../files/common/files.mjs";
import { IProductService } from "../../product/common/productService.mjs";
import { IRequestService } from "../../request/common/request.mjs";
import { IStorageService } from "../../storage/common/storage.mjs";
import { IResourceRefHandle, IUserData, IUserDataManifest, IUserDataSyncLogService, IUserDataSyncStore, IUserDataSyncStoreManagementService, IUserDataSyncStoreService, ServerResource, UserDataSyncStoreType } from "./userDataSync.mjs";
type UserDataSyncStore = IUserDataSyncStore & {
    defaultType: UserDataSyncStoreType;
};
export declare abstract class AbstractUserDataSyncStoreManagementService extends Disposable implements IUserDataSyncStoreManagementService {
    protected readonly productService: IProductService;
    protected readonly configurationService: IConfigurationService;
    protected readonly storageService: IStorageService;
    _serviceBrand: any;
    private readonly _onDidChangeUserDataSyncStore;
    readonly onDidChangeUserDataSyncStore: Event<void>;
    private _userDataSyncStore;
    get userDataSyncStore(): UserDataSyncStore | undefined;
    protected get userDataSyncStoreType(): UserDataSyncStoreType | undefined;
    protected set userDataSyncStoreType(type: UserDataSyncStoreType | undefined);
    constructor(productService: IProductService, configurationService: IConfigurationService, storageService: IStorageService);
    protected updateUserDataSyncStore(): void;
    protected toUserDataSyncStore(productStore: ConfigurationSyncStore & {
        web?: ConfigurationSyncStore;
    } | undefined, configuredStore?: ConfigurationSyncStore): UserDataSyncStore | undefined;
    abstract switch(type: UserDataSyncStoreType): Promise<void>;
    abstract getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore | undefined>;
}
export declare class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
    private readonly previousConfigurationSyncStore;
    constructor(productService: IProductService, configurationService: IConfigurationService, storageService: IStorageService);
    switch(type: UserDataSyncStoreType): Promise<void>;
    getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore | undefined>;
}
export declare class UserDataSyncStoreClient extends Disposable {
    private readonly requestService;
    private readonly logService;
    private readonly storageService;
    private userDataSyncStoreUrl;
    private authToken;
    private readonly commonHeadersPromise;
    private readonly session;
    private _onTokenFailed;
    readonly onTokenFailed: Event<void>;
    private _onTokenSucceed;
    readonly onTokenSucceed: Event<void>;
    private _donotMakeRequestsUntil;
    get donotMakeRequestsUntil(): Date | undefined;
    private _onDidChangeDonotMakeRequestsUntil;
    readonly onDidChangeDonotMakeRequestsUntil: Event<void>;
    constructor(userDataSyncStoreUrl: URI | undefined, productService: IProductService, requestService: IRequestService, logService: IUserDataSyncLogService, environmentService: IEnvironmentService, fileService: IFileService, storageService: IStorageService);
    setAuthToken(token: string, type: string): void;
    protected updateUserDataSyncStoreUrl(userDataSyncStoreUrl: URI | undefined): void;
    private initDonotMakeRequestsUntil;
    private resetDonotMakeRequestsUntilPromise;
    private setDonotMakeRequestsUntil;
    getAllCollections(headers?: IHeaders): Promise<string[]>;
    createCollection(headers?: IHeaders): Promise<string>;
    deleteCollection(collection?: string, headers?: IHeaders): Promise<void>;
    getAllResourceRefs(resource: ServerResource, collection?: string): Promise<IResourceRefHandle[]>;
    resolveResourceContent(resource: ServerResource, ref: string, collection?: string, headers?: IHeaders): Promise<string | null>;
    deleteResource(resource: ServerResource, ref: string | null, collection?: string): Promise<void>;
    deleteResources(): Promise<void>;
    readResource(resource: ServerResource, oldValue: IUserData | null, collection?: string, headers?: IHeaders): Promise<IUserData>;
    writeResource(resource: ServerResource, data: string, ref: string | null, collection?: string, headers?: IHeaders): Promise<string>;
    manifest(oldValue: IUserDataManifest | null, headers?: IHeaders): Promise<IUserDataManifest | null>;
    clear(): Promise<void>;
    private getResourceUrl;
    private clearSession;
    private request;
    private addSessionHeaders;
}
export declare class UserDataSyncStoreService extends UserDataSyncStoreClient implements IUserDataSyncStoreService {
    _serviceBrand: any;
    constructor(userDataSyncStoreManagementService: IUserDataSyncStoreManagementService, productService: IProductService, requestService: IRequestService, logService: IUserDataSyncLogService, environmentService: IEnvironmentService, fileService: IFileService, storageService: IStorageService);
}
export declare class RequestsSession {
    private readonly limit;
    private readonly interval;
    private readonly requestService;
    private readonly logService;
    private requests;
    private startTime;
    constructor(limit: number, interval: number, /* in ms */ requestService: IRequestService, logService: IUserDataSyncLogService);
    request(url: string, options: IRequestOptions, token: CancellationToken): Promise<IRequestContext>;
    private isExpired;
    private reset;
}
export {};