SYMBOL INDEX (112 symbols across 42 files)

FILE: src/Lock.ts
  constant REFRESH_INTERVAL_COEF (line 8) | const REFRESH_INTERVAL_COEF = 0.8
  method constructor (line 28) | constructor({
  method identifier (line 73) | get identifier(): string {
  method isAcquired (line 77) | get isAcquired(): boolean {
  method getIdentifier (line 81) | private getIdentifier(identifierSuffix: string | undefined): string {
  method _startRefresh (line 86) | private _startRefresh(): void {
  method stopRefresh (line 94) | stopRefresh(): void {
  method acquire (line 135) | async acquire(abortSignal?: AbortSignal): Promise<void> {
  method tryAcquire (line 143) | async tryAcquire(abortSignal?: AbortSignal): Promise<boolean> {
  method release (line 159) | async release(): Promise<void> {

FILE: src/RedisMultiSemaphore.ts
  class RedisMultiSemaphore (line 7) | class RedisMultiSemaphore extends RedisSemaphore {
    method constructor (line 11) | constructor(
    method _refresh (line 28) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 38) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 49) | protected async _release(): Promise<void> {

FILE: src/RedisMutex.ts
  class RedisMutex (line 9) | class RedisMutex extends Lock {
    method constructor (line 14) | constructor(client: RedisClient, key: string, options?: LockOptions) {
    method _refresh (line 29) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 38) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 42) | protected async _release(): Promise<void> {

FILE: src/RedisSemaphore.ts
  class RedisSemaphore (line 7) | class RedisSemaphore extends RedisMutex {
    method constructor (line 11) | constructor(
    method _refresh (line 28) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 37) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 47) | protected async _release(): Promise<void> {

FILE: src/RedlockMultiSemaphore.ts
  class RedlockMultiSemaphore (line 7) | class RedlockMultiSemaphore extends RedlockSemaphore {
    method constructor (line 11) | constructor(
    method _refresh (line 28) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 38) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 49) | protected async _release(): Promise<void> {

FILE: src/RedlockMutex.ts
  class RedlockMutex (line 8) | class RedlockMutex extends Lock {
    method constructor (line 13) | constructor(
    method _refresh (line 32) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 41) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 50) | protected async _release(): Promise<void> {

FILE: src/RedlockSemaphore.ts
  class RedlockSemaphore (line 7) | class RedlockSemaphore extends RedlockMutex {
    method constructor (line 11) | constructor(
    method _refresh (line 28) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 37) | protected async _acquire(abortSignal?: AbortSignal): Promise<boolean> {
    method _release (line 47) | protected async _release(): Promise<void> {

FILE: src/errors/LostLockError.ts
  class LostLockError (line 1) | class LostLockError extends Error {}

FILE: src/errors/TimeoutError.ts
  class TimeoutError (line 1) | class TimeoutError extends Error {}

FILE: src/misc.ts
  function defaultOnLockLost (line 10) | function defaultOnLockLost(err: LostLockError): never {

FILE: src/multiSemaphore/acquire/index.ts
  type Options (line 8) | interface Options {
  function acquireSemaphore (line 16) | async function acquireSemaphore(

FILE: src/multiSemaphore/refresh/index.ts
  type Options (line 7) | interface Options {
  function refreshSemaphore (line 12) | async function refreshSemaphore(

FILE: src/multiSemaphore/release/index.ts
  type Options (line 7) | interface Options {
  function releaseSemaphore (line 13) | async function releaseSemaphore(

FILE: src/mutex/acquire.ts
  type Options (line 7) | interface Options {
  function acquireMutex (line 15) | async function acquireMutex(

FILE: src/mutex/refresh.ts
  function refreshMutex (line 25) | async function refreshMutex(

FILE: src/mutex/release.ts
  function releaseMutex (line 22) | async function releaseMutex(

FILE: src/redlockMultiSemaphore/acquire.ts
  type Options (line 9) | interface Options {
  function acquireRedlockMultiSemaphore (line 17) | async function acquireRedlockMultiSemaphore(

FILE: src/redlockMultiSemaphore/refresh.ts
  type Options (line 10) | interface Options {
  function refreshRedlockMultiSemaphore (line 15) | async function refreshRedlockMultiSemaphore(

FILE: src/redlockMultiSemaphore/release.ts
  function releaseRedlockMultiSemaphore (line 7) | async function releaseRedlockMultiSemaphore(

FILE: src/redlockMutex/acquire.ts
  type Options (line 9) | interface Options {
  function acquireRedlockMutex (line 17) | async function acquireRedlockMutex(

FILE: src/redlockMutex/refresh.ts
  function refreshRedlockMutex (line 9) | async function refreshRedlockMutex(

FILE: src/redlockMutex/release.ts
  function releaseRedlockMutex (line 8) | async function releaseRedlockMutex(

FILE: src/redlockSemaphore/acquire.ts
  type Options (line 9) | interface Options {
  function acquireRedlockSemaphore (line 17) | async function acquireRedlockSemaphore(

FILE: src/redlockSemaphore/refresh.ts
  type Options (line 10) | interface Options {
  function refreshRedlockSemaphore (line 15) | async function refreshRedlockSemaphore(

FILE: src/redlockSemaphore/release.ts
  function releaseRedlockSemaphore (line 7) | async function releaseRedlockSemaphore(

FILE: src/semaphore/acquire/index.ts
  type Options (line 8) | interface Options {
  function acquireSemaphore (line 16) | async function acquireSemaphore(

FILE: src/semaphore/refresh/index.ts
  type Options (line 7) | interface Options {
  function refreshSemaphore (line 12) | async function refreshSemaphore(

FILE: src/semaphore/release.ts
  function releaseSemaphore (line 6) | async function releaseSemaphore(

FILE: src/types.ts
  type RedisClient (line 9) | type RedisClient = Pick<
  type LockLostCallback (line 15) | interface LockLostCallback {
  type TimeoutOptions (line 19) | interface TimeoutOptions {
  type LockOptions (line 27) | interface LockOptions extends TimeoutOptions {
  type AcquireOptions (line 57) | interface AcquireOptions {

FILE: src/utils/createEval.ts
  function createSHA1 (line 8) | function createSHA1(script: string): string {
  function isNoScriptError (line 12) | function isNoScriptError(err: Error): boolean {
  function createEval (line 16) | function createEval<Args extends Array<number | string>, Result>(

FILE: src/utils/index.ts
  function delay (line 6) | function delay(ms: number, signal?: AbortSignal): Promise<void> {
  function getConnectionName (line 30) | function getConnectionName(client: RedisClient): string {

FILE: src/utils/redlock.ts
  function getQuorum (line 1) | function getQuorum(clientCount: number): number {
  function smartSum (line 5) | function smartSum(count: number, zeroOrOne: number): number {

FILE: test/redisClient.ts
  function createClient (line 5) | function createClient(num: number) {
  function createClientMock (line 28) | function createClientMock(num: number) {

FILE: test/shell.ts
  constant LOGGING (line 5) | const LOGGING = !!process.env.LOGSHELL
  function sh (line 7) | function sh(cmd: string) {
  function upRedisServer (line 28) | async function upRedisServer(num: number) {
  function downRedisServer (line 35) | async function downRedisServer(num: number) {

FILE: test/src/Lock.test.ts
  class TestLock (line 7) | class TestLock extends Lock {
    method constructor (line 10) | constructor(key: string, options: LockOptions) {
    method _refresh (line 14) | protected async _refresh(): Promise<boolean> {
    method _acquire (line 18) | protected async _acquire(): Promise<boolean> {
    method _release (line 21) | protected async _release(): Promise<void> {}

FILE: test/src/RedlockMultiSemaphore.test.ts
  function expectZRangeAllEql (line 30) | async function expectZRangeAllEql(key: string, values: string[]) {
  function expectZRangeAllHaveMembers (line 39) | async function expectZRangeAllHaveMembers(key: string, values: string[]) {
  function expectZCardAllEql (line 50) | async function expectZCardAllEql(key: string, count: number) {

FILE: test/src/RedlockMutex.test.ts
  function expectGetAll (line 29) | async function expectGetAll(

FILE: test/src/RedlockSemaphore.test.ts
  function expectZRangeAllEql (line 29) | async function expectZRangeAllEql(key: string, values: string[]) {
  function expectZRangeAllHaveMembers (line 38) | async function expectZRangeAllHaveMembers(key: string, values: string[]) {
  function expectZCardAllEql (line 49) | async function expectZCardAllEql(key: string, count: number) {

FILE: test/src/multiSemaphore/acquire/internal.test.ts
  type Options (line 6) | interface Options {
  function acquire (line 18) | async function acquire(options: Options) {

FILE: test/src/semaphore/acquire/internal.test.ts
  type Options (line 6) | interface Options {
  function acquire (line 18) | async function acquire(options: Options) {

FILE: test/src/utils/redlock.test.ts
  function makeTest (line 7) | function makeTest(count: number, expectedResult: number) {

FILE: test/unhandledRejection.ts
  function throwReason (line 3) | function throwReason(reason: any) {
  function catchUnhandledRejection (line 10) | function catchUnhandledRejection() {
  function throwUnhandledRejection (line 16) | function throwUnhandledRejection() {
  function init (line 21) | function init() {
  function removeAllListeners (line 25) | function removeAllListeners() {