> 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.

# air_sdk.endpoints.marketplace_demos

Stub file for marketplace demos endpoint type hints.

## Classes

| Name                                                                                         | Description                                             |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| [`MarketplaceDemo`](#air_sdkendpointsmarketplace_demosmarketplacedemo)                       | Marketplace demo model representing a marketplace demo. |
| [`MarketplaceDemoEndpointAPI`](#air_sdkendpointsmarketplace_demosmarketplacedemoendpointapi) | API client for marketplace demo endpoints.              |

## Module Contents

```python
class air_sdk.endpoints.marketplace_demos.MarketplaceDemo
```

**Bases**: `air_sdk.endpoints.history.HistoryModelMixin`, `air_sdk.air_model.AirModel`

Marketplace demo model representing a marketplace demo.

```python
id: str
```

Unique identifier for the marketplace demo

```python
name: str
```

Human-readable name of the marketplace demo

```python
demo: Simulation
```

Demo simulation to be used as a base for cloned simulations.

```python
created: datetime.datetime
```

Timestamp when the marketplace demo was created

```python
modified: datetime.datetime
```

Timestamp when the marketplace demo was last modified

```python
creator: str
```

The creator of the marketplace demo

```python
documentation: str | None
```

The documentation of the marketplace demo

```python
tags: list[str]
```

The tags of the marketplace demo

```python
published: bool
```

Whether the marketplace demo is published

```python
publicly_published: bool
```

Whether a published demo is publicly accessible

```python
is_owned_by_client: bool | None
```

Whether the demo is owned by the caller's org. When True,
the caller can publish or unpublish the demo. None when read from an Air
deployment that does not yet report it.

```python
preview: bool | None
```

Whether the demo is in preview mode — listed for all authenticated
users while provisioning stays restricted to the allowlisted orgs. Only
True for a published, restricted demo whose publish access record has
preview enabled. None when read from an Air deployment that does not yet
report it.

```python
access_request_status: ACCESS_REQUEST_STATUS | None
```

Status of the caller's org's access request for this
demo, or None when the org has not requested access.

```python
can_provision: bool | None
```

Whether the caller can provision a simulation from this demo.
A preview demo is listed for everyone but provisionable only by the
allowlisted orgs; when False, request access with `request_access()`.
None when read from an Air deployment that does not yet report it.

```python
demo_simulation_state: DEMO_SIMULATION_STATE
```

The state of the simulation instance associated with
this demo which acts as the template for all provisioned simulations from
this demo.

```python
expected_resource_usage: SimRequiredResources
```

Estimated resources required to provision the demo

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

The description of the demo

```python
repo: str | None
```

The repository of the marketplace demo

```python
publisher: str
```

The name of the company or organization the marketplace demo is
published under (e.g. NVIDIA, Google). A publisher must be set before the
demo can be published.

```python
icon: str | None
```

The icon of the marketplace demo

```python
publish_access_record_id: str | None
```

```python
featured: bool
```

Whether the marketplace demo is featured. Featured demos appear
before non-featured demos in the default ordering.

```python
order: int | None
```

The ordering value of the marketplace demo. Demos with a lower
`order` value appear before demos with a higher `order` value. May
be null.

```python
provision_count: int
```

Number of times a clone has been provisioned from this
marketplace demo (counted when the provision request creates the clone;
not decremented if that clone later fails to boot).

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

```python
model_api: MarketplaceDemoEndpointAPI
```

```python
update(
    *,
    name: str | dataclasses._MISSING_TYPE = ...,
    description: str | None | dataclasses._MISSING_TYPE = ...,
    documentation: str | None | dataclasses._MISSING_TYPE = ...,
    repo: str | None | dataclasses._MISSING_TYPE = ...,
    publisher: str | dataclasses._MISSING_TYPE = ...,
    tags: list[str] | dataclasses._MISSING_TYPE = ...,
    icon: str | None | dataclasses._MISSING_TYPE = ...
) -> MarketplaceDemo
```

Update the marketplace demo's properties.

**Parameters:**

* `name` – New name for the marketplace demo
* `description` – Description of the marketplace demo
* `documentation` – Documentation of the marketplace demo
* `repo` – Repository of the marketplace demo
* `publisher` – The company or organization the demo is published under (e.g. NVIDIA, Google). Required before the demo can be published.
* `tags` – Tags of the marketplace demo
* `icon` – Icon of the marketplace demo

**Returns:**

The updated MarketplaceDemo instance

**Example:**

```python
>>> marketplace_demo.update(name='New Name', description='New Desc')
>>> print(marketplace_demo.name)
```

```python
publish(
    *,
    prefer_public: bool = ...,
    allowed_orgs: list[PrimaryKey] = ...,
    justification: str = ...,
    publish_images: bool = ...,
    preview: bool = ...,
    **kwargs: Any
) -> None
```

Publish the marketplace demo.

A `publisher` must be set on the demo before it can be published.

**Parameters:**

* `prefer_public` – Whether to publish as public (`true`, default) or restricted (`false`). When `false`, supply the authoritative `allowed_orgs`.
* `allowed_orgs` – Authoritative allow-list: orgs that may use the demo when `prefer_public` is `false`. The demo owning org is always included; `[]` is valid. Privileged endpoint only — not the gated `request-publish` string hint.
* `justification` – Optional text explaining who/why to share with.
* `publish_images` – When `true`, automatically publish org-owned images referenced by the demo so they reach the same audience as the demo. When `false` (default), the request is rejected with 400 if any referenced image needs to be published to reach the demo audience.
* `preview` – When `true`, the demo is listed for all authenticated users while provisioning stays restricted to the allow-list, and previewing users may request access. Requires a restricted (non-public) outcome. Defaults to `false`.

**Example:**

```python
>>> marketplace_demo.publish()
```

```python
unpublish(**kwargs: Any) -> None
```

Immediately unpublish the marketplace demo (privileged).

This privileged action takes no request body. To submit a gated unpublish
request for review instead, use `request_unpublish`.

**Example:**

```python
>>> marketplace_demo.unpublish()
```

```python
provision(**kwargs: Any) -> Simulation
```

Provision a simulation from this marketplace demo.

**Returns:**

The newly created simulation instance.

**Example:**

```python
>>> simulation = marketplace_demo.provision()
>>> print(simulation.name)
```

```python
request_publish(
    *,
    justification: str,
    prefer_public: bool = ...,
    allowed_orgs_request_text: str = ...,
    publish_images: bool = ...,
    preview: bool = ...,
    publisher: str = ...,
    tags: list[str] = ...
) -> MarketplaceDemo
```

Submit a request to publish this marketplace demo.

A `publisher` must be set on the demo — either previously or via this
request — before the demo can be queued for publishing.

**Parameters:**

* `justification` – Required explanation for the review request and notifications.
* `prefer_public` – When true, the requester prefers a public publish. When false, the requester prefers a restricted-access publish; describe the desired allow list in `allowed_orgs_request_text`.
* `allowed_orgs_request_text` – Optional free-text description of orgs that should have access if the outcome is restricted. Not the authoritative allow list.
* `publish_images` – When `true`, automatically publish org-owned images referenced by the demo so they reach the same audience as the demo. When `false` (default), the request is rejected with 400 if any referenced image needs to be published to reach the demo audience.
* `preview` – When `true`, the demo is listed for all authenticated users while provisioning stays restricted to the allow-list, and previewing users may request access. Requires a restricted (non-public) outcome. Defaults to `false`.
* `publisher` – Optional publisher name to set on the demo when submitting the request (e.g. NVIDIA, Google). Omitting the field leaves the existing `publisher` unchanged.
* `tags` – Optional tag names to assign to the demo when submitting the request (same rules as demo update). Omitting the field leaves the demo's existing tags unchanged; an empty list clears them.

**Returns:**

the marketplace demo instance with updated publish_access_record_id

**Example:**

```python
>>> marketplace_demo.request_publish(justification='Ready for community use')
```

```python
request_unpublish(
    *,
    justification: str
) -> MarketplaceDemo
```

Submit a request to unpublish this marketplace demo.

**Parameters:**

* `justification` – Required explanation for the review request and notifications.

**Returns:**

the marketplace demo instance

**Example:**

```python
>>> marketplace_demo.request_unpublish(justification='No longer maintained')
```

```python
request_public(
    *,
    prefer_public: bool,
    justification: str,
    publish_images: bool = ...,
    preview: bool = ...
) -> MarketplaceDemo
```

Submit a request to change marketplace demo visibility to public or restricted.

**Parameters:**

* `prefer_public` – When true, request catalog-wide visibility. When false, request restricted visibility.
* `justification` – Required explanation for the review request and notifications.
* `publish_images` – When `true`, automatically publish org-owned images referenced by the demo so they reach the same audience as the demo. When `false` (default), the request is rejected with 400 if any referenced image needs to be published to reach the demo audience.
* `preview` – When `true`, the demo is listed for all authenticated users while provisioning stays restricted to the allow-list, and previewing users may request access. Requires a restricted (non-public) outcome. Defaults to `false`.

**Returns:**

the marketplace demo instance

**Example:**

```python
>>> marketplace_demo.request_public(
...     prefer_public=True,
...     justification='Open source',
...     publish_images=True,
... )
```

```python
request_allowlist_change(
    *,
    justification: str,
    allowed_orgs_request_text: str,
    publish_images: bool = ...,
    preview: bool = ...
) -> MarketplaceDemo
```

Submit a request to change the allowlist for this marketplace demo.

**Parameters:**

* `justification` – Required explanation for the review request and notifications.
* `allowed_orgs_request_text` – Required description of the allow-list change (e.g. org names or IDs).
* `publish_images` – When `true`, automatically publish org-owned images referenced by the demo so they reach the same audience as the demo. When `false` (default), the request is rejected with 400 if any referenced image needs to be published to reach the demo audience.
* `preview` – When `true`, the demo is listed for all authenticated users while provisioning stays restricted to the allow-list, and previewing users may request access. Requires a restricted (non-public) outcome. Defaults to `false`.

**Returns:**

the marketplace demo instance

**Example:**

```python
>>> marketplace_demo.request_allowlist_change(
...     justification='Add partner orgs',
...     allowed_orgs_request_text='org-a, org-b',
... )
```

```python
cancel_publish_access_record(**kwargs: Any) -> MarketplaceDemo
```

Cancel the active publish access record for this marketplace demo.

**Returns:**

the marketplace demo instance

**Example:**

```python
>>> marketplace_demo.cancel_publish_access_record()
```

```python
request_access(
    *,
    company_name: str,
    justification: str = ...,
    **kwargs: Any
) -> MarketplaceDemoAccessRequest
```

Request access to this preview marketplace demo for your org.

See `request_access`.

**Parameters:**

* `company_name` – Required free-text company name for the requester. Not derived from your Air organization.
* `justification` – Optional explanation of why access is needed.

**Returns:**

your org's access request for this demo

**Example:**

```python
>>> marketplace_demo.request_access(
...     company_name='Acme Corp',
...     justification='Evaluating for a customer deployment',
... )
```

```python
get_access_request(**kwargs: Any) -> MarketplaceDemoAccessRequest
```

Retrieve your org's access request for this marketplace demo.

See `get_access_request`.

**Returns:**

your org's access request for this demo

**Example:**

```python
>>> access_request = marketplace_demo.get_access_request()
>>> print(access_request.status)
```

```python
manage(
    *,
    featured: bool = ...,
    order: int | None = ...,
    **kwargs: Any
) -> MarketplaceDemo
```

Adjust how this marketplace demo is featured and ordered.

Privileged action (SRE/ADMIN). See
`manage`.

**Parameters:**

* `featured` – Whether the demo is featured. Featured demos appear before non-featured demos in the default ordering.
* `order` – The ordering value of the demo. Demos with a lower `order` value appear before demos with a higher `order` value. Pass `None` to clear the demo's order.

**Returns:**

the updated marketplace demo instance

**Example:**

```python
>>> marketplace_demo.manage(featured=True, order=1)
```

```python
class air_sdk.endpoints.marketplace_demos.MarketplaceDemoEndpointAPI
```

**Bases**: `air_sdk.air_model.BaseEndpointAPI[air_sdk.endpoints.marketplace_demos.MarketplaceDemo]`

API client for marketplace demo endpoints.

```python
API_PATH: str
```

```python
API_PUBLISH_PATH: str
```

```python
API_UNPUBLISH_PATH: str
```

```python
API_PROVISION_PATH: str
```

```python
API_REQUEST_PUBLISH_PATH: str
```

```python
API_REQUEST_UNPUBLISH_PATH: str
```

```python
API_REQUEST_PUBLIC_PATH: str
```

```python
API_REQUEST_ALLOWLIST_CHANGE_PATH: str
```

```python
API_CANCEL_PUBLISH_ACCESS_RECORD_PATH: str
```

```python
API_REQUEST_ACCESS_PATH: str
```

```python
API_ACCESS_REQUEST_PATH: str
```

```python
API_MANAGE_PATH: str
```

```python
API_TIGHTEN_ORDER_PATH: str
```

```python
model: type[MarketplaceDemo]
```

```python
create(
    *,
    name: str,
    simulation: str,
    description: str | None | dataclasses._MISSING_TYPE = ...,
    documentation: str | None | dataclasses._MISSING_TYPE = ...,
    repo: str | None | dataclasses._MISSING_TYPE = ...,
    publisher: str | dataclasses._MISSING_TYPE = ...,
    tags: list[str] | dataclasses._MISSING_TYPE = ...,
    icon: str | None | dataclasses._MISSING_TYPE = ...,
    checkpoint: str | None | dataclasses._MISSING_TYPE = ...
) -> MarketplaceDemo
```

Create a new marketplace demo.

**Parameters:**

* `name` – Name for the new marketplace demo
* `simulation` – Simulation to be used to provision the marketplace demo
* `description` – Description of the marketplace demo
* `documentation` – Documentation of the marketplace demo
* `repo` – Repository of the marketplace demo
* `publisher` – The company or organization the demo is published under (e.g. NVIDIA, Google). Required before the demo can be published.
* `tags` – Tags of the marketplace demo
* `icon` – Icon of the marketplace demo
* `checkpoint` – A COMPLETE checkpoint to clone from. Provided checkpoint must belong to the simulation. If not specified, latest COMPLETE checkpoint will be used.

**Returns:**

The created MarketplaceDemo instance

**Example:**

```python
>>> marketplace_demo = api.marketplace_demos.create(
...     name='My Marketplace Demo',
...     simulation='sim-id',
...     description='My Demo Description',
...     documentation='My Demo Documentation',
...     repo='My Demo Repo',
...     tags=['networking', 'sonic'],
... )
```

```python
delete(pk: PrimaryKey) -> None
```

Delete a marketplace demo.

**Parameters:**

* `pk` – The marketplace demo ID (string or UUID)

**Example:**

```python
>>> api.marketplace_demos.delete('marketplace-demo-id')
```

```python
list(
    *,
    demo_simulation_state: DEMO_SIMULATION_STATE | dataclasses._MISSING_TYPE = ...,
    creator: str | dataclasses._MISSING_TYPE = ...,
    tags: list[str] | dataclasses._MISSING_TYPE = ...,
    published: bool | dataclasses._MISSING_TYPE = ...,
    publicly_published: bool | dataclasses._MISSING_TYPE = ...,
    is_owned_by_client: bool | dataclasses._MISSING_TYPE = ...,
    featured: bool | dataclasses._MISSING_TYPE = ...,
    publisher: str | dataclasses._MISSING_TYPE = ...,
    search: str | dataclasses._MISSING_TYPE = ...,
    ordering: str | dataclasses._MISSING_TYPE = ...,
    limit: int | dataclasses._MISSING_TYPE = ...,
    offset: int | dataclasses._MISSING_TYPE = ...
) -> Iterator[MarketplaceDemo]
```

List all marketplace demos.

Optional parameters:
demo_simulation_state: Filter by the state of the template simulation
creator: Filter by creator email
tags: Filter by tags (matched case-insensitively)
published: Filter by published status (true or false)
publicly_published: Filter by publicly published status (true or false)
is_owned_by_client: Filter by whether your org owns the demo (true or
false)
featured: Filter by whether the demo is featured (true or false). Featured
demos are listed before non-featured demos in the default ordering.
publisher: Filter by the company or organization the demo is published
under (e.g. NVIDIA). Matched case-insensitively.
search: Search term to filter demos
ordering: Order the response by the specified field
limit: Number of results to return per page
offset: The initial index from which to return the results

**Returns:**

Iterator of MarketplaceDemo instances

**Example:**

```python
>>> # List all demos
>>> for demo in api.marketplace_demos.list():
...     print(demo.name)
>>> # List with filters
>>> results = list(
...     api.marketplace_demos.list(
...         creator='test@example.com',
...         published=True,
...         tags=['networking'],
...     )
... )
```

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

Get a specific marketplace demo by ID.

**Parameters:**

* `pk` – The marketplace demo ID (string or UUID)

**Returns:**

The MarketplaceDemo instance

**Example:**

```python
>>> marketplace_demo = api.marketplace_demos.get('marketplace-demo-id')
>>> print(marketplace_demo.name)
```

```python
publish(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    prefer_public: bool = ...,
    allowed_orgs: List[PrimaryKey] = ...,
    justification: str = ...,
    publish_images: bool = ...,
    preview: bool = ...,
    **kwargs: Any
) -> None
```

Publish a marketplace demo.

A `publisher` must be set on the demo before it can be published.

**Parameters:**

* `marketplace_demo` – The marketplace demo to publish (object or ID)
* `prefer_public` – Whether to publish as public (`true`, default) or restricted (`false`). When `false`, supply the authoritative `allowed_orgs`.
* `allowed_orgs` – Authoritative allow-list: orgs that may use the demo when `prefer_public` is `false`. The demo owning org is always included; `[]` is valid. Privileged endpoint only — not the gated `request-publish` string hint.
* `justification` – Optional text explaining who/why to share with.
* `publish_images` – When `true`, automatically publish org-owned images referenced by the demo so they reach the same audience as the demo. When `false` (default), the request is rejected with 400 if any referenced image needs to be published to reach the demo audience.
* `preview` – When `true`, the demo is listed for all authenticated users while provisioning stays restricted to the allow-list, and previewing users may request access. Requires a restricted (non-public) outcome. Defaults to `false`.

**Returns:**

None

**Example:**

```python
>>> # Using demo object
>>> api.marketplace_demos.publish(marketplace_demo=marketplace_demo)
>>> # Or using ID
>>> api.marketplace_demos.publish(marketplace_demo='marketplace-demo-id')
```

```python
unpublish(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    **kwargs: Any
) -> None
```

Unpublish a marketplace demo.

**Parameters:**

* `marketplace_demo` – The marketplace demo to unpublish (object or ID)

**Returns:**

None

**Example:**

```python
>>> api.marketplace_demos.unpublish(marketplace_demo=marketplace_demo)
```

```python
provision(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    **kwargs: Any
) -> Simulation
```

Provision a simulation from a marketplace demo.

Creates a new simulation by cloning the demo simulation. Check the demo's
`can_provision` first: a restricted or preview demo can only be provisioned
by the allowlisted orgs, and the API rejects everyone else with a 403.

**Parameters:**

* `marketplace_demo` – The marketplace demo to provision (object or ID)

**Returns:**

The newly created simulation instance.

**Example:**

```python
>>> # Using demo object
>>> marketplace_demo = api.marketplace_demos.get('marketplace-demo-id')
>>> simulation = marketplace_demo.provision()
>>> print(simulation.id)
>>> # Or using API directly with ID
>>> demo_id = 'marketplace-demo-id'
>>> simulation = api.marketplace_demos.provision(marketplace_demo=demo_id)
>>> print(simulation.name)
```

```python
request_publish(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    justification: str,
    prefer_public: bool = ...,
    allowed_orgs_request_text: str = ...,
    publish_images: bool = ...,
    preview: bool = ...,
    publisher: str = ...,
    tags: List[str] = ...
) -> MarketplaceDemo
```

Submit a request to publish a marketplace demo.

A `publisher` must be set on the demo — either previously or via this
request — before the demo can be queued for publishing.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to request publication for
(MarketplaceDemo instance or marketplace demo ID)
justification: Required explanation for the review request and
notifications.

Optional parameters:
prefer_public: When true, the requester prefers a public publish. When
false, the requester prefers a restricted-access publish; describe the
desired allow list in `allowed_orgs_request_text`.
allowed_orgs_request_text: Optional free-text description of orgs that
should have access if the outcome is restricted. Not the authoritative
allow list.
publish_images: When `true`, automatically publish org-owned images
referenced by the demo so they reach the same audience as the demo.
When `false` (default), the request is rejected with 400 if any
referenced image needs to be published to reach the demo audience.
preview: When `true`, the demo is listed for all authenticated users
while provisioning stays restricted to the allow-list, and previewing
users may request access. Requires a restricted (non-public) outcome.
Defaults to `false`.
publisher: Optional publisher name to set on the demo when submitting
the request (e.g. NVIDIA, Google). Omitting the field leaves the
existing `publisher` unchanged.
tags: Optional tag names to assign to the demo when submitting the
request (same rules as demo update). Omitting the field leaves the
demo's existing tags unchanged; an empty list clears them.

**Returns:**

MarketplaceDemo: the marketplace demo instance with updated
publish_access_record_id

**Example:**

```python
>>> api.marketplace_demos.request_publish(
...     marketplace_demo=marketplace_demo,
...     justification='Ready',
... )
```

```python
request_unpublish(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    justification: str
) -> MarketplaceDemo
```

Submit a request to unpublish a marketplace demo.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to request unpublication for
(MarketplaceDemo instance or marketplace demo ID)
justification: Required explanation for the review request and
notifications.

**Returns:**

MarketplaceDemo: the marketplace demo instance

**Example:**

```python
>>> api.marketplace_demos.request_unpublish(
...     marketplace_demo=marketplace_demo,
...     justification='Deprecated',
... )
```

```python
request_public(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    prefer_public: bool,
    justification: str,
    publish_images: bool = ...,
    preview: bool = ...
) -> MarketplaceDemo
```

Submit a request to change marketplace demo visibility to public or restricted.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to update (MarketplaceDemo instance or
marketplace demo ID)
prefer_public: When true, request catalog-wide visibility. When false,
request restricted visibility.
justification: Required explanation for the review request and
notifications.

Optional parameters:
publish_images: When `true`, automatically publish org-owned images
referenced by the demo so they reach the same audience as the demo.
When `false` (default), the request is rejected with 400 if any
referenced image needs to be published to reach the demo audience.
preview: When `true`, the demo is listed for all authenticated users
while provisioning stays restricted to the allow-list, and previewing
users may request access. Requires a restricted (non-public) outcome.
Defaults to `false`.

**Returns:**

MarketplaceDemo: the marketplace demo instance

**Example:**

```python
>>> api.marketplace_demos.request_public(
...     marketplace_demo=marketplace_demo,
...     prefer_public=True,
...     justification='Open source',
... )
```

```python
request_allowlist_change(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    justification: str,
    allowed_orgs_request_text: str,
    publish_images: bool = ...,
    preview: bool = ...
) -> MarketplaceDemo
```

Submit a request to change the allowlist for a marketplace demo.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to update (MarketplaceDemo instance or
marketplace demo ID)
justification: Required explanation for the review request and
notifications.
allowed_orgs_request_text: Required description of the allow-list change
(e.g. org names or IDs).

Optional parameters:
publish_images: When `true`, automatically publish org-owned images
referenced by the demo so they reach the same audience as the demo.
When `false` (default), the request is rejected with 400 if any
referenced image needs to be published to reach the demo audience.
preview: When `true`, the demo is listed for all authenticated users
while provisioning stays restricted to the allow-list, and previewing
users may request access. Requires a restricted (non-public) outcome.
Defaults to `false`.

**Returns:**

MarketplaceDemo: the marketplace demo instance

**Example:**

```python
>>> api.marketplace_demos.request_allowlist_change(
...     marketplace_demo=marketplace_demo,
...     justification='Add partner orgs',
...     allowed_orgs_request_text='org-a, org-b',
... )
```

```python
cancel_publish_access_record(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey
) -> MarketplaceDemo
```

Cancel the active publish access record for a marketplace demo.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to cancel the record for (MarketplaceDemo
instance or marketplace demo ID)

**Returns:**

MarketplaceDemo: the marketplace demo instance

**Example:**

```python
>>> api.marketplace_demos.cancel_publish_access_record(
...     marketplace_demo=marketplace_demo,
... )
```

```python
request_access(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    company_name: str,
    justification: str = ...,
    **kwargs: Any
) -> MarketplaceDemoAccessRequest
```

Request access to a preview marketplace demo on behalf of your org.

A preview demo is visible to every authenticated user but can only be
provisioned by the orgs on its allow-list. Requesting access queues your org
for an admin to accept or deny. Re-requesting updates your org's existing
request rather than creating another, appending the new `justification`
while the request is still open.

Raises `AirUnexpectedResponse` when the demo is not preview-restricted,
when your org owns it, when your org is already allow-listed, or when the
demo is not visible in the catalog.

**Parameters:**

* `marketplace_demo` – Marketplace demo to request access to (MarketplaceDemo instance or marketplace demo ID)
* `company_name` – Required free-text company name for the requester. Not derived from your Air organization.
* `justification` – Optional explanation of why access is needed.
* `**kwargs` – Additional parameters

**Returns:**

your org's access request for this demo

**Example:**

```python
>>> api.marketplace_demos.request_access(
...     marketplace_demo=marketplace_demo,
...     company_name='Acme Corp',
...     justification='Evaluating for a customer deployment',
... )
```

```python
get_access_request(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    **kwargs: Any
) -> MarketplaceDemoAccessRequest
```

Retrieve your org's access request for a marketplace demo.

Always scoped to the calling org, including for admins. Raises
`AirUnexpectedResponse` when the demo is not visible or your org has not
requested access. Use `api.marketplace_demo_access_requests.list()` to
review requests raised by other orgs.

**Parameters:**

* `marketplace_demo` – Marketplace demo to read the access request for (MarketplaceDemo instance or marketplace demo ID)
* `**kwargs` – Additional query parameters

**Returns:**

your org's access request for this demo

**Example:**

```python
>>> access_request = api.marketplace_demos.get_access_request(
...     marketplace_demo=marketplace_demo,
... )
>>> print(access_request.status)
```

```python
manage(
    *,
    marketplace_demo: MarketplaceDemo | PrimaryKey,
    featured: bool = ...,
    order: int | None = ...,
    **kwargs: Any
) -> MarketplaceDemo
```

Adjust how a marketplace demo is featured and ordered.

Privileged action (SRE/ADMIN). Featured demos appear before non-featured
demos in the default ordering, and demos with a lower `order` value
appear before demos with a higher `order` value.

**Args:**

Required parameters:
marketplace_demo: Marketplace demo to manage (MarketplaceDemo instance
or marketplace demo ID)

Optional parameters:
featured: Whether the demo is featured.
order: The ordering value of the demo. Pass `None` to clear the
demo's order.

**Returns:**

MarketplaceDemo: the updated marketplace demo instance

**Example:**

```python
>>> api.marketplace_demos.manage(
...     marketplace_demo=marketplace_demo,
...     featured=True,
...     order=1,
... )
```

```python
tighten_order(**kwargs: Any) -> None
```

Re-number marketplace demo `order` values to be consecutive from 1.

Privileged action (SRE/ADMIN). Re-numbers the populated `order` values
of marketplace demos so that they are consecutive starting at 1,
preserving their relative ordering. For example, demos with
`order=[1, 5, 20]` become `[1, 2, 3]`. Demos with `order=None` are
left untouched.

**Returns:**

None

**Example:**

```python
>>> api.marketplace_demos.tighten_order()
```