/* eslint-disable */
/**
 * Generated `api` utility.
 *
 * THIS CODE IS AUTOMATICALLY GENERATED.
 *
 * To regenerate, run `npx convex dev`.
 * @module
 */

import type * as lib from "../lib.js";

import type {
  ApiFromModules,
  FilterApi,
  FunctionReference,
} from "convex/server";

/**
 * A utility for referencing Convex functions in your app's API.
 *
 * Usage:
 * ```js
 * const myFunctionReference = api.myModule.myFunction;
 * ```
 */
declare const fullApi: ApiFromModules<{
  lib: typeof lib;
}>;
export type Mounts = {
  lib: {
    acquireLock: FunctionReference<"mutation", "public", { key: string }, any>;
    deleteAll: FunctionReference<"action", "public", {}, any>;
    deleteById: FunctionReference<
      "mutation",
      "public",
      { executionId: string },
      any
    >;
    getManyById: FunctionReference<
      "query",
      "public",
      {
        requests: Array<{
          executionId: string;
          filters?: {
            isFinished?: boolean;
            isSleepingTask?: boolean;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
          };
        }>;
      },
      any
    >;
    getManyByParentExecutionId: FunctionReference<
      "query",
      "public",
      { requests: Array<{ parentExecutionId: string }> },
      any
    >;
    getManyBySleepingTaskUniqueId: FunctionReference<
      "query",
      "public",
      { requests: Array<{ sleepingTaskUniqueId: string }> },
      any
    >;
    insertMany: FunctionReference<
      "mutation",
      "public",
      {
        executions: Array<{
          acc: number;
          areChildrenSequential: boolean;
          children?: Array<{ executionId: string; taskId: string }>;
          closeExpiresAt?: number;
          closeStatus: "idle" | "ready" | "closing" | "closed";
          closedAt?: number;
          createdAt: number;
          error?: {
            errorType: "generic" | "not_found" | "timed_out" | "cancelled";
            isInternal: boolean;
            isRetryable: boolean;
            message: string;
          };
          executionId: string;
          executorId?: string;
          expiresAt?: number;
          finalize?: { executionId: string; taskId: string };
          finishedAt?: number;
          indexInParentChildren?: number;
          input: string;
          isFinalizeOfParent?: boolean;
          isFinished: boolean;
          isOnlyChildOfParent?: boolean;
          isSleepingTask: boolean;
          npc: boolean;
          ocfpExpiresAt?: number;
          ocfpFinishedAt?: number;
          ocfpStatus: "idle" | "processing" | "processed";
          output?: string;
          parentExecutionDocId?: string;
          parentExecutionId?: string;
          parentTaskId?: string;
          retryAttempts: number;
          retryOptions: {
            baseDelayMs?: number;
            delayMultiplier?: number;
            maxAttempts: number;
            maxDelayMs?: number;
          };
          rootExecutionId?: string;
          rootTaskId?: string;
          runOutput?: string;
          shard: number;
          sleepMsBeforeRun: number;
          sleepingTaskUniqueId?: string;
          startAt: number;
          startedAt?: number;
          status:
            | "ready"
            | "running"
            | "failed"
            | "timed_out"
            | "waiting_for_children"
            | "waiting_for_finalize"
            | "finalize_failed"
            | "completed"
            | "cancelled";
          taskId: string;
          timeoutMs: number;
          updatedAt: number;
          waitingForChildrenStartedAt?: number;
          waitingForFinalizeStartedAt?: number;
        }>;
      },
      any
    >;
    releaseLock: FunctionReference<"mutation", "public", { id: string }, any>;
    updateAndDecrementParentACCByIsFinishedAndCloseStatus: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateByCloseExpiresAt: FunctionReference<"mutation", "public", any, any>;
    updateByCloseStatusAndReturn: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateByExecutorIdAndNPCAndReturn: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateByOCFPExpiresAt: FunctionReference<"mutation", "public", any, any>;
    updateByStatusAndIsSleepingTaskAndExpiresAtLessThan: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateByStatusAndOCFPStatusAndACCZeroAndReturn: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateByStatusAndStartAtLessThanAndReturn: FunctionReference<
      "mutation",
      "public",
      any,
      any
    >;
    updateManyById: FunctionReference<
      "mutation",
      "public",
      {
        requests: Array<{
          executionId: string;
          filters?: {
            isFinished?: boolean;
            isSleepingTask?: boolean;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
          };
          update: {
            acc?: number;
            children?: Array<{ executionId: string; taskId: string }>;
            closeExpiresAt?: number;
            closeStatus?: "idle" | "ready" | "closing" | "closed";
            closedAt?: number;
            error?: {
              errorType: "generic" | "not_found" | "timed_out" | "cancelled";
              isInternal: boolean;
              isRetryable: boolean;
              message: string;
            };
            executorId?: string;
            expiresAt?: number;
            finalize?: { executionId: string; taskId: string };
            finishedAt?: number;
            isFinished?: boolean;
            npc?: boolean;
            ocfpExpiresAt?: number;
            ocfpFinishedAt?: number;
            ocfpStatus?: "idle" | "processing" | "processed";
            output?: string;
            retryAttempts?: number;
            runOutput?: string;
            startAt?: number;
            startedAt?: number;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
            unset?: {
              closeExpiresAt?: boolean;
              error?: boolean;
              executorId?: boolean;
              expiresAt?: boolean;
              ocfpExpiresAt?: boolean;
              runOutput?: boolean;
              startedAt?: boolean;
            };
            updatedAt: number;
            waitingForChildrenStartedAt?: number;
            waitingForFinalizeStartedAt?: number;
          };
        }>;
      },
      any
    >;
    updateManyByIdAndInsertChildrenIfUpdated: FunctionReference<
      "mutation",
      "public",
      {
        requests: Array<{
          childrenTaskExecutionsToInsertIfAnyUpdated: Array<{
            acc: number;
            areChildrenSequential: boolean;
            children?: Array<{ executionId: string; taskId: string }>;
            closeExpiresAt?: number;
            closeStatus: "idle" | "ready" | "closing" | "closed";
            closedAt?: number;
            createdAt: number;
            error?: {
              errorType: "generic" | "not_found" | "timed_out" | "cancelled";
              isInternal: boolean;
              isRetryable: boolean;
              message: string;
            };
            executionId: string;
            executorId?: string;
            expiresAt?: number;
            finalize?: { executionId: string; taskId: string };
            finishedAt?: number;
            indexInParentChildren?: number;
            input: string;
            isFinalizeOfParent?: boolean;
            isFinished: boolean;
            isOnlyChildOfParent?: boolean;
            isSleepingTask: boolean;
            npc: boolean;
            ocfpExpiresAt?: number;
            ocfpFinishedAt?: number;
            ocfpStatus: "idle" | "processing" | "processed";
            output?: string;
            parentExecutionDocId?: string;
            parentExecutionId?: string;
            parentTaskId?: string;
            retryAttempts: number;
            retryOptions: {
              baseDelayMs?: number;
              delayMultiplier?: number;
              maxAttempts: number;
              maxDelayMs?: number;
            };
            rootExecutionId?: string;
            rootTaskId?: string;
            runOutput?: string;
            shard: number;
            sleepMsBeforeRun: number;
            sleepingTaskUniqueId?: string;
            startAt: number;
            startedAt?: number;
            status:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
            taskId: string;
            timeoutMs: number;
            updatedAt: number;
            waitingForChildrenStartedAt?: number;
            waitingForFinalizeStartedAt?: number;
          }>;
          executionId: string;
          filters?: {
            isFinished?: boolean;
            isSleepingTask?: boolean;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
          };
          update: {
            acc?: number;
            children?: Array<{ executionId: string; taskId: string }>;
            closeExpiresAt?: number;
            closeStatus?: "idle" | "ready" | "closing" | "closed";
            closedAt?: number;
            error?: {
              errorType: "generic" | "not_found" | "timed_out" | "cancelled";
              isInternal: boolean;
              isRetryable: boolean;
              message: string;
            };
            executorId?: string;
            expiresAt?: number;
            finalize?: { executionId: string; taskId: string };
            finishedAt?: number;
            isFinished?: boolean;
            npc?: boolean;
            ocfpExpiresAt?: number;
            ocfpFinishedAt?: number;
            ocfpStatus?: "idle" | "processing" | "processed";
            output?: string;
            retryAttempts?: number;
            runOutput?: string;
            startAt?: number;
            startedAt?: number;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
            unset?: {
              closeExpiresAt?: boolean;
              error?: boolean;
              executorId?: boolean;
              expiresAt?: boolean;
              ocfpExpiresAt?: boolean;
              runOutput?: boolean;
              startedAt?: boolean;
            };
            updatedAt: number;
            waitingForChildrenStartedAt?: number;
            waitingForFinalizeStartedAt?: number;
          };
        }>;
      },
      any
    >;
    updateManyByParentExecutionIdAndIsFinished: FunctionReference<
      "mutation",
      "public",
      {
        requests: Array<{
          isFinished: boolean;
          parentExecutionId: string;
          update: {
            acc?: number;
            children?: Array<{ executionId: string; taskId: string }>;
            closeExpiresAt?: number;
            closeStatus?: "idle" | "ready" | "closing" | "closed";
            closedAt?: number;
            error?: {
              errorType: "generic" | "not_found" | "timed_out" | "cancelled";
              isInternal: boolean;
              isRetryable: boolean;
              message: string;
            };
            executorId?: string;
            expiresAt?: number;
            finalize?: { executionId: string; taskId: string };
            finishedAt?: number;
            isFinished?: boolean;
            npc?: boolean;
            ocfpExpiresAt?: number;
            ocfpFinishedAt?: number;
            ocfpStatus?: "idle" | "processing" | "processed";
            output?: string;
            retryAttempts?: number;
            runOutput?: string;
            startAt?: number;
            startedAt?: number;
            status?:
              | "ready"
              | "running"
              | "failed"
              | "timed_out"
              | "waiting_for_children"
              | "waiting_for_finalize"
              | "finalize_failed"
              | "completed"
              | "cancelled";
            unset?: {
              closeExpiresAt?: boolean;
              error?: boolean;
              executorId?: boolean;
              expiresAt?: boolean;
              ocfpExpiresAt?: boolean;
              runOutput?: boolean;
              startedAt?: boolean;
            };
            updatedAt: number;
            waitingForChildrenStartedAt?: number;
            waitingForFinalizeStartedAt?: number;
          };
        }>;
      },
      any
    >;
  };
};
// For now fullApiWithMounts is only fullApi which provides
// jump-to-definition in component client code.
// Use Mounts for the same type without the inference.
declare const fullApiWithMounts: typeof fullApi;

export declare const api: FilterApi<
  typeof fullApiWithMounts,
  FunctionReference<any, "public">
>;
export declare const internal: FilterApi<
  typeof fullApiWithMounts,
  FunctionReference<any, "internal">
>;

export declare const components: {};