hevy-shared 1.0.960 → 1.0.962

package/built/API/APIClient.js

@@ -1,381 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HevyAPIClient = void 0;
-const __1 = require("..");
-const types_1 = require("./types");
-class HevyAPIClient {
-    constructor(httpClient, config) {
-        this._requestCompletionCallbacks = [];
-        this._errorHandlers = [];
-        this._authTokenFactory = {
-            type: 'value',
-            value: null,
-        };
-        this._legacyAuthToken = null;
-        this._addHeaders = (headers, config) => (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config === null || config === void 0 ? void 0 : config.headers), headers) }));
-        this._httpClient = httpClient;
-        this._config = Object.assign({ tokenExpirySafetyThresholdMs: HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS, accessTokenMinimumValidAgeMs: HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS, tokenRefreshThrottleMs: HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS, refreshAuthTokenApiEndpoint: HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT, isAccessTokenExpiredResponse: (response) => response.status === 401 &&
-                (0, types_1.isHTTPErrorResponse)(response) &&
-                response.data.error === 'AccessTokenExpired', isAccessTokenInvalidResponse: (response) => response.status === 401 &&
-                (0, types_1.isHTTPErrorResponse)(response) &&
-                response.data.error === 'InvalidAccessToken', getUserContext: () => undefined }, config);
-        const classProperties = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter((m) => m in this && typeof m === 'string' && m !== 'constructor');
-        classProperties.forEach((m) => {
-            if (typeof this[m] === 'function')
-                this[m] = this[m].bind(this);
-        });
-    }
-    get _authToken() {
-        switch (this._authTokenFactory.type) {
-            case 'value':
-                return this._authTokenFactory.value;
-            case 'getter':
-                return this._authTokenFactory.get();
-        }
-    }
-    get _authHeaders() {
-        return Object.assign(Object.assign(Object.assign({}, (this._authToken
-            ? { authorization: `Bearer ${this._authToken.access_token}` }
-            : {})), (this._legacyAuthToken ? { 'auth-token': this._legacyAuthToken } : {})), { 'x-client-time': String(new Date().valueOf() / 1000) });
-    }
-    refreshExpiredAuthToken(userContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { _authToken } = this;
-            if (!_authToken)
-                return;
-            if (new Date().valueOf() <=
-                new Date(_authToken.expires_at).valueOf() -
-                    this._config.tokenExpirySafetyThresholdMs) {
-                // Token is still valid, at least according to the client. Don't refresh.
-                return;
-            }
-            yield this._refreshAuthToken(_authToken, userContext);
-        });
-    }
-    forceRefreshAuthToken(userContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { _authToken } = this;
-            if (!_authToken)
-                return;
-            yield this._refreshAuthToken(_authToken, userContext);
-        });
-    }
-    waitForTokenRefresh() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // This may look like it does nothing, but that is absolutely not the case.
-            // Do not remove this function!
-        });
-    }
-    get _isTokenRecentlyRefreshed() {
-        const { _lastTokenRefresh } = this;
-        return (_lastTokenRefresh !== undefined &&
-            _lastTokenRefresh.valueOf() >
-                new Date().valueOf() - this._config.tokenRefreshThrottleMs);
-    }
-    _refreshAuthToken(authToken, userContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._isTokenRecentlyRefreshed) {
-                // We have called this function recently. Do not ever spam this endpoint.
-                // Also, if any request needs to be retried due to issues with the client
-                // clock being out of sync with the backend, do that with the last token
-                // that was obtained after a 401 with the `AccessTokenExpired` response.
-                return;
-            }
-            this._lastTokenRefresh = new Date();
-            const { access_token, refresh_token } = authToken;
-            const { method, url } = this.refreshAuthTokenApiEndpoint;
-            const headers = {
-                authorization: `Bearer ${access_token}`,
-                'x-client-time': String(new Date().valueOf() / 1000),
-            };
-            // This will throw and bail out if the request fails.
-            const response = yield this._handleResponse({
-                method,
-                url,
-                headers,
-                try: () => this._httpClient[method](url, { refresh_token }, { headers }),
-            }, userContext, false);
-            const newToken = {
-                access_token: response.data.access_token,
-                refresh_token: response.data.refresh_token,
-                expires_at: new Date(response.data.expires_at),
-            };
-            /**
-             * Do not attempt to auto-refresh the token before this time - by default,
-             * {@link HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS 15 mins}
-             * after the current time. Normally the backend will generate a token that
-             * lives for at least 15 minutes, but since it sends the expiry timestamp
-             * rather than a max age in relative time units, even if the client's clock
-             * is severely out of sync, we don't want to think that the token has
-             * expired when in reality it hasn't.
-             *
-             * If we ever change the access tokens to really live for less than 15 min,
-             * this assertion will no longer hold, and any tokens that are expired
-             * despite the client not realising it will be handled by the logic that
-             * handles 401s with the `AccessTokenExpired` error response.
-             */
-            const earliestAutoRefreshUnixMs = new Date().valueOf() + this._config.accessTokenMinimumValidAgeMs;
-            if (newToken.expires_at.valueOf() < earliestAutoRefreshUnixMs) {
-                newToken.expires_at = new Date(earliestAutoRefreshUnixMs);
-            }
-            if (this._authTokenFactory.type === 'value') {
-                this._authTokenFactory.value = newToken;
-            }
-            this._config.onNewAuthToken(newToken, userContext);
-        });
-    }
-    _handleResponse(request_1, userContext_1) {
-        return __awaiter(this, arguments, void 0, function* (request, userContext, retryOnFailure = !this._isTokenRecentlyRefreshed) {
-            const requestTime = new Date();
-            try {
-                const response = yield request.try();
-                if (response.status >= 400) {
-                    throw Object.assign(new Error(`Request failed with status code ${response.status}`), {
-                        response,
-                    });
-                }
-                this._requestCompletionCallbacks.forEach((cb) => cb({ isSuccess: true, value: response }, request));
-                return response;
-            }
-            catch (e) {
-                this._requestCompletionCallbacks.forEach((cb) => cb({ isSuccess: false, error: e }, request));
-                if (!(0, types_1.isHTTPError)(e))
-                    throw e;
-                const { response } = e;
-                /**
-                 * We've had a {@link _refreshAuthToken} called _after_ this request was
-                 * made. If that request reached the server before this one did, this one
-                 * will have failed with a 401 because it's using the old token.
-                 *
-                 * In this (relatively unlikely) scenario, we will want to retry the
-                 * request, and also we will not want to log the user out.
-                 */
-                const isTokenRefreshedAfterRequest = this._lastTokenRefresh !== undefined &&
-                    requestTime < this._lastTokenRefresh;
-                /**
-                 * Similar to the above, but this will be `true` if the user has logged
-                 * out after the request was made, i.e. the session that the request was
-                 * made within is is (probably) no longer valid. In this case, we don't
-                 * want to retry the request, but we also don't want to log the user out,
-                 * in case that they've logged in to another session in the meantime.
-                 */
-                const isPreviousSession = this._lastSessionDelete !== undefined &&
-                    requestTime < this._lastSessionDelete;
-                this._errorHandlers.forEach((cb) => cb(response, request, {
-                    willRetry: retryOnFailure,
-                    isTokenRefreshedAfterRequest,
-                    isPreviousSession,
-                }));
-                if (retryOnFailure && this.isAccessTokenExpiredResponse(response)) {
-                    yield this.forceRefreshAuthToken(userContext);
-                    return yield this._handleResponse(request, userContext, false);
-                }
-                else if (retryOnFailure &&
-                    this.isAccessTokenInvalidResponse(response) &&
-                    isTokenRefreshedAfterRequest &&
-                    !isPreviousSession) {
-                    yield this.waitForTokenRefresh();
-                    return yield this._handleResponse(request, userContext, false);
-                }
-                else {
-                    throw e;
-                }
-            }
-        });
-    }
-    isAccessTokenExpiredResponse(response) {
-        return this._config.isAccessTokenExpiredResponse(response);
-    }
-    isAccessTokenInvalidResponse(response) {
-        return this._config.isAccessTokenInvalidResponse(response);
-    }
-    get refreshAuthTokenApiEndpoint() {
-        return Object.assign({}, this._config.refreshAuthTokenApiEndpoint);
-    }
-    setAuthToken(newAuthToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForTokenRefresh();
-            const { authToken, getAuthToken, legacyAuthToken } = newAuthToken;
-            if (getAuthToken !== undefined && authToken === undefined) {
-                this._authTokenFactory = { type: 'getter', get: getAuthToken };
-            }
-            else if (authToken !== undefined && getAuthToken === undefined) {
-                this._authTokenFactory = { type: 'value', value: authToken };
-            }
-            else {
-                throw new Error("Invalid arguments: exactly one of `authToken' or `getAuthToken' is required");
-            }
-            this._legacyAuthToken = legacyAuthToken;
-            this._lastTokenRefresh = undefined;
-        });
-    }
-    clearAuthToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForTokenRefresh();
-            this._authTokenFactory = { type: 'value', value: null };
-            this._legacyAuthToken = null;
-            this._lastTokenRefresh = undefined;
-        });
-    }
-    get isAuthenticated() {
-        if (this._authTokenFactory.type === 'value' &&
-            this._authTokenFactory.value === null) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    }
-    markSessionDeleted() {
-        this._lastSessionDelete = new Date();
-    }
-    /**
-     * Adds a callback to be executed whenever a request has finished processing.
-     * This means either that the request has received a response, or that there
-     * was an error. In the case of an error, it may be either an HTTP error from
-     * the server, or some other type of error, such as a network error.
-     *
-     * This is a lower level API than {@link attachErrorHandler} - prefer using
-     * that one instead of this one if it's enough to suit your needs.
-     */
-    attachRequestCompletionCallback(onResult) {
-        this._requestCompletionCallbacks.push(onResult);
-    }
-    removeRequestCompletionCallbacks() {
-        this._requestCompletionCallbacks.length = 0;
-    }
-    /**
-     * Adds a callback to be executed on receiving an HTTP error from the server.
-     * This callback will not be executed for any other type of error, such as a
-     * network error. For that and more, use {@link attachRequestCompletionCallback}.
-     */
-    attachErrorHandler(onError) {
-        this._errorHandlers.push(onError);
-    }
-    removeErrorHandlers() {
-        this._errorHandlers.length = 0;
-    }
-    get(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'get';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    delete(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'delete';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    head(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'head';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    options(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'options';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    post(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'post';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    put(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'put';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-    patch(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userContext = this._config.getUserContext();
-            yield this.refreshExpiredAuthToken(userContext);
-            const method = 'patch';
-            return this._handleResponse({
-                method,
-                url,
-                headers: this._authHeaders,
-                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
-            }, userContext);
-        });
-    }
-}
-exports.HevyAPIClient = HevyAPIClient;
-HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS = 60000;
-HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS = 900000;
-HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS = 20000;
-HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT = {
-    method: 'post',
-    url: 'auth/refresh_token',
-};
-__decorate([
-    (0, __1.synchronized)(true, 'refreshAuthToken')
-], HevyAPIClient.prototype, "refreshExpiredAuthToken", null);
-__decorate([
-    (0, __1.synchronized)(true, 'refreshAuthToken')
-], HevyAPIClient.prototype, "forceRefreshAuthToken", null);
-__decorate([
-    (0, __1.synchronized)(true, 'refreshAuthToken')
-], HevyAPIClient.prototype, "waitForTokenRefresh", null);

package/built/API/index.d.ts

@@ -1,2 +0,0 @@
-export * from './APIClient';
-export * from './types';

package/built/API/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./APIClient"), exports);
-__exportStar(require("./types"), exports);

package/built/API/types.d.ts

@@ -1,38 +0,0 @@
-import { Result } from '..';
-export interface HTTPClient {
-    get<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    delete<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    head<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    options<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    post<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    put<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
-    patch<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
-}
-export interface RequestConfig {
-    headers?: Record<string, string>;
-    baseURL?: string;
-    params?: unknown;
-    signal?: AbortSignal;
-}
-export type HTTPMethod = keyof {
-    [K in keyof HTTPClient as HTTPClient[K] extends (...args: any) => Promise<HTTPResponse<never>> ? K : never]: never;
-};
-export interface HTTPRequestFactory<T = unknown> {
-    method: HTTPMethod;
-    url: string;
-    headers: Record<string, string>;
-    try(): Promise<HTTPResponse<T>>;
-}
-export type HTTPRequestCompletionCallback<T = unknown, R = unknown> = (result: Result<HTTPResponse<T>>, request: HTTPRequestFactory<R>) => void;
-export type HTTPErrorHandler<E, T = unknown, R = unknown> = (response: HTTPResponse<T>, request: HTTPRequestFactory<R>, extraData: E) => void;
-export interface HTTPResponse<T = unknown> {
-    status: number;
-    data: T;
-}
-export interface HTTPError<T = unknown> extends Error {
-    response: HTTPResponse<T>;
-}
-export declare const isHTTPError: <T = unknown>(e: unknown) => e is HTTPError<T>;
-export declare const isHTTPErrorResponse: (response: HTTPResponse<unknown>) => response is HTTPResponse<{
-    error: string;
-}>;

package/built/API/types.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHTTPErrorResponse = exports.isHTTPError = void 0;
-const isHTTPError = (e) => {
-    return (e instanceof Error &&
-        'response' in e &&
-        typeof e.response === 'object' &&
-        e.response !== null &&
-        'status' in e.response &&
-        typeof e.response.status === 'number');
-};
-exports.isHTTPError = isHTTPError;
-const isHTTPErrorResponse = (response) => response.status >= 400 &&
-    typeof response.data === 'object' &&
-    response.data !== null &&
-    'error' in response.data &&
-    typeof response.data.error === 'string';
-exports.isHTTPErrorResponse = isHTTPErrorResponse;

package/built/adjustEventTokens.d.ts

@@ -1,16 +0,0 @@
-/**
- * Manage adjust events at https://suite.adjust.com/apps/na3q7q6avq4g/events
- */
-export declare const ADJUST_EVENT_TOKENS: {
-    logWorkout: string;
-    purchase: string;
-    signupComplete: string;
-    renewal: string;
-    updateSexMale: string;
-    updateSexFemale: string;
-    updateSexOther: string;
-    updateAge18Through28: string;
-    updateAge29Through44: string;
-    updateAge45AndUp: string;
-};
-export type AdjustEventToken = typeof ADJUST_EVENT_TOKENS[keyof typeof ADJUST_EVENT_TOKENS];

package/built/adjustEventTokens.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADJUST_EVENT_TOKENS = void 0;
-/**
- * Manage adjust events at https://suite.adjust.com/apps/na3q7q6avq4g/events
- */
-exports.ADJUST_EVENT_TOKENS = {
-    logWorkout: 'e3xe9l',
-    purchase: 'qf1l8r',
-    signupComplete: 'n46d1z',
-    renewal: 'i5pcdz',
-    updateSexMale: 'kbdp5b',
-    updateSexFemale: 'jkkjka',
-    updateSexOther: 'z4awr3',
-    updateAge18Through28: 'o5f1gc',
-    updateAge29Through44: 'vvhb17',
-    updateAge45AndUp: '3meyo6',
-};

package/built/adminPermissions.d.ts

@@ -1,4 +0,0 @@
-import { Lookup } from './typeUtils';
-export declare const AdminPermissions: readonly ["become_user", "blacklists", "featured_users", "feature_flags", "hevy_trainer", "user_account_management", "import_strong_csv", "community_management", "user_app_logs", "backend_maintenance"];
-export type AdminPermission = Lookup<typeof AdminPermissions>;
-export declare const isAdminPermission: (permission?: any) => permission is AdminPermission;

package/built/adminPermissions.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAdminPermission = exports.AdminPermissions = void 0;
-exports.AdminPermissions = [
-    'become_user',
-    'blacklists',
-    'featured_users',
-    'feature_flags',
-    'hevy_trainer',
-    'user_account_management',
-    'import_strong_csv',
-    'community_management',
-    'user_app_logs',
-    'backend_maintenance',
-];
-const isAdminPermission = (permission) => {
-    if (!permission || typeof permission !== 'string') {
-        return false;
-    }
-    return exports.AdminPermissions.includes(permission);
-};
-exports.isAdminPermission = isAdminPermission;

package/built/async.d.ts

@@ -1,50 +0,0 @@
-export type Result<T, E = unknown> = {
-    isSuccess: true;
-    value: T;
-} | {
-    isSuccess: false;
-    error: E;
-};
-/**
- * The difference between this and `Promise.all` is that `Promise.all` rejects
- * when any promise rejects, and this resolves when all promises resolve _or_
- * reject.
- *
- * This function returns an array of results, each of which is either a success
- * result containing the resolved promise, or an error result containing the
- * value that was passed to `reject()`.
- *
- * This function itself never throws or rejects.
- */
-export declare const allToResolveOrReject: <T>(promises: Promise<T>[]) => Promise<Result<T>[]>;
-/**
- * Attach a dummy rejection handler to a promise and return the original
- * promise. Used to prevent unhandled rejections in the background.
- *
- * To use this, wrap any `async` or `Promise`-returning function with this
- * function and use it as you otherwise would.
- *
- * Calling this multiple times for the same promise should have no ill effect.
- *
- * @example
- * // Before
- * await fetch('https://hevy.com/blabla');
- *
- * // After
- * await handleRejection(fetch('https://hevy.com/blabla'));
- */
-export declare const handleRejection: <T>(p: Promise<T>) => Promise<T>;
-type Stage3MethodDecorator<T> = (value: (...args: any[]) => T, context: ClassMemberDecoratorContext) => (...args: any[]) => T;
-export declare function _synchronized_3(queue: boolean): Stage3MethodDecorator<Promise<any>>;
-export declare function _synchronized_3(queue: boolean, id: any): Stage3MethodDecorator<Promise<any>>;
-export declare function _synchronized_3(value: (...args: any[]) => any, context: ClassMemberDecoratorContext): void;
-type LegacyMethodDecorator<T> = (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => T>) => void;
-export declare function synchronized(queue: boolean): LegacyMethodDecorator<Promise<any>>;
-export declare function synchronized(queue: boolean, id: any): LegacyMethodDecorator<Promise<any>>;
-export declare function synchronized(target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>): void;
-export declare abstract class LockError extends Error {
-    abstract readonly propertyKey: string | symbol;
-    abstract readonly lockId: unknown;
-    protected constructor(...args: any);
-}
-export {};