> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/dsx-air/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/dsx-air/_mcp/server.

# air_sdk.endpoints.manifests

Stub file for manifests endpoint type hints.

## Classes

| Name                                                                   | Description                                                     |
| ---------------------------------------------------------------------- | --------------------------------------------------------------- |
| [`Manifest`](#air_sdkendpointsmanifestsmanifest)                       | Manifest model representing a simulator/platform configuration. |
| [`ManifestEndpointAPI`](#air_sdkendpointsmanifestsmanifestendpointapi) | API client for manifest endpoints.                              |

## Module Contents

```python
class air_sdk.endpoints.manifests.Manifest
```

**Bases**: `air_sdk.bc.BaseCompatMixin`, `air_sdk.bc.manifests.ManifestCompatMixin`, `air_sdk.air_model.AirModel`

Manifest model representing a simulator/platform configuration.

Manifests define how a specific network device or platform should be
emulated, including resource requirements, docker parameters, and
platform capabilities.

```python
id: str
```

Unique identifier for the manifest (required)

```python
org_name: str
```

Organization name that owns this manifest (read-only, set by API)

```python
docker_run_parameters: dict[str, Any]
```

Docker container runtime parameters (required)

```python
emulation_type: str
```

Type of emulation (required)

```python
platform_information: dict[str, Any]
```

Dictionary of platform configurations (required)

```python
simulator_image: Image
```

Docker image used for the simulator (required)

```python
simulator_resources: dict[str, Any]
```

Resource requirements for the simulator (required)

```python
description: str | None
```

Manifest description (optional)

```python
artifacts_directory: str | None
```

Directory path for simulator artifacts (optional)

```python
artifacts_directory_max_size_gb: int | None
```

Maximum size for artifacts dir in GB (optional)

```python
boot_group: int | None
```

Boot group number for startup ordering (optional)

```python
configure_node_properties: dict[str, Any] | None
```

Node configuration properties (optional)

```python
configure_simulator: dict[str, Any] | None
```

Simulator configuration parameters (optional)

```python
simulation_engine_versions: list[str] | None
```

List of supported sim engine versions (optional)

```python
emulation_params: dict[str, Any] | None
```

Emulation-specific parameters (optional)

```python
port_mapping_required: bool | None
```

Whether port mapping is required (optional, read-only)

```python
get_model_api() -> type[ManifestEndpointAPI]
```

Returns the respective `AirModelAPI` type for this model.

**Returns:**

ManifestEndpointAPI class

```python
model_api: ManifestEndpointAPI
```

The current model API instance.

**Returns:**

ManifestEndpointAPI instance

```python
update(
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any] = ...,
    emulation_type: str = ...,
    platform_information: dict[str, Platform | dict[str, Any]] = ...,
    simulator_image: Image | str = ...,
    simulator_resources: Resources | dict[str, Any] = ...,
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: list[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...
) -> None
```

Update the manifest's properties.

**Parameters:**

* `docker_run_parameters` – Docker runtime parameters
* `emulation_type` – Type of emulation
* `platform_information` – Platform configurations
* `simulator_image` – Docker image for the simulator
* `simulator_resources` – Resource requirements
* `description` – Manifest description
* `artifacts_directory` – Directory path for simulator artifacts
* `artifacts_directory_max_size_gb` – Max size for artifacts dir
* `boot_group` – Boot group number
* `configure_node_properties` – Node configuration properties
* `configure_simulator` – Simulator configuration
* `simulation_engine_versions` – Supported engine versions
* `emulation_params` – Emulation parameters

**Example:**

```python
>>> manifest.update(boot_group=2)
>>> manifest.update(description='Updated manifest')
```

```python
delete() -> None
```

Delete this manifest.

**Example:**

```python
>>> manifest = api.manifests.get('manifest-id-123')
>>> manifest.delete()
```

```python
class air_sdk.endpoints.manifests.ManifestEndpointAPI
```

**Bases**: `air_sdk.air_model.BaseEndpointAPI[air_sdk.endpoints.manifests.Manifest]`

API client for manifest endpoints.

```python
API_PATH: str
```

```python
model: type[Manifest]
```

```python
list(
    *,
    simulator_image: Image | str = ...,
    emulation_type: str = ...,
    limit: int = ...,
    offset: int = ...,
    ordering: str = ...,
    search: str = ...,
    **params: Any
) -> Iterator[Manifest]
```

List all manifests with optional filtering.

**Parameters:**

* `simulator_image` – Filter by simulator image (Image or image ID)
* `emulation_type` – Filter by emulation type
* `limit` – Number of results to return per page
* `offset` – The initial index from which to return the results
* `ordering` – Order objects by field. Prefix with "-" for desc order
* `search` – Search term to filter manifests
* `**params` – Additional query parameters

**Returns:**

Iterator of Manifest instances

**Example:**

```python
>>> # List all manifests
>>> for manifest in api.manifests.list():
...     print(manifest.emulation_type)

>>> # Filter by emulation type
>>> for manifest in api.manifests.list(emulation_type='NIC_INFINIBAND'):
...     print(manifest.org_name)

>>> # Filter by simulator image
>>> for manifest in api.manifests.list(simulator_image='image-id'):
...     print(manifest.id)

>>> # Search and order
>>> for manifest in api.manifests.list(search='cumulus', ordering='-created'):
...     print(manifest.id)
```

```python
create(
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any],
    emulation_type: str,
    platform_information: dict[str, Platform | dict[str, Any]],
    simulator_image: Image | str,
    simulator_resources: Resources | dict[str, Any],
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: List[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...,
    **kwargs: Any
) -> Manifest
```

Create a new manifest.

Note: org\_name is automatically determined by API and cannot be specified.

**Parameters:**

* `docker_run_parameters` – Docker runtime parameters (required)
* `emulation_type` – Type of emulation (required)
* `platform_information` – Platform configurations (required)
* `simulator_image` – Docker image for the simulator - Image obj or ID (required)
* `simulator_resources` – Resource requirements (required)
* `description` – Manifest description (optional)
* `artifacts_directory` – Directory path for simulator artifacts (optional)
* `artifacts_directory_max_size_gb` – Max size for artifacts dir (optional)
* `boot_group` – Boot group number (optional)
* `configure_node_properties` – Node configuration properties (optional)
* `configure_simulator` – Simulator configuration (optional)
* `simulation_engine_versions` – Supported engine versions (optional)
* `emulation_params` – Emulation parameters (optional)
* `**kwargs` – Additional fields

**Returns:**

The created Manifest instance

**Example:**

```python
>>> manifest = api.manifests.create(
...     artifacts_directory='/artifacts',
...     artifacts_directory_max_size_gb=10,
...     boot_group=1,
...     configure_node_properties={},
...     configure_simulator={},
...     docker_run_parameters={
...         'tmpfs': [],
...         'cap_add': ['NET_ADMIN'],
...         'devices': ['/dev/kvm'],
...         'volumes': [],
...         'environment': {},
...     },
...     emulation_type='NIC_INFINIBAND',
...     platform_information={},
...     simulation_engine_versions=['1.0'],
...     simulator_image='image-id',
...     simulator_resources={'cpu': 2.0, 'memory': 4096},
...     emulation_params={
...         'direct_link_emulation': True,
...         'max_network_pci': 8,
...     },
... )
```

```python
get(pk: PrimaryKey) -> Manifest
```

Get a specific manifest by ID.

**Parameters:**

* `pk` – The manifest ID (string or UUID)

**Returns:**

The Manifest instance

**Example:**

```python
>>> manifest = api.manifests.get('manifest-id-123')
>>> print(manifest.emulation_type)
```

```python
patch(
    pk: PrimaryKey,
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any] = ...,
    emulation_type: str = ...,
    platform_information: dict[str, Platform | dict[str, Any]] = ...,
    simulator_image: Image | str = ...,
    simulator_resources: Resources | dict[str, Any] = ...,
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: List[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...,
    **kwargs: Any
) -> Manifest
```

Update a manifest's properties.

**Parameters:**

* `pk` – The manifest ID (string or UUID)
* `docker_run_parameters` – Docker runtime parameters
* `emulation_type` – Type of emulation
* `platform_information` – Platform configurations
* `simulator_image` – Docker image for the simulator
* `simulator_resources` – Resource requirements
* `description` – Manifest description
* `artifacts_directory` – Directory path for simulator artifacts
* `artifacts_directory_max_size_gb` – Max size for artifacts dir
* `boot_group` – Boot group number
* `configure_node_properties` – Node configuration properties
* `configure_simulator` – Simulator configuration
* `simulation_engine_versions` – Supported engine versions
* `emulation_params` – Emulation parameters
* `**kwargs` – Additional fields to update

**Returns:**

The updated Manifest instance

**Example:**

```python
>>> updated_manifest = api.manifests.patch(
...     pk='manifest-id-123',
...     boot_group=2,
... )
```

```python
delete(
    pk: PrimaryKey,
    **kwargs: Any
) -> None
```

Delete a manifest.

**Parameters:**

* `pk` – The manifest ID (string or UUID) to delete
* `**kwargs` – Additional parameters

**Example:**

```python
>>> api.manifests.delete('manifest-id-123')
```