Class ClaimedExecution

attr<K extends NonNeverSelectKeys<ClaimedExecutionsTable>>(
    name: K,
): { createdAt: Date; id: number; jobId: number; processId: number }[K]

attrs(): { createdAt: Date; id: number; jobId: number; processId: number }

destroy(): Promise<void>

reload(): Promise<ClaimedExecution>

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

update(
    attrs: { id?: number; jobId?: number; processId?: number },
): Promise<void>

all(): Promise<ClaimedExecution[]>

attributesFromJob(
    job: Job,
): { jobId: number; priority: number; queueName: string }

count(): Promise<number>

create(
    attrs: { jobId: number; processId: number } & {
        createdAt?: string | number;
        id?: number;
    },
    options?: {
        ignoreConflict:
            | NonNullableInsertKeys<ClaimedExecutionsTable>
            | NullableInsertKeys<ClaimedExecutionsTable>;
    },
): Promise<ClaimedExecution>

createAll(
    attrs: (
        { jobId: number; processId: number } & {
            createdAt?: string | number;
            id?: number;
        }
    )[],
): Promise<ClaimedExecution[]>

createAllFromJobs(jobs: Job[]): Promise<void>

createUnique(
    attrs: { jobId: number; processId: number } & {
        createdAt?: string | number;
        id?: number;
    },
    uniqueBy:
        | NonNullableInsertKeys<ClaimedExecutionsTable>
        | NullableInsertKeys<ClaimedExecutionsTable>,
): Promise<null | ClaimedExecution>

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

discardAllFromJobs(jobs: Job[]): Promise<void>

discardAllInBatches(
    opts?: { batchSize?: number; queue?: string },
): Promise<void>

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

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

findByIdOrThrow(id: number): Promise<ClaimedExecution>

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

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

last(): Promise<null | ClaimedExecution>

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

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

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

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