Class Semaphore

attr<K extends NonNeverSelectKeys<SemaphoresTable>>(
    name: K,
): {
    createdAt: Date;
    expiresAt: string;
    id: number;
    key: string;
    updatedAt: string;
    value: number;
}[K]

attrs(): {
    createdAt: Date;
    expiresAt: string;
    id: number;
    key: string;
    updatedAt: string;
    value: number;
}

destroy(): Promise<void>

reload(): Promise<Semaphore>

transaction(
    cb: (tx: Transaction<Database>) => Promise<unknown>,
): Promise<unknown>

update(
    attrs: {
        createdAt?: Date;
        expiresAt?: string;
        id?: number;
        key?: string;
        updatedAt?: string;
        value?: number;
    },
): Promise<void>

all(): Promise<Semaphore[]>

count(): Promise<number>

create(
    attrs: { key: string } & {
        createdAt?: Date;
        expiresAt?: string;
        id?: number;
        updatedAt?: string;
        value?: number;
    },
    options?: { ignoreConflict: "key" | NullableInsertKeys<SemaphoresTable> },
): Promise<Semaphore>

createAll(
    attrs: (
        { key: string } & {
            createdAt?: Date;
            expiresAt?: string;
            id?: number;
            updatedAt?: string;
            value?: number;
        }
    )[],
): Promise<Semaphore[]>

createUnique(
    attrs: { key: string } & {
        createdAt?: Date;
        expiresAt?: string;
        id?: number;
        updatedAt?: string;
        value?: number;
    },
    uniqueBy: "key" | NullableInsertKeys<SemaphoresTable>,
): Promise<null | Semaphore>

destroy(cb: (db: Kysely<Database>) => CompiledQuery): Promise<number>

findAll(cb: (db: Kysely<Database>) => CompiledQuery): Promise<Semaphore[]>

findById(id: number): Promise<null | Semaphore>

findByIdOrThrow(id: number): Promise<Semaphore>

findOne(cb: (db: Kysely<Database>) => CompiledQuery): Promise<null | Semaphore>

findOneOrThrow(cb: (db: Kysely<Database>) => CompiledQuery): Promise<Semaphore>

last(): Promise<null | Semaphore>

last(limit: 1): Promise<null | Semaphore>

last(limit: number): Promise<Semaphore[]>

transaction<T>(cb: (tx: Transaction<Database>) => Promise<T>): Promise<T>

updateAll(cb: (db: Kysely<Database>) => CompiledQuery): Promise<number>