# This file is automatically generated.
# DO NOT MODIFY THIS FILE MANUALLY.

from __future__ import annotations

from typing import Any, Dict, List, Optional

from pydantic import BaseModel, Field


class DeleteBodySlurmJobJobid(BaseModel):
    pass


class DeletePathSlurmJobJobid(BaseModel):
    job_id: str = Field(..., title="Job Id")


class DeleteQuerySlurmJobJobid(BaseModel):
    signal: Optional[str] = Field(None, title="Signal")


class GetBodySlurmJobJobid(BaseModel):
    pass


class GetBodySlurmJobs(BaseModel):
    pass


class GetPathSlurmJobJobid(BaseModel):
    job_id: str = Field(..., title="Job Id")


class GetPathSlurmJobs(BaseModel):
    pass


class GetQuerySlurmJobJobid(BaseModel):
    update_time: Optional[str] = Field(None, title="Update Time")


class GetQuerySlurmJobs(BaseModel):
    update_time: Optional[str] = Field(None, title="Update Time")


class JobDescMsgBeginTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgCrontabLine(BaseModel):
    start: Optional[int] = Field(None, title="Start of this entry in file")
    end: Optional[int] = Field(None, title="End of this entry in file")


class JobDescMsgDistributionPlaneSize(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgKillWarningDelay(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgMemoryPerCpu(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgMemoryPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgPriority(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRequiredSwitches(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsAs(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsCore(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsCpu(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsData(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsFsize(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsMemlock(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsNofile(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsNproc(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsRss(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgRlimitsStack(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgSegmentSize(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgTimeLimit(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class JobDescMsgTimeMinimum(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespErrorsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form error description")
    error_number: Optional[int] = Field(None, title="Slurm numeric error identifier")
    error: Optional[str] = Field(None, title="Short form error description")
    source: Optional[str] = Field(
        None, title="Source of error or where error was first detected"
    )


class OpenapiJobInfoRespJobsItemAccrueTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemArrayJobId(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemArrayMaxTasks(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemArrayTaskId(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemBillableTres(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[float] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCoresPerSocket(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCpuFrequencyGovernor(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCpuFrequencyMaximum(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCpuFrequencyMinimum(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCpus(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemCpusPerTask(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemDeadline(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemDelayBoot(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemDerivedExitCodeReturnCode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemDerivedExitCodeSignalId(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemEligibleTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemEndTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemExitCodeReturnCode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemExitCodeSignalId(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemHetJobId(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemHetJobOffset(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemCpus(BaseModel):
    count: Optional[int] = Field(None, title="Total number of CPUs assigned to job")
    used: Optional[int] = Field(None, title="Total number of CPUs used by job")


class OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemMemory(BaseModel):
    used: Optional[int] = Field(None, title="Total memory (MiB) used by job")
    allocated: Optional[int] = Field(None, title="Total memory (MiB) allocated to job")


class OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItemCoresItem(
    BaseModel
):
    index: Optional[int] = Field(None, title="Core index")
    status: Optional[List[str]] = Field(None, title="Core status")


class OpenapiJobInfoRespJobsItemJobResourcesThreadsPerCore(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemLastSchedEvaluation(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMaxCpus(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMaxNodes(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMemoryPerCpu(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMemoryPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMinimumCpusPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemMinimumTmpDiskPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemNodeCount(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemPower(BaseModel):
    flags: Optional[List[Dict[str, Any]]] = Field(None, title="Flags")


class OpenapiJobInfoRespJobsItemPreSusTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemPreemptTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemPreemptableTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemPriority(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemResizeTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemSocketsPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemStartTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemSubmitTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemSuspendTime(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasks(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasksPerBoard(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasksPerCore(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasksPerNode(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasksPerSocket(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTasksPerTres(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemThreadsPerCore(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTimeLimit(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespJobsItemTimeMinimum(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespLastBackfill(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespLastUpdate(BaseModel):
    set: Optional[bool] = Field(
        None, title="True if number has been set; False if number is unset"
    )
    infinite: Optional[bool] = Field(
        None,
        title='True if number has been set to infinite; "set" and "number" will be ignored',
    )
    number: Optional[int] = Field(
        None,
        title='If "set" is True the number will be set with value; otherwise ignore number contents',
    )


class OpenapiJobInfoRespMetaClient(BaseModel):
    source: Optional[str] = Field(None, title="Client source description")
    user: Optional[str] = Field(None, title="Client user (if known)")
    group: Optional[str] = Field(None, title="Client group (if known)")


class OpenapiJobInfoRespMetaPlugin(BaseModel):
    type: Optional[str] = Field(None, title="Slurm plugin type (if applicable)")
    name: Optional[str] = Field(None, title="Slurm plugin name (if applicable)")
    data_parser: Optional[str] = Field(None, title="Slurm data_parser plugin")
    accounting_storage: Optional[str] = Field(None, title="Slurm accounting plugin")


class OpenapiJobInfoRespMetaSlurmVersion(BaseModel):
    major: Optional[str] = Field(None, title="Slurm release major version")
    micro: Optional[str] = Field(None, title="Slurm release micro version")
    minor: Optional[str] = Field(None, title="Slurm release minor version")


class OpenapiJobInfoRespWarningsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form warning description")
    source: Optional[str] = Field(
        None, title="Source of warning or where warning was first detected"
    )


class OpenapiJobSubmitResponseErrorsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form error description")
    error_number: Optional[int] = Field(None, title="Slurm numeric error identifier")
    error: Optional[str] = Field(None, title="Short form error description")
    source: Optional[str] = Field(
        None, title="Source of error or where error was first detected"
    )


class OpenapiJobSubmitResponseMetaClient(BaseModel):
    source: Optional[str] = Field(None, title="Client source description")
    user: Optional[str] = Field(None, title="Client user (if known)")
    group: Optional[str] = Field(None, title="Client group (if known)")


class OpenapiJobSubmitResponseMetaPlugin(BaseModel):
    type: Optional[str] = Field(None, title="Slurm plugin type (if applicable)")
    name: Optional[str] = Field(None, title="Slurm plugin name (if applicable)")
    data_parser: Optional[str] = Field(None, title="Slurm data_parser plugin")
    accounting_storage: Optional[str] = Field(None, title="Slurm accounting plugin")


class OpenapiJobSubmitResponseMetaSlurmVersion(BaseModel):
    major: Optional[str] = Field(None, title="Slurm release major version")
    micro: Optional[str] = Field(None, title="Slurm release micro version")
    minor: Optional[str] = Field(None, title="Slurm release minor version")


class OpenapiJobSubmitResponseResult(BaseModel):
    job_id: Optional[int] = Field(None, title="New job ID")
    step_id: Optional[str] = Field(None, title="New job step ID")
    error_code: Optional[int] = Field(None, title="Error code")
    error: Optional[str] = Field(None, title="Error message")
    job_submit_user_msg: Optional[str] = Field(
        None, title="Message to user from job_submit plugin"
    )


class OpenapiJobSubmitResponseWarningsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form warning description")
    source: Optional[str] = Field(
        None, title="Source of warning or where warning was first detected"
    )


class OpenapiRespErrorsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form error description")
    error_number: Optional[int] = Field(None, title="Slurm numeric error identifier")
    error: Optional[str] = Field(None, title="Short form error description")
    source: Optional[str] = Field(
        None, title="Source of error or where error was first detected"
    )


class OpenapiRespMetaClient(BaseModel):
    source: Optional[str] = Field(None, title="Client source description")
    user: Optional[str] = Field(None, title="Client user (if known)")
    group: Optional[str] = Field(None, title="Client group (if known)")


class OpenapiRespMetaPlugin(BaseModel):
    type: Optional[str] = Field(None, title="Slurm plugin type (if applicable)")
    name: Optional[str] = Field(None, title="Slurm plugin name (if applicable)")
    data_parser: Optional[str] = Field(None, title="Slurm data_parser plugin")
    accounting_storage: Optional[str] = Field(None, title="Slurm accounting plugin")


class OpenapiRespMetaSlurmVersion(BaseModel):
    major: Optional[str] = Field(None, title="Slurm release major version")
    micro: Optional[str] = Field(None, title="Slurm release micro version")
    minor: Optional[str] = Field(None, title="Slurm release minor version")


class OpenapiRespWarningsItem(BaseModel):
    description: Optional[str] = Field(None, title="Long form warning description")
    source: Optional[str] = Field(
        None, title="Source of warning or where warning was first detected"
    )


class PostPathSlurmJobSubmit(BaseModel):
    pass


class PostQuerySlurmJobSubmit(BaseModel):
    pass


class JobDescMsgCrontab(BaseModel):
    flags: Optional[List[str]] = Field(None, title="Flags")
    minute: Optional[str] = Field(
        None, title="Ranged string specifying eligible minute values (e.g. 0-10,50)"
    )
    hour: Optional[str] = Field(
        None, title="Ranged string specifying eligible hour values (e.g. 0-5,23)"
    )
    day_of_month: Optional[str] = Field(
        None,
        title="Ranged string specifying eligible day of month values (e.g. 0-10,29)",
    )
    month: Optional[str] = Field(
        None, title="Ranged string specifying eligible month values (e.g. 0-5,12)"
    )
    day_of_week: Optional[str] = Field(
        None, title="Ranged string specifying eligible day of week values (e.g.0-3,7)"
    )
    specification: Optional[str] = Field(
        None,
        title="Time specification (* means valid for all allowed values) - minute hour day_of_month month day_of_week",
    )
    command: Optional[str] = Field(None, title="Command to run")
    line: Optional[JobDescMsgCrontabLine] = Field(
        None, title="Job desc msg crontab line"
    )


class JobDescMsgRlimits(BaseModel):
    cpu: Optional[JobDescMsgRlimitsCpu] = Field(
        None, title="Per-process CPU limit, in seconds."
    )
    fsize: Optional[JobDescMsgRlimitsFsize] = Field(
        None, title="Largest file that can be created, in bytes."
    )
    data: Optional[JobDescMsgRlimitsData] = Field(
        None, title="Maximum size of data segment, in bytes. "
    )
    stack: Optional[JobDescMsgRlimitsStack] = Field(
        None, title="Maximum size of stack segment, in bytes."
    )
    core: Optional[JobDescMsgRlimitsCore] = Field(
        None, title="Largest core file that can be created, in bytes."
    )
    rss: Optional[JobDescMsgRlimitsRss] = Field(
        None,
        title="Largest resident set size, in bytes. This affects swapping; processes that are exceeding their resident set size will be more likely to have physical memory taken from them.",
    )
    nproc: Optional[JobDescMsgRlimitsNproc] = Field(None, title="Number of processes.")
    nofile: Optional[JobDescMsgRlimitsNofile] = Field(
        None, title="Number of open files."
    )
    memlock: Optional[JobDescMsgRlimitsMemlock] = Field(
        None, title="Locked-in-memory address space"
    )
    as_: Optional[JobDescMsgRlimitsAs] = Field(
        None, alias="as", title="Address space limit."
    )


class OpenapiJobInfoRespJobsItemDerivedExitCodeSignal(BaseModel):
    id: Optional[OpenapiJobInfoRespJobsItemDerivedExitCodeSignalId] = Field(
        None, title="Signal sent to process (numeric)"
    )
    name: Optional[str] = Field(None, title="Signal sent to process")


class OpenapiJobInfoRespJobsItemExitCodeSignal(BaseModel):
    id: Optional[OpenapiJobInfoRespJobsItemExitCodeSignalId] = Field(
        None, title="Signal sent to process (numeric)"
    )
    name: Optional[str] = Field(None, title="Signal sent to process")


class OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItem(BaseModel):
    index: Optional[int] = Field(None, title="Core index")
    cores: Optional[
        List[
            OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItemCoresItem
        ]
    ] = Field(None, title="Core in socket")


class OpenapiJobInfoRespMetaSlurm(BaseModel):
    version: Optional[OpenapiJobInfoRespMetaSlurmVersion] = Field(
        None, title="Openapi job info resp meta slurm version"
    )
    release: Optional[str] = Field(None, title="Slurm release string")
    cluster: Optional[str] = Field(None, title="Slurm cluster name")


class OpenapiJobSubmitResponseMetaSlurm(BaseModel):
    version: Optional[OpenapiJobSubmitResponseMetaSlurmVersion] = Field(
        None, title="Openapi job submit response meta slurm version"
    )
    release: Optional[str] = Field(None, title="Slurm release string")
    cluster: Optional[str] = Field(None, title="Slurm cluster name")


class OpenapiRespMetaSlurm(BaseModel):
    version: Optional[OpenapiRespMetaSlurmVersion] = Field(
        None, title="Openapi resp meta slurm version"
    )
    release: Optional[str] = Field(None, title="Slurm release string")
    cluster: Optional[str] = Field(None, title="Slurm cluster name")


class JobDescMsg(BaseModel):
    account: Optional[str] = Field(None, title="Account associated with the job")
    account_gather_frequency: Optional[str] = Field(
        None, title="Job accounting and profiling sampling intervals in seconds"
    )
    admin_comment: Optional[str] = Field(
        None, title="Arbitrary comment made by administrator"
    )
    allocation_node_list: Optional[str] = Field(
        None, title="Local node making the resource allocation"
    )
    allocation_node_port: Optional[int] = Field(
        None, title="Port to send allocation confirmation to"
    )
    argv: Optional[List[str]] = Field(None, title="Arguments to the script")
    array: Optional[str] = Field(None, title="Job array index value specification")
    batch_features: Optional[str] = Field(
        None, title="Features required for batch script's node"
    )
    begin_time: Optional[JobDescMsgBeginTime] = Field(
        None,
        title="Defer the allocation of the job until the specified time (UNIX timestamp)",
    )
    flags: Optional[List[str]] = Field(None, title="Job flags")
    burst_buffer: Optional[str] = Field(None, title="Burst buffer specifications")
    clusters: Optional[str] = Field(
        None, title="Clusters that a federated job can run on"
    )
    cluster_constraint: Optional[str] = Field(
        None,
        title="Required features that a federated cluster must have to have a sibling job submitted to it",
    )
    comment: Optional[str] = Field(None, title="Arbitrary comment made by user")
    contiguous: Optional[bool] = Field(
        None, title="True if job requires contiguous nodes"
    )
    container: Optional[str] = Field(
        None, title="Absolute path to OCI container bundle"
    )
    container_id: Optional[str] = Field(None, title="OCI container ID")
    core_specification: Optional[int] = Field(None, title="Specialized core count")
    thread_specification: Optional[int] = Field(None, title="Specialized thread count")
    cpu_binding: Optional[str] = Field(
        None, title="Method for binding tasks to allocated CPUs"
    )
    cpu_binding_flags: Optional[List[str]] = Field(None, title="Flags for CPU binding")
    cpu_frequency: Optional[str] = Field(
        None, title="Requested CPU frequency range <p1>[-p2][:p3]"
    )
    cpus_per_tres: Optional[str] = Field(
        None,
        title="Semicolon delimited list of TRES=# values values indicating how many CPUs should be allocated for each specified TRES (currently only used for gres/gpu)",
    )
    crontab: Optional[JobDescMsgCrontab] = Field(
        None, title="Specification for scrontab job"
    )
    deadline: Optional[int] = Field(
        None, title="Latest time that the job may start (UNIX timestamp)"
    )
    delay_boot: Optional[int] = Field(
        None,
        title="Number of seconds after job eligible start that nodes will be rebooted to satisfy feature specification",
    )
    dependency: Optional[str] = Field(
        None,
        title="Other jobs that must meet certain criteria before this job can start",
    )
    end_time: Optional[int] = Field(None, title="Expected end time (UNIX timestamp)")
    environment: Optional[List[str]] = Field(
        None, title="Environment variables to be set for the job"
    )
    rlimits: Optional[JobDescMsgRlimits] = Field(None, title="Job desc msg rlimits")
    excluded_nodes: Optional[List[str]] = Field(
        None, title="Comma separated list of nodes that may not be used"
    )
    extra: Optional[str] = Field(
        None,
        title="Arbitrary string used for node filtering if extra constraints are enabled",
    )
    constraints: Optional[str] = Field(
        None, title="Comma separated list of features that are required"
    )
    group_id: Optional[str] = Field(
        None, title="Group ID of the user that owns the job"
    )
    hetjob_group: Optional[int] = Field(
        None,
        title="Unique sequence number applied to this component of the heterogeneous job",
    )
    immediate: Optional[bool] = Field(
        None,
        title="If true, exit if resources are not available within the time period specified",
    )
    job_id: Optional[int] = Field(None, title="Job ID")
    kill_on_node_fail: Optional[bool] = Field(
        None, title="If true, kill job on node failure"
    )
    licenses: Optional[str] = Field(None, title="License(s) required by the job")
    mail_type: Optional[List[str]] = Field(None, title="Mail event type(s)")
    mail_user: Optional[str] = Field(None, title="User to receive email notifications")
    mcs_label: Optional[str] = Field(
        None, title="Multi-Category Security label on the job"
    )
    memory_binding: Optional[str] = Field(None, title="Binding map for map/mask_cpu")
    memory_binding_type: Optional[List[str]] = Field(
        None, title="Method for binding tasks to memory"
    )
    memory_per_tres: Optional[str] = Field(
        None,
        title="Semicolon delimited list of TRES=# values indicating how much memory in megabytes should be allocated for each specified TRES (currently only used for gres/gpu)",
    )
    name: Optional[str] = Field(None, title="Job name")
    network: Optional[str] = Field(None, title="Network specs for job step")
    nice: Optional[int] = Field(None, title="Requested job priority change")
    tasks: Optional[int] = Field(None, title="Number of tasks")
    open_mode: Optional[List[str]] = Field(
        None, title="Open mode used for stdout and stderr files"
    )
    reserve_ports: Optional[int] = Field(
        None, title="Port to send various notification msg to"
    )
    overcommit: Optional[bool] = Field(None, title="Overcommit resources")
    partition: Optional[str] = Field(None, title="Partition assigned to the job")
    distribution_plane_size: Optional[JobDescMsgDistributionPlaneSize] = Field(
        None, title="Plane size specification when distribution specifies plane"
    )
    power_flags: Optional[List[Dict[str, Any]]] = Field(None, title="Power Flags")
    prefer: Optional[str] = Field(
        None,
        title="Comma separated list of features that are preferred but not required",
    )
    hold: Optional[bool] = Field(None, title="Hold (true) or release (false) job")
    priority: Optional[JobDescMsgPriority] = Field(
        None, title="Request specific job priority"
    )
    profile: Optional[List[str]] = Field(
        None, title="Profile used by the acct_gather_profile plugin"
    )
    qos: Optional[str] = Field(None, title="Quality of Service assigned to the job")
    reboot: Optional[bool] = Field(None, title="Node reboot requested before start")
    required_nodes: Optional[List[str]] = Field(
        None, title="Comma separated list of required nodes"
    )
    requeue: Optional[bool] = Field(
        None, title="Determines whether the job may be requeued"
    )
    reservation: Optional[str] = Field(None, title="Name of reservation to use")
    resv_mpi_ports: Optional[int] = Field(
        None,
        title="Number of reserved communication ports; can only be used if slurmstepd step manager is enabled",
    )
    script: Optional[str] = Field(
        None,
        title="Job batch script; only the first component in a HetJob is populated or honored",
    )
    shared: Optional[List[str]] = Field(
        None, title="How the job can share resources with other jobs, if at all"
    )
    exclusive: Optional[List[str]] = Field(None, title="Exclusive")
    oversubscribe: Optional[bool] = Field(None, title="Oversubscribe")
    site_factor: Optional[int] = Field(None, title="Site-specific priority factor")
    spank_environment: Optional[List[str]] = Field(
        None,
        title="Environment variables for job prolog/epilog scripts as set by SPANK plugins",
    )
    distribution: Optional[str] = Field(None, title="Layout")
    time_limit: Optional[JobDescMsgTimeLimit] = Field(
        None, title="Maximum run time in minutes"
    )
    time_minimum: Optional[JobDescMsgTimeMinimum] = Field(
        None, title="Minimum run time in minutes"
    )
    tres_bind: Optional[str] = Field(None, title="Task to TRES binding directives")
    tres_freq: Optional[str] = Field(None, title="TRES frequency directives")
    tres_per_job: Optional[str] = Field(
        None,
        title="Comma separated list of TRES=# values to be allocated for every job",
    )
    tres_per_node: Optional[str] = Field(
        None,
        title="Comma separated list of TRES=# values to be allocated for every node",
    )
    tres_per_socket: Optional[str] = Field(
        None,
        title="Comma separated list of TRES=# values to be allocated for every socket",
    )
    tres_per_task: Optional[str] = Field(
        None,
        title="Comma separated list of TRES=# values to be allocated for every task",
    )
    user_id: Optional[str] = Field(None, title="User ID that owns the job")
    wait_all_nodes: Optional[bool] = Field(
        None, title="If true, wait to start until after all nodes have booted"
    )
    kill_warning_flags: Optional[List[str]] = Field(
        None, title="Flags related to job signals"
    )
    kill_warning_signal: Optional[str] = Field(
        None, title='Signal to send when approaching end time (e.g. "10" or "USR1")'
    )
    kill_warning_delay: Optional[JobDescMsgKillWarningDelay] = Field(
        None, title="Number of seconds before end time to send the warning signal"
    )
    current_working_directory: Optional[str] = Field(
        None, title="Working directory to use for the job"
    )
    cpus_per_task: Optional[int] = Field(
        None, title="Number of CPUs required by each task"
    )
    minimum_cpus: Optional[int] = Field(None, title="Minimum number of CPUs required")
    maximum_cpus: Optional[int] = Field(None, title="Maximum number of CPUs required")
    nodes: Optional[str] = Field(
        None, title="Node count range specification (e.g. 1-15:4)"
    )
    minimum_nodes: Optional[int] = Field(None, title="Minimum node count")
    maximum_nodes: Optional[int] = Field(None, title="Maximum node count")
    minimum_boards_per_node: Optional[int] = Field(
        None, title="Boards per node required"
    )
    minimum_sockets_per_board: Optional[int] = Field(
        None, title="Sockets per board required"
    )
    sockets_per_node: Optional[int] = Field(None, title="Sockets per node required")
    threads_per_core: Optional[int] = Field(None, title="Threads per core required")
    tasks_per_node: Optional[int] = Field(
        None, title="Number of tasks to invoke on each node"
    )
    tasks_per_socket: Optional[int] = Field(
        None, title="Number of tasks to invoke on each socket"
    )
    tasks_per_core: Optional[int] = Field(
        None, title="Number of tasks to invoke on each core"
    )
    tasks_per_board: Optional[int] = Field(
        None, title="Number of tasks to invoke on each board"
    )
    ntasks_per_tres: Optional[int] = Field(
        None, title="Number of tasks that can access each GPU"
    )
    minimum_cpus_per_node: Optional[int] = Field(
        None, title="Minimum number of CPUs per node"
    )
    memory_per_cpu: Optional[JobDescMsgMemoryPerCpu] = Field(
        None, title="Minimum memory in megabytes per allocated CPU"
    )
    memory_per_node: Optional[JobDescMsgMemoryPerNode] = Field(
        None, title="Minimum memory in megabytes per allocated CPU"
    )
    temporary_disk_per_node: Optional[int] = Field(
        None, title="Minimum tmp disk space required per node"
    )
    selinux_context: Optional[str] = Field(None, title="SELinux context")
    required_switches: Optional[JobDescMsgRequiredSwitches] = Field(
        None, title="Maximum number of switches"
    )
    segment_size: Optional[JobDescMsgSegmentSize] = Field(
        None, title="Segment size for topology/block"
    )
    standard_error: Optional[str] = Field(None, title="Path to stderr file")
    standard_input: Optional[str] = Field(None, title="Path to stdin file")
    standard_output: Optional[str] = Field(None, title="Path to stdout file")
    wait_for_switch: Optional[int] = Field(
        None, title="Maximum time to wait for switches in seconds"
    )
    wckey: Optional[str] = Field(None, title="Workload characterization key")
    x11: Optional[List[str]] = Field(None, title="X11 forwarding options")
    x11_magic_cookie: Optional[str] = Field(
        None, title="Magic cookie for X11 forwarding"
    )
    x11_target_host: Optional[str] = Field(
        None, title="Hostname or UNIX socket if x11_target_port=0"
    )
    x11_target_port: Optional[int] = Field(None, title="TCP port")


class JobSubmitReq(BaseModel):
    script: Optional[str] = Field(
        None, title="Deprecated; Populate script field in jobs[0] or job"
    )
    jobs: Optional[List[JobDescMsg]] = Field(None, title="HetJob description")
    job: Optional[JobDescMsg] = Field(None, title="Job description")


class OpenapiJobInfoRespJobsItemDerivedExitCode(BaseModel):
    status: Optional[List[str]] = Field(None, title="Status given by return code")
    return_code: Optional[OpenapiJobInfoRespJobsItemDerivedExitCodeReturnCode] = Field(
        None, title="Process return code (numeric)"
    )
    signal: Optional[OpenapiJobInfoRespJobsItemDerivedExitCodeSignal] = Field(
        None, title="Openapi job info resp jobs item derived exit code signal"
    )


class OpenapiJobInfoRespJobsItemExitCode(BaseModel):
    status: Optional[List[str]] = Field(None, title="Status given by return code")
    return_code: Optional[OpenapiJobInfoRespJobsItemExitCodeReturnCode] = Field(
        None, title="Process return code (numeric)"
    )
    signal: Optional[OpenapiJobInfoRespJobsItemExitCodeSignal] = Field(
        None, title="Openapi job info resp jobs item exit code signal"
    )


class OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItem(BaseModel):
    index: Optional[int] = Field(None, title="Node index")
    name: Optional[str] = Field(None, title="Node name")
    cpus: Optional[OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemCpus] = (
        Field(
            None,
            title="Openapi job info resp jobs item job resources nodes allocation item cpus",
        )
    )
    memory: Optional[
        OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemMemory
    ] = Field(
        None,
        title="Openapi job info resp jobs item job resources nodes allocation item memory",
    )
    sockets: Optional[
        List[OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItem]
    ] = Field(None, title="Socket allocations in node")


class OpenapiJobInfoRespMeta(BaseModel):
    plugin: Optional[OpenapiJobInfoRespMetaPlugin] = Field(
        None, title="Openapi job info resp meta plugin"
    )
    client: Optional[OpenapiJobInfoRespMetaClient] = Field(
        None, title="Openapi job info resp meta client"
    )
    command: Optional[List[str]] = Field(None, title="CLI command (if applicable)")
    slurm: Optional[OpenapiJobInfoRespMetaSlurm] = Field(
        None, title="Openapi job info resp meta slurm"
    )


class OpenapiJobSubmitResponseMeta(BaseModel):
    plugin: Optional[OpenapiJobSubmitResponseMetaPlugin] = Field(
        None, title="Openapi job submit response meta plugin"
    )
    client: Optional[OpenapiJobSubmitResponseMetaClient] = Field(
        None, title="Openapi job submit response meta client"
    )
    command: Optional[List[str]] = Field(None, title="CLI command (if applicable)")
    slurm: Optional[OpenapiJobSubmitResponseMetaSlurm] = Field(
        None, title="Openapi job submit response meta slurm"
    )


class OpenapiRespMeta(BaseModel):
    plugin: Optional[OpenapiRespMetaPlugin] = Field(
        None, title="Openapi resp meta plugin"
    )
    client: Optional[OpenapiRespMetaClient] = Field(
        None, title="Openapi resp meta client"
    )
    command: Optional[List[str]] = Field(None, title="CLI command (if applicable)")
    slurm: Optional[OpenapiRespMetaSlurm] = Field(None, title="Openapi resp meta slurm")


class PostBodySlurmJobSubmit(BaseModel):
    content: Optional[JobSubmitReq] = Field(None, title="Job submit req")


class OpenapiJobInfoRespJobsItemJobResourcesNodes(BaseModel):
    count: Optional[int] = Field(None, title="Number of allocated nodes")
    select_type: Optional[List[str]] = Field(
        None, title="Node scheduling selection method"
    )
    list: Optional[str] = Field(None, title="Node(s) allocated to the job")
    whole: Optional[bool] = Field(None, title="Whether whole nodes were allocated")
    allocation: Optional[
        List[OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItem]
    ] = Field(None, title="Allocated node resources")


class OpenapiJobSubmitResponse(BaseModel):
    result: Optional[OpenapiJobSubmitResponseResult] = Field(
        None, title="Job submission"
    )
    job_id: Optional[int] = Field(None, title="Submitted Job ID")
    step_id: Optional[str] = Field(None, title="Submitted Step ID")
    job_submit_user_msg: Optional[str] = Field(
        None, title="Job submission user message"
    )
    meta: Optional[OpenapiJobSubmitResponseMeta] = Field(
        None, title="Slurm meta values"
    )
    errors: Optional[List[OpenapiJobSubmitResponseErrorsItem]] = Field(
        None, title="Query errors"
    )
    warnings: Optional[List[OpenapiJobSubmitResponseWarningsItem]] = Field(
        None, title="Query warnings"
    )


class OpenapiResp(BaseModel):
    meta: Optional[OpenapiRespMeta] = Field(None, title="Slurm meta values")
    errors: Optional[List[OpenapiRespErrorsItem]] = Field(None, title="Query errors")
    warnings: Optional[List[OpenapiRespWarningsItem]] = Field(
        None, title="Query warnings"
    )


class PostResponse200SlurmJobSubmit(BaseModel):
    content: OpenapiJobSubmitResponse = Field(..., title="Openapi job submit response")


class PostResponseDefaultSlurmJobSubmit(BaseModel):
    content: OpenapiJobSubmitResponse = Field(..., title="Openapi job submit response")


class DeleteResponse200SlurmJobJobid(BaseModel):
    content: OpenapiResp = Field(..., title="Openapi resp")


class DeleteResponseDefaultSlurmJobJobid(BaseModel):
    content: OpenapiResp = Field(..., title="Openapi resp")


class OpenapiJobInfoRespJobsItemJobResources(BaseModel):
    select_type: Optional[List[str]] = Field(
        None, title="Scheduler consumable resource selection type"
    )
    nodes: Optional[OpenapiJobInfoRespJobsItemJobResourcesNodes] = Field(
        None, title="Openapi job info resp jobs item job resources nodes"
    )
    cpus: Optional[int] = Field(None, title="Number of allocated CPUs")
    threads_per_core: Optional[OpenapiJobInfoRespJobsItemJobResourcesThreadsPerCore] = (
        Field(None, title="Number of processor threads per CPU core")
    )


class OpenapiJobInfoRespJobsItem(BaseModel):
    account: Optional[str] = Field(None, title="Account associated with the job")
    accrue_time: Optional[OpenapiJobInfoRespJobsItemAccrueTime] = Field(
        None, title="When the job started accruing age priority (UNIX timestamp)"
    )
    admin_comment: Optional[str] = Field(
        None, title="Arbitrary comment made by administrator"
    )
    allocating_node: Optional[str] = Field(
        None, title="Local node making the resource allocation"
    )
    array_job_id: Optional[OpenapiJobInfoRespJobsItemArrayJobId] = Field(
        None, title="Job ID of job array, or 0 if N/A"
    )
    array_task_id: Optional[OpenapiJobInfoRespJobsItemArrayTaskId] = Field(
        None, title="Task ID of this task in job array"
    )
    array_max_tasks: Optional[OpenapiJobInfoRespJobsItemArrayMaxTasks] = Field(
        None,
        title="Maximum number of simultaneously running array tasks, 0 if no limit",
    )
    array_task_string: Optional[str] = Field(
        None, title="String expression of task IDs in this record"
    )
    association_id: Optional[int] = Field(
        None, title="Unique identifier for the association"
    )
    batch_features: Optional[str] = Field(
        None, title="Features required for batch script's node"
    )
    batch_flag: Optional[bool] = Field(None, title="True if batch job")
    batch_host: Optional[str] = Field(None, title="Name of host running batch script")
    flags: Optional[List[str]] = Field(None, title="Job flags")
    burst_buffer: Optional[str] = Field(None, title="Burst buffer specifications")
    burst_buffer_state: Optional[str] = Field(None, title="Burst buffer state details")
    cluster: Optional[str] = Field(None, title="Cluster name")
    cluster_features: Optional[str] = Field(
        None, title="List of required cluster features"
    )
    command: Optional[str] = Field(None, title="Executed command")
    comment: Optional[str] = Field(None, title="Arbitrary comment")
    container: Optional[str] = Field(
        None, title="Absolute path to OCI container bundle"
    )
    container_id: Optional[str] = Field(None, title="OCI container ID")
    contiguous: Optional[bool] = Field(
        None, title="True if job requires contiguous nodes"
    )
    core_spec: Optional[int] = Field(None, title="Specialized core count")
    thread_spec: Optional[int] = Field(None, title="Specialized thread count")
    cores_per_socket: Optional[OpenapiJobInfoRespJobsItemCoresPerSocket] = Field(
        None, title="Cores per socket required"
    )
    billable_tres: Optional[OpenapiJobInfoRespJobsItemBillableTres] = Field(
        None, title="Billable TRES"
    )
    cpus_per_task: Optional[OpenapiJobInfoRespJobsItemCpusPerTask] = Field(
        None, title="Number of CPUs required by each task"
    )
    cpu_frequency_minimum: Optional[OpenapiJobInfoRespJobsItemCpuFrequencyMinimum] = (
        Field(None, title="Minimum CPU frequency")
    )
    cpu_frequency_maximum: Optional[OpenapiJobInfoRespJobsItemCpuFrequencyMaximum] = (
        Field(None, title="Maximum CPU frequency")
    )
    cpu_frequency_governor: Optional[OpenapiJobInfoRespJobsItemCpuFrequencyGovernor] = (
        Field(None, title="CPU frequency governor")
    )
    cpus_per_tres: Optional[str] = Field(
        None,
        title="Semicolon delimited list of TRES=# values indicating how many CPUs should be allocated for each specified TRES (currently only used for gres/gpu)",
    )
    cron: Optional[str] = Field(None, title="Time specification for scrontab job")
    deadline: Optional[OpenapiJobInfoRespJobsItemDeadline] = Field(
        None, title="Latest time that the job may start (UNIX timestamp)"
    )
    delay_boot: Optional[OpenapiJobInfoRespJobsItemDelayBoot] = Field(
        None,
        title="Number of seconds after job eligible start that nodes will be rebooted to satisfy feature specification",
    )
    dependency: Optional[str] = Field(
        None,
        title="Other jobs that must meet certain criteria before this job can start",
    )
    derived_exit_code: Optional[OpenapiJobInfoRespJobsItemDerivedExitCode] = Field(
        None, title="Highest exit code of all job steps"
    )
    eligible_time: Optional[OpenapiJobInfoRespJobsItemEligibleTime] = Field(
        None, title="Time when the job became eligible to run (UNIX timestamp)"
    )
    end_time: Optional[OpenapiJobInfoRespJobsItemEndTime] = Field(
        None, title="End time, real or expected (UNIX timestamp)"
    )
    excluded_nodes: Optional[str] = Field(
        None, title="Comma separated list of nodes that may not be used"
    )
    exit_code: Optional[OpenapiJobInfoRespJobsItemExitCode] = Field(
        None, title="Exit code of the job"
    )
    extra: Optional[str] = Field(
        None,
        title="Arbitrary string used for node filtering if extra constraints are enabled",
    )
    failed_node: Optional[str] = Field(
        None, title="Name of node that caused job failure"
    )
    features: Optional[str] = Field(
        None, title="Comma separated list of features that are required"
    )
    federation_origin: Optional[str] = Field(
        None, title="Origin cluster's name (when using federation)"
    )
    federation_siblings_active: Optional[str] = Field(
        None, title="Active sibling job names"
    )
    federation_siblings_viable: Optional[str] = Field(
        None, title="Viable sibling job names"
    )
    gres_detail: Optional[List[str]] = Field(
        None, title="List of GRES index and counts allocated per node"
    )
    group_id: Optional[int] = Field(
        None, title="Group ID of the user that owns the job"
    )
    group_name: Optional[str] = Field(
        None, title="Group name of the user that owns the job"
    )
    het_job_id: Optional[OpenapiJobInfoRespJobsItemHetJobId] = Field(
        None, title="Heterogeneous job ID, if applicable"
    )
    het_job_id_set: Optional[str] = Field(
        None, title="Job ID range for all heterogeneous job components"
    )
    het_job_offset: Optional[OpenapiJobInfoRespJobsItemHetJobOffset] = Field(
        None,
        title="Unique sequence number applied to this component of the heterogeneous job",
    )
    job_id: Optional[int] = Field(None, title="Job ID")
    job_resources: Optional[OpenapiJobInfoRespJobsItemJobResources] = Field(
        None, title="Resources used by the job"
    )
    job_size_str: Optional[List[str]] = Field(
        None, title="Number of nodes (in a range) required for this job"
    )
    job_state: Optional[List[str]] = Field(None, title="Current state")
    last_sched_evaluation: Optional[OpenapiJobInfoRespJobsItemLastSchedEvaluation] = (
        Field(None, title="Last time job was evaluated for scheduling (UNIX timestamp)")
    )
    licenses: Optional[str] = Field(None, title="License(s) required by the job")
    mail_type: Optional[List[str]] = Field(None, title="Mail event type(s)")
    mail_user: Optional[str] = Field(None, title="User to receive email notifications")
    max_cpus: Optional[OpenapiJobInfoRespJobsItemMaxCpus] = Field(
        None, title="Maximum number of CPUs usable by the job"
    )
    max_nodes: Optional[OpenapiJobInfoRespJobsItemMaxNodes] = Field(
        None, title="Maximum number of nodes usable by the job"
    )
    mcs_label: Optional[str] = Field(
        None, title="Multi-Category Security label on the job"
    )
    memory_per_tres: Optional[str] = Field(
        None,
        title="Semicolon delimited list of TRES=# values indicating how much memory in megabytes should be allocated for each specified TRES (currently only used for gres/gpu)",
    )
    name: Optional[str] = Field(None, title="Job name")
    network: Optional[str] = Field(None, title="Network specs for the job")
    nodes: Optional[str] = Field(None, title="Node(s) allocated to the job")
    nice: Optional[int] = Field(None, title="Requested job priority change")
    tasks_per_core: Optional[OpenapiJobInfoRespJobsItemTasksPerCore] = Field(
        None, title="Number of tasks invoked on each core"
    )
    tasks_per_tres: Optional[OpenapiJobInfoRespJobsItemTasksPerTres] = Field(
        None, title="Number of tasks that can assess each GPU"
    )
    tasks_per_node: Optional[OpenapiJobInfoRespJobsItemTasksPerNode] = Field(
        None, title="Number of tasks invoked on each node"
    )
    tasks_per_socket: Optional[OpenapiJobInfoRespJobsItemTasksPerSocket] = Field(
        None, title="Number of tasks invoked on each socket"
    )
    tasks_per_board: Optional[OpenapiJobInfoRespJobsItemTasksPerBoard] = Field(
        None, title="Number of tasks invoked on each board"
    )
    cpus: Optional[OpenapiJobInfoRespJobsItemCpus] = Field(
        None, title="Minimum number of CPUs required"
    )
    node_count: Optional[OpenapiJobInfoRespJobsItemNodeCount] = Field(
        None, title="Minimum number of nodes required"
    )
    tasks: Optional[OpenapiJobInfoRespJobsItemTasks] = Field(
        None, title="Number of tasks"
    )
    partition: Optional[str] = Field(None, title="Partition assigned to the job")
    prefer: Optional[str] = Field(
        None, title="Feature(s) the job requested but that are not required"
    )
    memory_per_cpu: Optional[OpenapiJobInfoRespJobsItemMemoryPerCpu] = Field(
        None, title="Minimum memory in megabytes per allocated CPU"
    )
    memory_per_node: Optional[OpenapiJobInfoRespJobsItemMemoryPerNode] = Field(
        None, title="Minimum memory in megabytes per allocated node"
    )
    minimum_cpus_per_node: Optional[OpenapiJobInfoRespJobsItemMinimumCpusPerNode] = (
        Field(None, title="Minimum number of CPUs per node")
    )
    minimum_tmp_disk_per_node: Optional[
        OpenapiJobInfoRespJobsItemMinimumTmpDiskPerNode
    ] = Field(None, title="Minimum tmp disk space required per node")
    power: Optional[OpenapiJobInfoRespJobsItemPower] = Field(
        None, title="Openapi job info resp jobs item power"
    )
    preempt_time: Optional[OpenapiJobInfoRespJobsItemPreemptTime] = Field(
        None, title="Time job received preemption signal (UNIX timestamp)"
    )
    preemptable_time: Optional[OpenapiJobInfoRespJobsItemPreemptableTime] = Field(
        None, title="Time job becomes eligible for preemption (UNIX timestamp)"
    )
    pre_sus_time: Optional[OpenapiJobInfoRespJobsItemPreSusTime] = Field(
        None, title="Total run time prior to last suspend in seconds"
    )
    hold: Optional[bool] = Field(None, title="Hold (true) or release (false) job")
    priority: Optional[OpenapiJobInfoRespJobsItemPriority] = Field(
        None, title="Request specific job priority"
    )
    profile: Optional[List[str]] = Field(
        None, title="Profile used by the acct_gather_profile plugin"
    )
    qos: Optional[str] = Field(None, title="Quality of Service assigned to the job")
    reboot: Optional[bool] = Field(None, title="Node reboot requested before start")
    required_nodes: Optional[str] = Field(
        None, title="Comma separated list of required nodes"
    )
    minimum_switches: Optional[int] = Field(
        None, title="Maximum number of switches (the 'minimum' in the key is incorrect)"
    )
    requeue: Optional[bool] = Field(
        None, title="Determines whether the job may be requeued"
    )
    resize_time: Optional[OpenapiJobInfoRespJobsItemResizeTime] = Field(
        None, title="Time of last size change (UNIX timestamp)"
    )
    restart_cnt: Optional[int] = Field(None, title="Number of job restarts")
    resv_name: Optional[str] = Field(None, title="Name of reservation to use")
    scheduled_nodes: Optional[str] = Field(
        None, title="List of nodes scheduled to be used for the job"
    )
    selinux_context: Optional[str] = Field(None, title="SELinux context")
    shared: Optional[List[str]] = Field(
        None, title="How the job can share resources with other jobs, if at all"
    )
    exclusive: Optional[List[str]] = Field(None, title="Exclusive")
    oversubscribe: Optional[bool] = Field(None, title="Oversubscribe")
    show_flags: Optional[List[str]] = Field(
        None, title="Job details shown in this response"
    )
    sockets_per_board: Optional[int] = Field(
        None, title="Number of sockets per board required"
    )
    sockets_per_node: Optional[OpenapiJobInfoRespJobsItemSocketsPerNode] = Field(
        None, title="Number of sockets per node required"
    )
    start_time: Optional[OpenapiJobInfoRespJobsItemStartTime] = Field(
        None, title="Time execution began, or is expected to begin (UNIX timestamp)"
    )
    state_description: Optional[str] = Field(
        None, title="Optional details for state_reason"
    )
    state_reason: Optional[str] = Field(
        None, title="Reason for current Pending or Failed state"
    )
    standard_error: Optional[str] = Field(None, title="Path to stderr file")
    standard_input: Optional[str] = Field(None, title="Path to stdin file")
    standard_output: Optional[str] = Field(None, title="Path to stdout file")
    submit_time: Optional[OpenapiJobInfoRespJobsItemSubmitTime] = Field(
        None, title="Time when the job was submitted (UNIX timestamp)"
    )
    suspend_time: Optional[OpenapiJobInfoRespJobsItemSuspendTime] = Field(
        None, title="Time the job was last suspended or resumed (UNIX timestamp)"
    )
    system_comment: Optional[str] = Field(
        None, title="Arbitrary comment from slurmctld"
    )
    time_limit: Optional[OpenapiJobInfoRespJobsItemTimeLimit] = Field(
        None, title="Maximum run time in minutes"
    )
    time_minimum: Optional[OpenapiJobInfoRespJobsItemTimeMinimum] = Field(
        None, title="Minimum run time in minutes"
    )
    threads_per_core: Optional[OpenapiJobInfoRespJobsItemThreadsPerCore] = Field(
        None, title="Number of processor threads per CPU core required"
    )
    tres_bind: Optional[str] = Field(None, title="Task to TRES binding directives")
    tres_freq: Optional[str] = Field(None, title="TRES frequency directives")
    tres_per_job: Optional[str] = Field(
        None, title="Comma separated list of TRES=# values to be allocated per job"
    )
    tres_per_node: Optional[str] = Field(
        None, title="Comma separated list of TRES=# values to be allocated per node"
    )
    tres_per_socket: Optional[str] = Field(
        None, title="Comma separated list of TRES=# values to be allocated per socket"
    )
    tres_per_task: Optional[str] = Field(
        None, title="Comma separated list of TRES=# values to be allocated per task"
    )
    tres_req_str: Optional[str] = Field(None, title="TRES requested by the job")
    tres_alloc_str: Optional[str] = Field(None, title="TRES used by the job")
    user_id: Optional[int] = Field(None, title="User ID that owns the job")
    user_name: Optional[str] = Field(None, title="User name that owns the job")
    maximum_switch_wait_time: Optional[int] = Field(
        None, title="Maximum time to wait for switches in seconds"
    )
    wckey: Optional[str] = Field(None, title="Workload characterization key")
    current_working_directory: Optional[str] = Field(
        None, title="Working directory to use for the job"
    )


class OpenapiJobInfoResp(BaseModel):
    jobs: Optional[List[OpenapiJobInfoRespJobsItem]] = Field(None, title="List of jobs")
    last_backfill: Optional[OpenapiJobInfoRespLastBackfill] = Field(
        None, title="Time of last backfill scheduler run (UNIX timestamp)"
    )
    last_update: Optional[OpenapiJobInfoRespLastUpdate] = Field(
        None, title="Time of last job change (UNIX timestamp)"
    )
    meta: Optional[OpenapiJobInfoRespMeta] = Field(None, title="Slurm meta values")
    errors: Optional[List[OpenapiJobInfoRespErrorsItem]] = Field(
        None, title="Query errors"
    )
    warnings: Optional[List[OpenapiJobInfoRespWarningsItem]] = Field(
        None, title="Query warnings"
    )


class GetResponse200SlurmJobJobid(BaseModel):
    content: OpenapiJobInfoResp = Field(..., title="Openapi job info resp")


class GetResponse200SlurmJobs(BaseModel):
    content: OpenapiJobInfoResp = Field(..., title="Openapi job info resp")


class GetResponseDefaultSlurmJobJobid(BaseModel):
    content: OpenapiJobInfoResp = Field(..., title="Openapi job info resp")


class GetResponseDefaultSlurmJobs(BaseModel):
    content: OpenapiJobInfoResp = Field(..., title="Openapi job info resp")


class AllModels(BaseModel):
    model0: PostPathSlurmJobSubmit = Field(
        ..., title="POST /slurm/v0.0.41/job/submit: path parameters"
    )
    model1: PostQuerySlurmJobSubmit = Field(
        ..., title="POST /slurm/v0.0.41/job/submit: query parameters"
    )
    model2: JobDescMsgBeginTime = Field(
        ...,
        title="Defer the allocation of the job until the specified time (UNIX timestamp)",
    )
    model3: JobDescMsgCrontabLine = Field(..., title="Job desc msg crontab line")
    model4: JobDescMsgCrontab = Field(..., title="Specification for scrontab job")
    model5: JobDescMsgRlimitsCpu = Field(
        ..., title="Per-process CPU limit, in seconds."
    )
    model6: JobDescMsgRlimitsFsize = Field(
        ..., title="Largest file that can be created, in bytes."
    )
    model7: JobDescMsgRlimitsData = Field(
        ..., title="Maximum size of data segment, in bytes. "
    )
    model8: JobDescMsgRlimitsStack = Field(
        ..., title="Maximum size of stack segment, in bytes."
    )
    model9: JobDescMsgRlimitsCore = Field(
        ..., title="Largest core file that can be created, in bytes."
    )
    model10: JobDescMsgRlimitsRss = Field(
        ...,
        title="Largest resident set size, in bytes. This affects swapping; processes that are exceeding their resident set size will be more likely to have physical memory taken from them.",
    )
    model11: JobDescMsgRlimitsNproc = Field(..., title="Number of processes.")
    model12: JobDescMsgRlimitsNofile = Field(..., title="Number of open files.")
    model13: JobDescMsgRlimitsMemlock = Field(
        ..., title="Locked-in-memory address space"
    )
    model14: JobDescMsgRlimitsAs = Field(..., title="Address space limit.")
    model15: JobDescMsgRlimits = Field(..., title="Job desc msg rlimits")
    model16: JobDescMsgDistributionPlaneSize = Field(
        ..., title="Plane size specification when distribution specifies plane"
    )
    model17: JobDescMsgPriority = Field(..., title="Request specific job priority")
    model18: JobDescMsgTimeLimit = Field(..., title="Maximum run time in minutes")
    model19: JobDescMsgTimeMinimum = Field(..., title="Minimum run time in minutes")
    model20: JobDescMsgKillWarningDelay = Field(
        ..., title="Number of seconds before end time to send the warning signal"
    )
    model21: JobDescMsgMemoryPerCpu = Field(
        ..., title="Minimum memory in megabytes per allocated CPU"
    )
    model22: JobDescMsgMemoryPerNode = Field(
        ..., title="Minimum memory in megabytes per allocated CPU"
    )
    model23: JobDescMsgRequiredSwitches = Field(..., title="Maximum number of switches")
    model24: JobDescMsgSegmentSize = Field(..., title="Segment size for topology/block")
    model25: JobDescMsg = Field(..., title="Job desc msg")
    model26: JobSubmitReq = Field(..., title="Job submit req")
    model27: PostBodySlurmJobSubmit = Field(..., title="Job description")
    model28: OpenapiJobSubmitResponseResult = Field(..., title="Job submission")
    model29: OpenapiJobSubmitResponseMetaPlugin = Field(
        ..., title="Openapi job submit response meta plugin"
    )
    model30: OpenapiJobSubmitResponseMetaClient = Field(
        ..., title="Openapi job submit response meta client"
    )
    model31: OpenapiJobSubmitResponseMetaSlurmVersion = Field(
        ..., title="Openapi job submit response meta slurm version"
    )
    model32: OpenapiJobSubmitResponseMetaSlurm = Field(
        ..., title="Openapi job submit response meta slurm"
    )
    model33: OpenapiJobSubmitResponseMeta = Field(..., title="Slurm meta values")
    model34: OpenapiJobSubmitResponseErrorsItem = Field(
        ..., title="Openapi job submit response errors item"
    )
    model35: OpenapiJobSubmitResponseWarningsItem = Field(
        ..., title="Openapi job submit response warnings item"
    )
    model36: OpenapiJobSubmitResponse = Field(..., title="Openapi job submit response")
    model37: PostResponse200SlurmJobSubmit = Field(..., title="job submission response")
    model38: PostResponseDefaultSlurmJobSubmit = Field(
        ..., title="job submission response"
    )
    model39: GetPathSlurmJobJobid = Field(
        ..., title="GET /slurm/v0.0.41/job/{job_id}: path parameters"
    )
    model40: GetQuerySlurmJobJobid = Field(
        ..., title="GET /slurm/v0.0.41/job/{job_id}: query parameters"
    )
    model41: GetBodySlurmJobJobid = Field(
        ..., title="GET /slurm/v0.0.41/job/{job_id}: body"
    )
    model42: OpenapiJobInfoRespJobsItemAccrueTime = Field(
        ..., title="When the job started accruing age priority (UNIX timestamp)"
    )
    model43: OpenapiJobInfoRespJobsItemArrayJobId = Field(
        ..., title="Job ID of job array, or 0 if N/A"
    )
    model44: OpenapiJobInfoRespJobsItemArrayTaskId = Field(
        ..., title="Task ID of this task in job array"
    )
    model45: OpenapiJobInfoRespJobsItemArrayMaxTasks = Field(
        ..., title="Maximum number of simultaneously running array tasks, 0 if no limit"
    )
    model46: OpenapiJobInfoRespJobsItemCoresPerSocket = Field(
        ..., title="Cores per socket required"
    )
    model47: OpenapiJobInfoRespJobsItemBillableTres = Field(..., title="Billable TRES")
    model48: OpenapiJobInfoRespJobsItemCpusPerTask = Field(
        ..., title="Number of CPUs required by each task"
    )
    model49: OpenapiJobInfoRespJobsItemCpuFrequencyMinimum = Field(
        ..., title="Minimum CPU frequency"
    )
    model50: OpenapiJobInfoRespJobsItemCpuFrequencyMaximum = Field(
        ..., title="Maximum CPU frequency"
    )
    model51: OpenapiJobInfoRespJobsItemCpuFrequencyGovernor = Field(
        ..., title="CPU frequency governor"
    )
    model52: OpenapiJobInfoRespJobsItemDeadline = Field(
        ..., title="Latest time that the job may start (UNIX timestamp)"
    )
    model53: OpenapiJobInfoRespJobsItemDelayBoot = Field(
        ...,
        title="Number of seconds after job eligible start that nodes will be rebooted to satisfy feature specification",
    )
    model54: OpenapiJobInfoRespJobsItemDerivedExitCodeReturnCode = Field(
        ..., title="Process return code (numeric)"
    )
    model55: OpenapiJobInfoRespJobsItemDerivedExitCodeSignalId = Field(
        ..., title="Signal sent to process (numeric)"
    )
    model56: OpenapiJobInfoRespJobsItemDerivedExitCodeSignal = Field(
        ..., title="Openapi job info resp jobs item derived exit code signal"
    )
    model57: OpenapiJobInfoRespJobsItemDerivedExitCode = Field(
        ..., title="Highest exit code of all job steps"
    )
    model58: OpenapiJobInfoRespJobsItemEligibleTime = Field(
        ..., title="Time when the job became eligible to run (UNIX timestamp)"
    )
    model59: OpenapiJobInfoRespJobsItemEndTime = Field(
        ..., title="End time, real or expected (UNIX timestamp)"
    )
    model60: OpenapiJobInfoRespJobsItemExitCodeReturnCode = Field(
        ..., title="Process return code (numeric)"
    )
    model61: OpenapiJobInfoRespJobsItemExitCodeSignalId = Field(
        ..., title="Signal sent to process (numeric)"
    )
    model62: OpenapiJobInfoRespJobsItemExitCodeSignal = Field(
        ..., title="Openapi job info resp jobs item exit code signal"
    )
    model63: OpenapiJobInfoRespJobsItemExitCode = Field(
        ..., title="Exit code of the job"
    )
    model64: OpenapiJobInfoRespJobsItemHetJobId = Field(
        ..., title="Heterogeneous job ID, if applicable"
    )
    model65: OpenapiJobInfoRespJobsItemHetJobOffset = Field(
        ...,
        title="Unique sequence number applied to this component of the heterogeneous job",
    )
    model66: OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemCpus = Field(
        ...,
        title="Openapi job info resp jobs item job resources nodes allocation item cpus",
    )
    model67: OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemMemory = Field(
        ...,
        title="Openapi job info resp jobs item job resources nodes allocation item memory",
    )
    model68: (
        OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItemCoresItem
    ) = Field(
        ...,
        title="Openapi job info resp jobs item job resources nodes allocation item sockets item cores item",
    )
    model69: OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItemSocketsItem = (
        Field(
            ...,
            title="Openapi job info resp jobs item job resources nodes allocation item sockets item",
        )
    )
    model70: OpenapiJobInfoRespJobsItemJobResourcesNodesAllocationItem = Field(
        ..., title="Job resources for a node"
    )
    model71: OpenapiJobInfoRespJobsItemJobResourcesNodes = Field(
        ..., title="Openapi job info resp jobs item job resources nodes"
    )
    model72: OpenapiJobInfoRespJobsItemJobResourcesThreadsPerCore = Field(
        ..., title="Number of processor threads per CPU core"
    )
    model73: OpenapiJobInfoRespJobsItemJobResources = Field(
        ..., title="Resources used by the job"
    )
    model74: OpenapiJobInfoRespJobsItemLastSchedEvaluation = Field(
        ..., title="Last time job was evaluated for scheduling (UNIX timestamp)"
    )
    model75: OpenapiJobInfoRespJobsItemMaxCpus = Field(
        ..., title="Maximum number of CPUs usable by the job"
    )
    model76: OpenapiJobInfoRespJobsItemMaxNodes = Field(
        ..., title="Maximum number of nodes usable by the job"
    )
    model77: OpenapiJobInfoRespJobsItemTasksPerCore = Field(
        ..., title="Number of tasks invoked on each core"
    )
    model78: OpenapiJobInfoRespJobsItemTasksPerTres = Field(
        ..., title="Number of tasks that can assess each GPU"
    )
    model79: OpenapiJobInfoRespJobsItemTasksPerNode = Field(
        ..., title="Number of tasks invoked on each node"
    )
    model80: OpenapiJobInfoRespJobsItemTasksPerSocket = Field(
        ..., title="Number of tasks invoked on each socket"
    )
    model81: OpenapiJobInfoRespJobsItemTasksPerBoard = Field(
        ..., title="Number of tasks invoked on each board"
    )
    model82: OpenapiJobInfoRespJobsItemCpus = Field(
        ..., title="Minimum number of CPUs required"
    )
    model83: OpenapiJobInfoRespJobsItemNodeCount = Field(
        ..., title="Minimum number of nodes required"
    )
    model84: OpenapiJobInfoRespJobsItemTasks = Field(..., title="Number of tasks")
    model85: OpenapiJobInfoRespJobsItemMemoryPerCpu = Field(
        ..., title="Minimum memory in megabytes per allocated CPU"
    )
    model86: OpenapiJobInfoRespJobsItemMemoryPerNode = Field(
        ..., title="Minimum memory in megabytes per allocated node"
    )
    model87: OpenapiJobInfoRespJobsItemMinimumCpusPerNode = Field(
        ..., title="Minimum number of CPUs per node"
    )
    model88: OpenapiJobInfoRespJobsItemMinimumTmpDiskPerNode = Field(
        ..., title="Minimum tmp disk space required per node"
    )
    model89: OpenapiJobInfoRespJobsItemPower = Field(
        ..., title="Openapi job info resp jobs item power"
    )
    model90: OpenapiJobInfoRespJobsItemPreemptTime = Field(
        ..., title="Time job received preemption signal (UNIX timestamp)"
    )
    model91: OpenapiJobInfoRespJobsItemPreemptableTime = Field(
        ..., title="Time job becomes eligible for preemption (UNIX timestamp)"
    )
    model92: OpenapiJobInfoRespJobsItemPreSusTime = Field(
        ..., title="Total run time prior to last suspend in seconds"
    )
    model93: OpenapiJobInfoRespJobsItemPriority = Field(
        ..., title="Request specific job priority"
    )
    model94: OpenapiJobInfoRespJobsItemResizeTime = Field(
        ..., title="Time of last size change (UNIX timestamp)"
    )
    model95: OpenapiJobInfoRespJobsItemSocketsPerNode = Field(
        ..., title="Number of sockets per node required"
    )
    model96: OpenapiJobInfoRespJobsItemStartTime = Field(
        ..., title="Time execution began, or is expected to begin (UNIX timestamp)"
    )
    model97: OpenapiJobInfoRespJobsItemSubmitTime = Field(
        ..., title="Time when the job was submitted (UNIX timestamp)"
    )
    model98: OpenapiJobInfoRespJobsItemSuspendTime = Field(
        ..., title="Time the job was last suspended or resumed (UNIX timestamp)"
    )
    model99: OpenapiJobInfoRespJobsItemTimeLimit = Field(
        ..., title="Maximum run time in minutes"
    )
    model100: OpenapiJobInfoRespJobsItemTimeMinimum = Field(
        ..., title="Minimum run time in minutes"
    )
    model101: OpenapiJobInfoRespJobsItemThreadsPerCore = Field(
        ..., title="Number of processor threads per CPU core required"
    )
    model102: OpenapiJobInfoRespJobsItem = Field(
        ..., title="Openapi job info resp jobs item"
    )
    model103: OpenapiJobInfoRespLastBackfill = Field(
        ..., title="Time of last backfill scheduler run (UNIX timestamp)"
    )
    model104: OpenapiJobInfoRespLastUpdate = Field(
        ..., title="Time of last job change (UNIX timestamp)"
    )
    model105: OpenapiJobInfoRespMetaPlugin = Field(
        ..., title="Openapi job info resp meta plugin"
    )
    model106: OpenapiJobInfoRespMetaClient = Field(
        ..., title="Openapi job info resp meta client"
    )
    model107: OpenapiJobInfoRespMetaSlurmVersion = Field(
        ..., title="Openapi job info resp meta slurm version"
    )
    model108: OpenapiJobInfoRespMetaSlurm = Field(
        ..., title="Openapi job info resp meta slurm"
    )
    model109: OpenapiJobInfoRespMeta = Field(..., title="Slurm meta values")
    model110: OpenapiJobInfoRespErrorsItem = Field(
        ..., title="Openapi job info resp errors item"
    )
    model111: OpenapiJobInfoRespWarningsItem = Field(
        ..., title="Openapi job info resp warnings item"
    )
    model112: OpenapiJobInfoResp = Field(..., title="Openapi job info resp")
    model113: GetResponse200SlurmJobJobid = Field(..., title="job(s) information")
    model114: GetResponseDefaultSlurmJobJobid = Field(..., title="job(s) information")
    model115: DeletePathSlurmJobJobid = Field(
        ..., title="DELETE /slurm/v0.0.41/job/{job_id}: path parameters"
    )
    model116: DeleteQuerySlurmJobJobid = Field(
        ..., title="DELETE /slurm/v0.0.41/job/{job_id}: query parameters"
    )
    model117: DeleteBodySlurmJobJobid = Field(
        ..., title="DELETE /slurm/v0.0.41/job/{job_id}: body"
    )
    model118: OpenapiRespMetaPlugin = Field(..., title="Openapi resp meta plugin")
    model119: OpenapiRespMetaClient = Field(..., title="Openapi resp meta client")
    model120: OpenapiRespMetaSlurmVersion = Field(
        ..., title="Openapi resp meta slurm version"
    )
    model121: OpenapiRespMetaSlurm = Field(..., title="Openapi resp meta slurm")
    model122: OpenapiRespMeta = Field(..., title="Slurm meta values")
    model123: OpenapiRespErrorsItem = Field(..., title="Openapi resp errors item")
    model124: OpenapiRespWarningsItem = Field(..., title="Openapi resp warnings item")
    model125: OpenapiResp = Field(..., title="Openapi resp")
    model126: DeleteResponse200SlurmJobJobid = Field(..., title="job signal result")
    model127: DeleteResponseDefaultSlurmJobJobid = Field(..., title="job signal result")
    model128: GetPathSlurmJobs = Field(
        ..., title="GET /slurm/v0.0.41/jobs: path parameters"
    )
    model129: GetQuerySlurmJobs = Field(
        ..., title="GET /slurm/v0.0.41/jobs: query parameters"
    )
    model130: GetBodySlurmJobs = Field(..., title="GET /slurm/v0.0.41/jobs: body")
    model131: GetResponse200SlurmJobs = Field(..., title="job(s) information")
    model132: GetResponseDefaultSlurmJobs = Field(..., title="job(s) information")
