// API client for the platform backend.
//
// All endpoints that take a workspace context require the caller to
// pass `workspaceId` explicitly. Components read the active workspace
// from `useAuth().currentWorkspace` and thread it through; the cookie
// set by `/api/v1/auth/login` is sent automatically thanks to
// `credentials: "same-origin"`, and the backend reads it via the
// shared `request_context` dependency.
//
// 401 from any endpoint means the session has expired or was never
// established; the global `apiRequest` helper bounces the user to
// `/login` so the platform never tries to render with a stale identity.

export type ScriptType = "python" | "notebook";
export type Visibility = "private" | "workspace" | "public";

export type Employee = {
  user_id: string;
  username: string;
  display_name: string;
  email: string | null;
  status: "active" | "disabled" | "locked";
  role_code: "admin" | "developer";
  role_name: string;
  created_at: string;
};

export type ScriptItem = {
  script_id: string;
  workspace_id: string;
  current_object_id: string;
  owner_user_id: string;
  script_name: string;
  script_type: ScriptType;
  visibility: Visibility;
  status: string;
  relative_path: string;
  content_hash: string;
  size_bytes: number;
  created_at: string;
  updated_at: string;
};

export type WorkspaceDirectory = {
  path: string;
  name: string;
  parent_path: string;
};

type ApiEnvelope<T> = {
  request_id: string;
  data: T;
  meta: Record<string, unknown>;
};

type ApiErrorEnvelope = {
  detail?: string | {
    code?: string;
    message?: string;
  };
  error?: {
    code?: string;
    message?: string;
    details?: {
      editor_name?: string;
      lease_expires_at?: string;
    };
  };
};

export class ApiRequestError extends Error {
  readonly status: number;
  readonly code?: string;

  constructor(message: string, status: number, code?: string) {
    super(message);
    this.name = "ApiRequestError";
    this.status = status;
    this.code = code;
  }
}

function appendWorkspaceId(path: string, workspaceId: string): string {
  // `path` may already contain a query string. Use URLSearchParams to
  // merge cleanly either way.
  const separator = path.includes("?") ? "&" : "?";
  return `${path}${separator}workspace_id=${encodeURIComponent(workspaceId)}`;
}

async function apiRequest<T>(
  path: string,
  init: RequestInit = {},
  workspaceId?: string,
): Promise<T> {
  const finalPath = workspaceId ? appendWorkspaceId(path, workspaceId) : path;
  const response = await fetch(finalPath, {
    ...init,
    credentials: "same-origin",
    headers: {
      "X-Request-ID": crypto.randomUUID().replaceAll("-", ""),
      ...(init.body ? { "Content-Type": "application/json" } : {}),
      ...init.headers,
    },
  });

  // Session expired / never authenticated — bounce to login. The
  // /login route itself is the only path that must remain reachable
  // while anonymous, so the redirect there is safe.
  if (response.status === 401 && typeof window !== "undefined") {
    const here = window.location.pathname;
    if (here !== "/login") {
      window.location.assign("/login");
    }
    throw new ApiRequestError("未登录或登录已过期", 401);
  }

  const payload = (await response.json().catch(() => ({}))) as
    | ApiEnvelope<T>
    | ApiErrorEnvelope;
  if (!response.ok) {
    const error = payload as ApiErrorEnvelope;
    const detailMessage = typeof error.detail === "string"
      ? error.detail
      : error.detail?.message;
    const editor = error.error?.details?.editor_name;
    throw new ApiRequestError(
      (editor ? `${error.error?.message ?? "文件正在编辑"}（${editor}）` : undefined)
        ?? error.error?.message
        ?? detailMessage
        ?? `请求失败（HTTP ${response.status}）`,
      response.status,
      typeof error.detail === "object"
        ? error.detail?.code
        : error.error?.code,
    );
  }
  return (payload as ApiEnvelope<T>).data;
}

export async function listScripts(workspaceId: string): Promise<ScriptItem[]> {
  return apiRequest<ScriptItem[]>("/api/v1/scripts", {}, workspaceId);
}

function initialContent(scriptType: ScriptType): string {
  if (scriptType === "python") {
    return [
      '"""模型实验开发平台构建脚本。"""',
      "",
      "",
      "def main() -> None:",
      '    print("Hello, Model Platform!")',
      "",
      "",
      'if __name__ == "__main__":',
      "    main()",
      "",
    ].join("\n");
  }

  return JSON.stringify(
    {
      cells: [
        {
          cell_type: "markdown",
          metadata: {},
          source: ["# 新建模型实验\n", "在这里开始数据探索与模型构建。"],
        },
        {
          cell_type: "code",
          execution_count: null,
          metadata: {},
          outputs: [],
          source: ["print('Hello, Model Platform!')\n"],
        },
      ],
      metadata: {
        kernelspec: {
          display_name: "Python 3",
          language: "python",
          name: "python3",
        },
        language_info: {
          name: "python",
          version: "3.12",
        },
      },
      nbformat: 4,
      nbformat_minor: 5,
    },
    null,
    2,
  );
}

export async function createScript(
  workspaceId: string,
  input: {
    name: string;
    scriptType: ScriptType;
    visibility: Visibility;
    parentPath?: string | null;
  },
): Promise<ScriptItem> {
  return apiRequest<ScriptItem>(
    "/api/v1/scripts",
    {
      method: "POST",
      body: JSON.stringify({
        script_name: input.name.trim(),
        script_type: input.scriptType,
        visibility: input.visibility,
        content: initialContent(input.scriptType),
        parent_path: input.parentPath,
      }),
    },
    workspaceId,
  );
}

export async function uploadScript(
  workspaceId: string,
  file: File,
  parentPath = "",
  visibility: Visibility = "workspace",
): Promise<ScriptItem> {
  const parameters = new URLSearchParams({
    file_name: file.name,
    parent_path: parentPath,
    visibility,
  });
  return apiRequest<ScriptItem>(
    `/api/v1/scripts/upload?${parameters.toString()}`,
    {
      method: "POST",
      headers: { "Content-Type": "application/octet-stream" },
      body: file,
    },
    workspaceId,
  );
}

export async function updateScript(
  workspaceId: string,
  scriptId: string,
  input: { content: string },
): Promise<ScriptItem> {
  return apiRequest<ScriptItem>(
    `/api/v1/scripts/${scriptId}`,
    { method: "PUT", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function deleteScript(
  workspaceId: string,
  scriptId: string,
): Promise<{ script_id: string; status: string; versions_preserved: boolean }> {
  return apiRequest(
    `/api/v1/scripts/${scriptId}`,
    { method: "DELETE" },
    workspaceId,
  );
}

export async function listWorkspaceDirectories(
  workspaceId: string,
): Promise<WorkspaceDirectory[]> {
  const data = await apiRequest<{ directories: WorkspaceDirectory[] }>(
    "/api/v1/workspace-tree",
    {},
    workspaceId,
  );
  return data.directories;
}

export async function createWorkspaceDirectory(
  workspaceId: string,
  directoryName: string,
  parentPath = "",
): Promise<WorkspaceDirectory> {
  return apiRequest<WorkspaceDirectory>(
    "/api/v1/workspace-directories",
    {
      method: "POST",
      body: JSON.stringify({
        directory_name: directoryName,
        parent_path: parentPath,
      }),
    },
    workspaceId,
  );
}

export async function deleteWorkspaceDirectory(
  workspaceId: string,
  path: string,
): Promise<{
  path: string;
  status: string;
  deleted_scripts: number;
  versions_preserved: boolean;
}> {
  const parameters = new URLSearchParams({ path });
  return apiRequest(
    `/api/v1/workspace-directories?${parameters.toString()}`,
    { method: "DELETE" },
    workspaceId,
  );
}

export type FileLockSession = {
  edit_session_id: string;
  workspace_id: string;
  storage_object_id: string;
  user_id: string;
  session_status: "active" | "closed" | "expired";
  lease_seconds: number;
  heartbeat_interval_seconds: number;
  expires_at: string;
  runtime_id: string;
  jupyter_session_id: string;
  jupyter_url?: string;
  relative_path?: string;
  lock_token?: string;
};

export type ActiveEditSession = FileLockSession & {
  script_id: string;
  script_name: string;
  lock_token: string;
  ticket_expires_at?: string;
};

export type JupyterAccessTicket = {
  edit_session_id: string;
  jupyter_url: string;
  expires_at: string;
};

export type StableVersion = {
  versions_id: string;
  workspace_id: string;
  script_id: string;
  source_object_id: string;
  artifact_object_id: string;
  version_no: number;
  version_label: string;
  source_path: string;
  artifact_path: string;
  content_hash: string;
  file_size_bytes: number;
  visibility: Visibility;
  release_note: string | null;
  created_by: string;
  created_at: string;
};

// Note: the file-lock and jupyter-ticket endpoints are not yet
// implemented in the backend (see the cookie+JWT auth refactor plan).
// They are retained here so the editor UI keeps its existing call
// sites, but they will return 404 until the backend ships the
// corresponding routes.

export async function acquireFileLock(
  workspaceId: string,
  script: ScriptItem,
): Promise<ActiveEditSession> {
  const session = await apiRequest<FileLockSession>(
    `/api/v1/files/${script.current_object_id}/lock`,
    { method: "POST" },
    workspaceId,
  );
  if (!session.lock_token) {
    throw new Error("加锁成功响应缺少 lock_token");
  }
  return {
    ...session,
    script_id: script.script_id,
    script_name: script.script_name,
    lock_token: session.lock_token,
  };
}

export async function heartbeatFileLock(
  workspaceId: string,
  session: ActiveEditSession,
): Promise<FileLockSession> {
  return apiRequest<FileLockSession>(
    `/api/v1/file-locks/${session.edit_session_id}/heartbeat`,
    {
      method: "POST",
      body: JSON.stringify({ lock_token: session.lock_token }),
    },
    workspaceId,
  );
}

export async function releaseFileLock(
  workspaceId: string,
  session: ActiveEditSession,
): Promise<FileLockSession> {
  return apiRequest<FileLockSession>(
    `/api/v1/file-locks/${session.edit_session_id}`,
    {
      method: "DELETE",
      body: JSON.stringify({ lock_token: session.lock_token }),
    },
    workspaceId,
  );
}

export function releaseFileLockOnUnload(
  workspaceId: string,
  session: ActiveEditSession,
): void {
  void fetch(
    `/api/v1/file-locks/${session.edit_session_id}?workspace_id=${
      encodeURIComponent(workspaceId)
    }`,
    {
      method: "DELETE",
      credentials: "same-origin",
      keepalive: true,
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ lock_token: session.lock_token }),
    },
  );
}

export async function createJupyterAccessTicket(
  workspaceId: string,
  session: ActiveEditSession,
): Promise<JupyterAccessTicket> {
  return apiRequest<JupyterAccessTicket>(
    "/api/v1/jupyter/access-tickets",
    {
      method: "POST",
      body: JSON.stringify({
        edit_session_id: session.edit_session_id,
        lock_token: session.lock_token,
      }),
    },
    workspaceId,
  );
}

export async function listScriptVersions(
  workspaceId: string,
  scriptId: string,
): Promise<StableVersion[]> {
  return apiRequest<StableVersion[]>(
    `/api/v1/scripts/${scriptId}/versions`,
    {},
    workspaceId,
  );
}

export async function publishScriptVersion(
  workspaceId: string,
  input: {
    script: ScriptItem;
    releaseNote: string;
    visibility: Visibility;
  },
): Promise<StableVersion> {
  return apiRequest<StableVersion>(
    `/api/v1/scripts/${input.script.script_id}/versions`,
    {
      method: "POST",
      body: JSON.stringify({
        source_object_id: input.script.current_object_id,
        release_note: input.releaseNote.trim() || null,
        visibility: input.visibility,
      }),
    },
    workspaceId,
  );
}

export type ScheduleArtifact = {
  versions_id: string;
  version_label: string;
  script_id: string;
  script_name: string;
  script_type: ScriptType;
  content_hash: string;
  file_size_bytes: number;
  visibility: Visibility;
  created_by: string;
  created_at: string;
};

export type ScheduleNode = {
  node_id: string;
  schedule_id: string;
  node_key: string;
  node_name: string;
  versions_id: string;
  timeout_seconds: number;
  retry_count: number;
  retry_interval_sec: number;
  position_x: number;
  position_y: number;
  arguments_json: Record<string, unknown>;
  env_refs_json: Record<string, string>;
  created_at: string;
  updated_at: string;
  version: {
    versions_id: string;
    version_label: string;
    script_id: string;
    script_name: string;
    script_type: ScriptType;
    content_hash: string;
    created_at: string;
  };
};

export type ScheduleEdge = {
  edge_id: string;
  schedule_id: string;
  source_node_id: string;
  target_node_id: string;
  condition_expr: string | null;
  created_at: string;
};

export type DagValidation = {
  valid: boolean;
  node_count: number;
  edge_count: number;
  root_node_ids: string[];
  leaf_node_ids: string[];
  topological_order: string[];
  errors: Array<{
    code: string;
    message: string;
    edge_id?: string;
    node_ids?: string[];
  }>;
};

export type Schedule = {
  schedule_id: string;
  workspace_id: string;
  schedule_name: string;
  description: string | null;
  trigger_type: "manual" | "cron" | "api";
  cron_expression: string | null;
  timezone: string;
  enabled: boolean;
  workflow_version: number;
  max_concurrency: number;
  failure_policy: "stop" | "continue";
  last_run_at: string | null;
  next_run_at: string | null;
  created_by: string;
  updated_by: string;
  created_at: string;
  updated_at: string;
  node_count: number;
  edge_count: number;
  nodes: ScheduleNode[];
  edges: ScheduleEdge[];
  dag_validation: DagValidation;
};

export type CronPreview = {
  cron_expression: string;
  timezone: string;
  base_time: string;
  occurrences: Array<{
    local_time: string;
    utc_time: string;
  }>;
};

export type ScheduleRunStatus =
  | "queued"
  | "running"
  | "succeeded"
  | "failed"
  | "cancelled"
  | "timed_out";

export type ScheduleNodeRunStatus =
  | ScheduleRunStatus
  | "skipped";

export type ScheduleRunSummary = {
  run_id: string;
  schedule_id: string;
  workspace_id: string;
  workflow_version: number;
  trigger_type: "manual" | "cron" | "api" | "retry";
  run_status: ScheduleRunStatus;
  state_version: number;
  queued_at: string;
  started_at: string | null;
  finished_at: string | null;
  duration_ms: number | null;
  error_code: string | null;
  error_message: string | null;
  logs_object_id: string | null;
  result_object_id: string | null;
};

export type ScheduleNodeRun = {
  node_run_id: string;
  run_id: string;
  node_id: string;
  versions_id: string;
  attempt_no: number;
  node_status: ScheduleNodeRunStatus;
  state_version: number;
  started_at: string | null;
  finished_at: string | null;
  duration_ms: number | null;
  exit_code: number | null;
  message: string | null;
  logs_object_id: string | null;
  result_object_id: string | null;
};

export type ScheduleRunDetail = ScheduleRunSummary & {
  node_runs: ScheduleNodeRun[];
};

export async function listSchedules(workspaceId: string): Promise<Schedule[]> {
  return apiRequest<Schedule[]>("/api/v1/schedules", {}, workspaceId);
}

export async function getSchedule(
  workspaceId: string,
  scheduleId: string,
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}`,
    {},
    workspaceId,
  );
}

export async function createSchedule(
  workspaceId: string,
  input: {
    schedule_name: string;
    description?: string | null;
    trigger_type?: "manual" | "cron" | "api";
    cron_expression?: string | null;
    timezone?: string;
    enabled?: boolean;
    max_concurrency?: number;
    failure_policy?: "stop" | "continue";
  },
): Promise<Schedule> {
  return apiRequest<Schedule>(
    "/api/v1/schedules",
    { method: "POST", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function updateSchedule(
  workspaceId: string,
  scheduleId: string,
  input: {
    workflow_version: number;
    schedule_name?: string;
    description?: string | null;
    trigger_type?: "manual" | "cron" | "api";
    cron_expression?: string | null;
    timezone?: string;
    enabled?: boolean;
    max_concurrency?: number;
    failure_policy?: "stop" | "continue";
  },
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}`,
    { method: "PATCH", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function deleteSchedule(
  workspaceId: string,
  scheduleId: string,
  workflowVersion: number,
): Promise<{ schedule_id: string; deleted: boolean; workflow_version: number }> {
  return apiRequest(
    `/api/v1/schedules/${scheduleId}`,
    { method: "DELETE", body: JSON.stringify({ workflow_version: workflowVersion }) },
    workspaceId,
  );
}

export async function listScheduleArtifacts(
  workspaceId: string,
): Promise<ScheduleArtifact[]> {
  return apiRequest<ScheduleArtifact[]>(
    "/api/v1/schedule-artifacts",
    {},
    workspaceId,
  );
}

export async function hideScheduleArtifact(
  workspaceId: string,
  versionsId: string,
): Promise<{
  versions_id: string;
  deleted: boolean;
  artifact_preserved: boolean;
}> {
  return apiRequest(
    `/api/v1/versions/${versionsId}`,
    { method: "DELETE" },
    workspaceId,
  );
}

export async function listEmployees(workspaceId: string): Promise<Employee[]> {
  return apiRequest<Employee[]>("/api/v1/admin/employees", {}, workspaceId);
}

export async function createEmployee(
  workspaceId: string,
  input: {
    username: string;
    display_name: string;
    email?: string | null;
    role_code: "admin" | "developer";
  },
): Promise<Employee> {
  return apiRequest<Employee>(
    "/api/v1/admin/employees",
    { method: "POST", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function updateEmployee(
  workspaceId: string,
  userId: string,
  input: {
    display_name?: string;
    email?: string | null;
    role_code?: "admin" | "developer";
    status?: "active" | "disabled" | "locked";
  },
): Promise<Employee> {
  return apiRequest<Employee>(
    `/api/v1/admin/employees/${userId}`,
    { method: "PATCH", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function deleteEmployee(
  workspaceId: string,
  userId: string,
): Promise<{ user_id: string; deleted: boolean }> {
  return apiRequest(
    `/api/v1/admin/employees/${userId}`,
    { method: "DELETE" },
    workspaceId,
  );
}

export async function createScheduleNode(
  workspaceId: string,
  scheduleId: string,
  input: {
    workflow_version: number;
    node_key: string;
    node_name: string;
    versions_id: string;
    timeout_seconds?: number;
    retry_count?: number;
    retry_interval_sec?: number;
    position_x?: number;
    position_y?: number;
    arguments_json?: Record<string, unknown>;
    env_refs_json?: Record<string, string>;
  },
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}/nodes`,
    { method: "POST", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function updateScheduleNode(
  workspaceId: string,
  scheduleId: string,
  nodeId: string,
  input: {
    workflow_version: number;
    node_name?: string;
    versions_id?: string;
    timeout_seconds?: number;
    retry_count?: number;
    retry_interval_sec?: number;
    position_x?: number;
    position_y?: number;
    arguments_json?: Record<string, unknown>;
    env_refs_json?: Record<string, string>;
  },
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}/nodes/${nodeId}`,
    { method: "PUT", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function deleteScheduleNode(
  workspaceId: string,
  scheduleId: string,
  nodeId: string,
  workflowVersion: number,
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}/nodes/${nodeId}`,
    { method: "DELETE", body: JSON.stringify({ workflow_version: workflowVersion }) },
    workspaceId,
  );
}

export async function createScheduleEdge(
  workspaceId: string,
  scheduleId: string,
  input: {
    workflow_version: number;
    source_node_id: string;
    target_node_id: string;
    condition_expr?: string | null;
  },
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}/edges`,
    { method: "POST", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function deleteScheduleEdge(
  workspaceId: string,
  scheduleId: string,
  edgeId: string,
  workflowVersion: number,
): Promise<Schedule> {
  return apiRequest<Schedule>(
    `/api/v1/schedules/${scheduleId}/edges/${edgeId}`,
    { method: "DELETE", body: JSON.stringify({ workflow_version: workflowVersion }) },
    workspaceId,
  );
}

export async function validateSchedule(
  workspaceId: string,
  scheduleId: string,
): Promise<DagValidation & {
  schedule_id: string;
  workflow_version: number;
}> {
  return apiRequest(
    `/api/v1/schedules/${scheduleId}/validate`,
    { method: "POST" },
    workspaceId,
  );
}

export async function previewCron(
  workspaceId: string,
  input: {
    cron_expression: string;
    timezone: string;
    count?: number;
    base_time?: string;
  },
): Promise<CronPreview> {
  return apiRequest<CronPreview>(
    "/api/v1/cron/preview",
    { method: "POST", body: JSON.stringify(input) },
    workspaceId,
  );
}

export async function runScheduleNow(
  workspaceId: string,
  scheduleId: string,
): Promise<ScheduleRunDetail> {
  return apiRequest<ScheduleRunDetail>(
    `/api/v1/schedules/${scheduleId}/run`,
    {
      method: "POST",
      headers: {
        "Idempotency-Key": crypto.randomUUID(),
      },
      body: JSON.stringify({ reason: "manual_run" }),
    },
    workspaceId,
  );
}

export async function listScheduleRuns(
  workspaceId: string,
  input: {
    scheduleId?: string;
    status?: ScheduleRunStatus;
    limit?: number;
  } = {},
): Promise<ScheduleRunSummary[]> {
  const query = new URLSearchParams();
  if (input.scheduleId) query.set("schedule_id", input.scheduleId);
  if (input.status) query.set("status", input.status);
  query.set("limit", String(input.limit ?? 20));
  return apiRequest<ScheduleRunSummary[]>(
    `/api/v1/schedule-runs?${query.toString()}`,
    {},
    workspaceId,
  );
}

export async function getScheduleRun(
  workspaceId: string,
  runId: string,
): Promise<ScheduleRunDetail> {
  return apiRequest<ScheduleRunDetail>(
    `/api/v1/schedule-runs/${runId}`,
    {},
    workspaceId,
  );
}

// ----------------------------------------------------------------------------
// Workspace-bound API surface.
//
// `useApi()` in ~/context/AuthContext returns an object where every
// function has had its first `workspaceId` argument pre-filled. The
// type below lets consumers import the bound type without depending
// on the raw functions. Keep this last in the file so the type
// references all the exports above.
// ----------------------------------------------------------------------------
export type WorkspaceBoundApi = {
  listScripts: () => Promise<ScriptItem[]>;
  createScript: (
    input: Parameters<typeof createScript>[1],
  ) => Promise<ScriptItem>;
  uploadScript: (
    file: File,
    parentPath?: string,
    visibility?: Visibility,
  ) => Promise<ScriptItem>;
  updateScript: (
    scriptId: string,
    input: Parameters<typeof updateScript>[1],
  ) => Promise<ScriptItem>;
  deleteScript: (
    scriptId: string,
  ) => Promise<{ script_id: string; status: string; versions_preserved: boolean }>;
  listWorkspaceDirectories: () => Promise<WorkspaceDirectory[]>;
  createWorkspaceDirectory: (
    directoryName: string,
    parentPath?: string,
  ) => Promise<WorkspaceDirectory>;
  deleteWorkspaceDirectory: (
    path: string,
  ) => Promise<{
    path: string;
    status: string;
    deleted_scripts: number;
    versions_preserved: boolean;
  }>;
  acquireFileLock: (
    script: ScriptItem,
  ) => Promise<ActiveEditSession>;
  heartbeatFileLock: (
    session: ActiveEditSession,
  ) => Promise<FileLockSession>;
  releaseFileLock: (
    session: ActiveEditSession,
  ) => Promise<FileLockSession>;
  releaseFileLockOnUnload: (session: ActiveEditSession) => void;
  createJupyterAccessTicket: (
    session: ActiveEditSession,
  ) => Promise<JupyterAccessTicket>;
  listScriptVersions: (scriptId: string) => Promise<StableVersion[]>;
  publishScriptVersion: (
    input: Parameters<typeof publishScriptVersion>[1],
  ) => Promise<StableVersion>;
  listSchedules: () => Promise<Schedule[]>;
  getSchedule: (scheduleId: string) => Promise<Schedule>;
  createSchedule: (
    input: Parameters<typeof createSchedule>[1],
  ) => Promise<Schedule>;
  updateSchedule: (
    scheduleId: string,
    input: Parameters<typeof updateSchedule>[2],
  ) => Promise<Schedule>;
  deleteSchedule: (
    scheduleId: string,
    workflowVersion: number,
  ) => Promise<{ schedule_id: string; deleted: boolean; workflow_version: number }>;
  listScheduleArtifacts: () => Promise<ScheduleArtifact[]>;
  hideScheduleArtifact: (
    versionsId: string,
  ) => Promise<{
    versions_id: string;
    deleted: boolean;
    artifact_preserved: boolean;
  }>;
  listEmployees: () => Promise<Employee[]>;
  createEmployee: (
    input: Parameters<typeof createEmployee>[1],
  ) => Promise<Employee>;
  updateEmployee: (
    userId: string,
    input: Parameters<typeof updateEmployee>[2],
  ) => Promise<Employee>;
  deleteEmployee: (
    userId: string,
  ) => Promise<{ user_id: string; deleted: boolean }>;
  createScheduleNode: (
    scheduleId: string,
    input: Parameters<typeof createScheduleNode>[2],
  ) => Promise<Schedule>;
  updateScheduleNode: (
    scheduleId: string,
    nodeId: string,
    input: Parameters<typeof updateScheduleNode>[3],
  ) => Promise<Schedule>;
  deleteScheduleNode: (
    scheduleId: string,
    nodeId: string,
    workflowVersion: number,
  ) => Promise<Schedule>;
  createScheduleEdge: (
    scheduleId: string,
    input: Parameters<typeof createScheduleEdge>[2],
  ) => Promise<Schedule>;
  deleteScheduleEdge: (
    scheduleId: string,
    edgeId: string,
    workflowVersion: number,
  ) => Promise<Schedule>;
  validateSchedule: (
    scheduleId: string,
  ) => Promise<DagValidation & { schedule_id: string; workflow_version: number }>;
  previewCron: (
    input: Parameters<typeof previewCron>[1],
  ) => Promise<CronPreview>;
  runScheduleNow: (scheduleId: string) => Promise<ScheduleRunDetail>;
  listScheduleRuns: (
    input?: Parameters<typeof listScheduleRuns>[1],
  ) => Promise<ScheduleRunSummary[]>;
  getScheduleRun: (runId: string) => Promise<ScheduleRunDetail>;
};