openapi: 3.0.0
servers:
  - url: https://containers-api.ng.bluemix.net/v3
info:
  description: |-
    Containers are virtual software objects that include all the elements that an app needs to run. A container has the benefits of resource isolation and allocation but is more portable and efficient than, for example, a virtual machine.

     This documentation describes the IBM Containers API, which is based on the Docker Remote API. The API provides endpoints that you can use to create and manage your single containers and container groups in Bluemix. Endpoints are summarized under the following tags: 

    - **Authentication**: Retrieve and refresh your TLS certificates. 
    - **Private Docker images registry**: Create your own private Docker images registry in Bluemix by setting a namespace for your organization. 
    - **Images**: View, build, and push your images to your private Bluemix registry so you can use them with IBM Containers. You can also scan your container images with the Vulnerability Advisor against standard policies set by the organization manager and a database of known Ubuntu issues. 
    - **Single Containers**: Create and manage single containers in Bluemix. Use a single container to implement short-lived processes or to run simple tests as you develop an app or service. To make your single container available from the internet, review the `Public IP addresses` endpoints. 
    - **Container Groups**: Create and manage your container groups in Bluemix. A container group consists of multiple single containers that are all created from the same container image and as a consequence are configured in the same way. Container groups offer further options at no cost to make your app highly available. These options include in-built load balancing, auto-recovery of unhealthy container instances, and auto-scaling of container instances based on CPU and memory usage. Map a public route to your container group to make your app accessible from the internet.  
    - **Public IP addresses**: Use these endpoints to request public IP addresses for your space. You can bind this IP address to your container to make your container accessible from the internet. 
    - **File shares**: Create, list and delete file shares in a space. A file share is a NFS storage system that hosts Docker volumes.  
    - **Volumes**: Create and manage container volumes in your space to persist the data of your containers.  


     Each API request requires an HTTP header that includes the 'X-Auth-Token’ and 'X-Auth-Project-Id’ parameter. 

    - **X-Auth-Token**: The JSON web token (JWT) that you receive when logging into the Bluemix platform. It allows you to use the IBM Containers REST API, access services, and resources. Run `cf oauth-token` to retrieve your access token information.
    - **X-Auth-Project-Id**: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.


     For further information about how containers work in the IBM Containers service, review the documentation under https://new-console.ng.bluemix.net/docs/containers/container_index.html. 
  license:
    name: (C) Copyright IBM Corp. 2016 All Rights Reserved.
  title: IBM Containers API
  version: 3.0.0
  x-apisguru-categories:
    - developer_tools
  x-logo:
    url: https://twitter.com/IBMCloud/profile_image?size=original
  x-origin:
    - format: openapi
      url: http://ccsapi-doc.mybluemix.net/swagger.json
      version: "3.0"
  x-providerName: bluemix.net
  x-serviceName: containers
paths:
  /build:
    post:
      description: |-
        This API builds a new container image from a Dockerfile that is stored on your local machine and pushes the image to the private Bluemix registry (corresponding IBM Containers command: `cf ic build`).

         To push an image to your Bluemix registry, a namespace must be set for the organization. Run `cf ic namespace get` or call the `GET /registry/namespaces` API to check if a namespace is already set. If not, run `cf ic namespace set NAMESPACE` or call the `PUT /registry/namespaces/{namespace}` API to set a namespace for your organization.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: "Tag the image with the full path to your private Bluemix registry in the following format: `t=registry.ng.bluemix.net/<namespace>/<image_name>:<tag>`. This path is used to push the image to the private Bluemix registry after it is built."
          in: query
          name: t
          required: true
          schema:
            type: string
        - description: You can choose whether or not to show the verbose build output to review every step during the container image build. If you set the query parameter to `q=false`, `q=False`, or `q=0`, the verbose build output is suppressed. To show the verbose build output, enter `q=true`, `q=True`, or `q=1`.
          in: query
          name: q
          required: false
          schema:
            type: boolean
        - description: If you set the query parameter to `nocache=true`, `nocache=True`, or `nocache=1`, the cache will not be used to build your image. To use the cache, enter `nocache=false`, `nocache=False`, or `nocache=0`.
          in: query
          name: nocache
          required: false
          schema:
            type: boolean
        - description: If set to pull=true, pull=True, or pull=1, then a newer version of the image is always attempted to be pulled even though an older version of the image exists locally. If set to pull=false, pull=False, or pull=0, then the local image will be used if one exists.
          in: query
          name: pull
          required: false
          schema:
            type: boolean
      requestBody:
        content:
          application/tar:
            schema:
              format: binary
              type: string
        description: Must be the content of a tar archive compressed with gzip. The archive must include a file called 'Dockerfile' at its root. It may include any number of other files which will be accessible in the build context.
        required: true
      responses:
        "200":
          description: OK. The container image was built successfully and pushed to your private Bluemix repository. The build output stream is returned in JSON format.
        "400":
          description: Bad request. Your could not be processed. Be sure to include the `t` query parameter to tag your image and that your Dockerfile has been tar archived with gzip.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Build a Docker image from a Dockerfile
      tags:
        - Images
  /containers/create:
    post:
      description: |-
        This endpoint creates and starts a single container in your space based on the Docker image that is specified in the Image field of the request json. A single container in IBM Containers is similar to a container that you create in your local Docker environment. Single containers are a good way to start with IBM Containers and to learn about how containers work in the IBM Cloud and the features that IBM Containers provides. They are also recommended when you want to run simple app tests or during the development process of an app. 

         In the Docker API there are two separate APIs to create and start a container. However in IBM Containers a container is created and started in a single API call. Therefore, this API merges parameters from the Docker API to create and start container. 

         To create a container with IBM Containers, you must at least define the image that the container is based on.

        - Image: You must include the full path to the image in your private Bluemix registry in the format: `registry.ng.bluemix.net/<namespace>/<image>`.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: Choose a name for your container. The characters in the name can include uppercase letters, lowercase letters, numbers, periods (.), underscores (_), or hyphens (-), but the name must start with a letter.
          in: query
          name: name
          required: false
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/CreateContainer"
        description: Summary of input parameter to create a container in IBM Containers.
        required: true
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainerId"
          description: OK. The creation of a single container with the specified attributes has been initiated.
        "400":
          description: Bad request. The data that you entered in the request body are either incomplete or in the wrong format. Be sure to include at least the Docker image that you want to use in JSON format and re-run the API request.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "409":
          description: " Conflict. A container with the same name already exists. Choose another name for your container and re-run the API request."
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Create and start a single container
      tags:
        - Single containers
  /containers/floating-ips:
    get:
      description: "This endpoint returns a list of all public IP addresses that are allocated to a space and not bound to a container. If you want to list all public IP addresses that are allocated to a space, even those that are already bound to a container, use the `all` query parameter (corrsponding IBM Containers command: `cf ic ip list`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: If this option is set to `all=1`, `all=True`, or `all=true`, all public IP addresses that are allocated to a space are returned. If this option is set to `all=0`, `all=False`, or `all=false`, only available public IP addresses that are allocated but not bound to a container are returned. By default, only available public IP addresses are returned.
          in: query
          name: all
          required: false
          schema:
            type: boolean
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/FloatingIP"
                type: array
          description: OK. A list of public IP addresses that are allocated to the space is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List available public IP addresses in a space
      tags:
        - Public IP addresses
  /containers/floating-ips/request:
    post:
      description: "This endpoint requests a new public IP address for a space (corresponding IBM Containers command: `cf ic ip request`). The number of public IP addresses depends on the quota that is assigned to the space. If there is not enough quota left to request a new public IP address, you can either contact your organization manager to increase the quota, or unbind an existing IP address from a container by running `cf ic ip unbind <ip_adress> <container>` command, or  calling the `POST /container/{name_or_id}/floating-ips/{ip}/unbind` endpoint."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                description: New public IP address that is allocated to your space.
                type: string
          description: OK. A new public IP address is allocated to your space.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "402":
          description: Payment required. This request exceeds the quota that is allocated to the space. You can either contact your organization manager to increase the quota, or unbind an existing IP address from a container by running `cf ic ip unbind <ip_adress> <container>`, or calling the `POST /container/{name_or_id}/floating-ips/{ip}/unbind` endpoint.
        "409":
          description: Conflict. This request exceeds the quota that is allocated to the space. You can either contact your organization manager to increase the quota, or unbind an existing IP address from a container by running `cf ic ip unbind <ip_adress> <container>`, or calling the `POST /container/{name_or_id}/floating-ips/{ip}/unbind` endpoint.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Request a public IP address for a space
      tags:
        - Public IP addresses
  "/containers/floating-ips/{ip}/release":
    post:
      description: "This endpoint releases a public IP address from a space (corresponding IBM Containers command: `cf ic ip release <ip_adress>`). The public IP address is no longer allocated to the space. If a container was bound to the IP address, it is automatically unbound."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The public IP address that you want to release. Run `cf ic ip list` or call the `GET /containers/floating-ips?all=true` endpoint to review all public IP address that are allocated to your space. After a public IP address is released, it will no longer be allocated to your space.
          in: path
          name: ip
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The public IP address has been released from your space.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The public IP address that you entered, could not be found. Run `cf ic ip list`, or call the `GET /containers/floating-ips?all=true` endpoint to review your public IP addresses. Re-run the API call with the updated public IP address information.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Release public IP address
      tags:
        - Public IP addresses
  /containers/groups:
    get:
      description: "This endpoint returns a list of all container groups in a space independent of their current state. (corresponding IBM Containers command: `cf ic group list`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/ContainersGroupsGetListItem"
                type: array
          description: OK. A list of container groups is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List all container groups in a space
      tags:
        - Container Groups
    post:
      description: |-
        This endpoint creates and starts a new container group in your space. A container group consists of two or more single containers that are all created from the same container image and as a consequence are configured in the same way. Container groups offer different options at no cost to make your app highly available, such as in-built load balancing, auto-recovery of unhealthy container instances, and auto-scaling of container instances based on CPU and memory usage.

        To create a container group with IBM Containers, you must at least define a container group name and the image that the container group is based on. Required attributes:
















        - Name: The container group name must start with a letter and then can include uppercase letters, lowercase letters, numbers, periods (.), underscores (_), or hyphens (-). 
        - Image: You must include the full path to the image in your private Bluemix registry in the format:`registry.ng.bluemix.net/<namespace>/<image>`.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ContainersGroupsPostRequiredAttributes"
        description: Attributes that are required to create a container group in your space.
        required: true
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersGroupsPostCreatedInfo"
          description: Created. Your container group was successfully created.
        "400":
          description: Bad request. The information that you entered in the request body are either incomplete or in the wrong format to process your request. Be sure, to specify at least the name and container image for your container group in JSON format and re-run the REST call.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "409":
          description: Conflict. A container group with the same name already exists. Choose a new name for your container group and re-run the REST call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Create and start a container group.
      tags:
        - Container Groups
  "/containers/groups/{name_or_id}":
    delete:
      description: "Stops and deletes the container instances that run in a container group (corresponding IBM Containers command: `cf ic group rm <group_name>`). When you delete a container group, all floating private IP addresses are released."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or unique ID of the container group that you want to delete. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: "If you want to force the deletion of a container group that has running container instances, use the force option. This parameter needs to be set to either true or false. If set to `force=true`, `force=True`, or `force=1`, running container instances are deleted. If set to `force=false`, `force=False`, or `force=0`, running container instances are not deleted. If you do not specify this paramater, running container instances are not deleted by default. "
          in: query
          name: force
          required: false
          schema:
            type: string
      responses:
        "204":
          description: OK. No content. The deletion of the container group was successfully processed.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "403":
          description: The container group cannot be deleted due to running or failed container instances. Set the force query parameter to `force=true`, `force=True`, or `force=1` and re-run the REST call to force the deletion of your container group.
        "404":
          description: Not Found. The name or ID of the container group that you want to delete could not be found. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space. Enter the correct name or ID and re-run the API call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Stop and delete all container instances in a container group.
      tags:
        - Container Groups
    get:
      description: "This endpoint retrieves detailed information about a container group with a given name (corresponding IBM Containers command: `cf ic group inspect GROUP`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or unique ID of the container group that you want to inspect. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersGroupsNameOrIdGetDetails"
          description: OK. A detailed list of information about a container group is retrieved.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The specified name or ID of the container group that you want to update could not be found. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space. Enter the correct name or ID and re-run the REST call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Inspect a container group.
      tags:
        - Container Groups
    patch:
      description: |-
        Update the number of container instances that run in a container group (corresponding IBM Containers command: `cf ic group update <option> <group>`). 

        Note: You can run only one update at a time.  

         The desired number is the number of container instances that you require. It must be within the current limits of Max and Min. To increase the number of desired container instances above the Max value, you must first execute an update on the Max value. Once this update is completed, you can increase the desired number of container instances. 
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or unique ID of the container group that you want to update.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ContainersGroupsNameOrIdPatchUpdatedInfo"
        description: The container group parameter that you want to update.
        required: true
      responses:
        "204":
          description: No content. The update has successfully been processed.
        "400":
          description: Bad request. The information that you entered in the body of your request are either incomplete or in the wrong format. Be sure, to enter the information that you want to update in JSON format and review the description for each parameter to assure your desired update is valid and can be processed.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The name or ID of the container group that you want to update could not be found. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space. Enter the correct name or ID and re-run the REST call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Update a container group.
      tags:
        - Container Groups
  "/containers/groups/{name_or_id}/maproute":
    post:
      description: "If you want your container group to be accessible from the Internet, you need to expose a public port and map a public route to it (corresponding IBM Containers command: `cf ic route map -n <host> -d <domain> <group>`). Every route consists of the host name and domain."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or unique ID of the container group to which you want to map a public route. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Route"
        description: The public route that is mapped to the container group. A public route consists of the host name and domain.
        required: true
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersGroupsNameOrIdMaproutePostInfo"
          description: OK. The route that you specified was successfully mapped to the container group.
        "400":
          description: Bad request. The information that you entered in the body request is either incomplete or in the wrong format. To map a route enter the domain and host name in JSON format. Be sure, that you have exposed a public port when you created the container group, otherwise you cannot map a public route to it.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The name or ID of the container group to which you want to map a public route could not be found. Run `cf ic group list` or call the `GET /containers/groups` endpoint to retrieve a list of container groups in your space. Enter the correct name or ID and re-run the REST call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Map a public route to a container group.
      tags:
        - Container Groups
  "/containers/groups/{name_or_id}/unmaproute":
    post:
      description: |-
        This endpoint unmaps a public route from a container group (corresponding IBM Containers command: `cf ic route unmap -n <host> -d <domain> <group>`). If no other public route is mapped to the container group, then the container group is no longer available from the internet. 

         When you unmap a route from a container group, the route is not deleted and can be mapped to other container groups. 
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or unique ID (UUID) of the container group that you want to inspect.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Route"
        description: The public route that is unmapped from the container group. A public route consists of the host name and domain.
        required: true
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersGroupsNameOrIdMaproutePostInfo"
          description: OK. The route that you specified was successfully unmapped from the container group.
        "400":
          description: Bad request. The information that you entered in the body of your request is either incomplete or in the wrong format. To unmap a route, enter the domain and host name in JSON format and re-run the REST call.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The name or ID of the container group from which you want to unmap a public route could not be found. Enter the correct name or ID and re-run the REST call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Unmap a public route from a container group
      tags:
        - Container Groups
  /containers/json:
    get:
      description: "This endpoint returns a list of all single containers in a space that are currently in a running state (corresponding IBM Containers command: `cf ic ps`). To list all single containers independent of their current state, set the `all` query parameter to true."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: "By default, the `GET /containers/json` endpoint returns a list of all single containers in a space that are in a running state. To request a list of all containers independent of their current state, set the `all` query parameter to true. Allowed values are: `all=true`, `all=True`, and `all=1`. "
          in: query
          name: all
          required: false
          schema:
            type: string
        - description: You can filter your containers by any environment variable key or value that is listed in the `Env` section of your CLI/ API response when you run the `cf ic inspect <container>` command, or call the `GET /containers/{id}/json` endpoint. Your search criteria does not need to be an exact match. It can also be a part of the key or value you are looking for. For example, to filter all containers with an environment variable that contains `id` in one of their environment variables, use `filter=id`.
          in: query
          name: filters
          required: false
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/Container"
                type: array
          description: OK. A list of single containers that match the search criteria is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: List single containers in a space.
      tags:
        - Single containers
  /containers/messages:
    get:
      description: This endpoint retrieves all IBM Containers system messages for the user.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: "The unique ID of your organization space where you want to create or work with your containers. To retrieve your space ID, run `cf space <space_name> --guid` and replace `<space_name>` with the name of the space where you want to create or work with your container. "
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                properties:
                  created_date:
                    description: Timestamp when the message was created.
                    type: string
                  message:
                    description: Important information for the IBM Containers user.
                    type: string
                type: object
          description: OK. A list of messages is returned.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List messages for the user
      tags:
        - API info
  /containers/quota:
    get:
      description: Retrieve the quota that is assigned to the organization and space.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersQuotaInfo"
          description: "OK. The current quota that is assigned to the organization and space is returned. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Retrieve organization and space specific quota
      tags:
        - Quota
    put:
      description: |-
        This endpoint updates the quota that is allocated to a Bluemix space. 

         **Note**: Only paid accounts are eligbile to update the space quota. If you are using a free-trial account, upgrade to a paid account first.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ContainersQuotaList"
        description: The space quota details that you want to update.
        required: true
      responses:
        "204":
          description: "No content. The request to update the organization and/ or space quota has been processed. "
        "400":
          description: "Bad request. The "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Update space quota
      tags:
        - Quota
  /containers/usage:
    get:
      description: |-
        This endpoint returns a list of available container sizes and the quota limit and usage for the space. 

        - Container sizes: A list of available container sizes indicating the amount of container memory, disk space and virtual CPUs that can be assigned to the container.
        - Quota limit: Lists the number of containers, public IP addresses, available container memory, and virtual CPUS that are allocated to a space. 
        - Quota usage: Lists the current number of containers, images, and public IP addresses in a space that is counted towards your quota limit. 
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersUsageInfo"
          description: "OK. A list of available container sizes as well as the quota limit and usage for a space is returned. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List container sizes and quota limits
      tags:
        - Quota
  /containers/version:
    get:
      description: This endpoint retrieves a list of all microservices that are used in the IBM Containers service with their current build version. This method does not require authentication.
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainersVersionGetInfo"
          description: OK. A list of the current API and microservices versions is returend.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List latest API version
      tags:
        - API info
  "/containers/{id}/status":
    get:
      description: This endpoint returns the current state of a container. This state can either be a transient state, such as BUILDING and NETWORKING, or a non-transient state, such as RUNNING, SHUTDOWN, CRASHED, or SUSPENDED.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier that represents the container. Run `cf ic ps`, or call the `GET /containers/json` endpoint to retrieve the ID of the container.
          in: path
          name: id
          required: true
          schema:
            type: string
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/getContainerStatus"
          description: OK. The current status of a container is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container could not be found. Run `cf ic ps` or call the `GET /containers/json` endpoint to review the ID of your container.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: List the current state of a container.
      tags:
        - Single containers
  "/containers/{name_or_id}":
    delete:
      description: "Remove a single container that is identified by container ID or name from a space (corresponding IBM Containers command: `cf ic delete <container>`). The container must be stopped before it can be deleted, unless the `force` query parameter is set to true."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to delete. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review all containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: Use the `force` query parameter if you want to delete the container independent of their current state. The container does not need to be stopped first. To force the deletion of a container, enter `force=true`, `force=True`, or `force=1`. If you want to delete containers that are in a non-running state only, do either not set this query parameter, or enter `force=false`, `force=False`, or `force=0`.
          in: query
          name: force
          required: false
          schema:
            type: boolean
      responses:
        "204":
          description: No Content. The deletion of your container has been initiated.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Remove a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/floating-ips/{ip}/bind":
    post:
      description: "This endpoint binds an available public IP address to a single container (corresponding IBM Containers command: `cf ic ip bind <ip_adress> <container>`). After a container is bound to a public IP address, it can be accessed at `https://<public_ip_adress>:<public_port>`."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or ID of the container that you want to bind to the public IP address. Run the `cf ic ps` command or call the `GET /containers/json` endpoint to retrieve a list of containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: |-
            The public IP address that you want to bind to your container. 

            Note: The public IP address must be available in the space and not bound to a container. Run `cf ic ip list` or call the `GET /containers/floating-ips` endpoint.
          in: path
          name: ip
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. Your request to bind a public IP address to a container has successfully been processed.
        "304":
          description: Not modified. The container is already bound to a public IP address. To view the details of your container, run `cf ic inspect <container>` or call the `GET /containers/{name_or_id}/json endpoint.
        "400":
          description: Bad request. The IP address that you entered does not exist. Run `cf ic ip list` or call the `GET /containers/floating-ips` endpoint to retrieve a list of available public IP addresses in your space.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: "Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container. "
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Bind a public IP address to a single container
      tags:
        - Public IP addresses
  "/containers/{name_or_id}/floating-ips/{ip}/unbind":
    post:
      description: "This endpoint unbinds a public IP address from a container (corresponding IBM Containers command: `cf ic ip unbind <ip_adress> <container>`). The container that is unbound from the IP address will not be accessible from the internet anymore. The public IP address will be further allocated to the space and can be used to be bound to other containers. "
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: "The name or ID of the container that you want to bind to the public IP address. Run the `cf ic ps` command or call the `GET /containers/json` endpoint to retrieve a list of containers in your space. "
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: |-
            The public IP address that you want to unbind from your container. 

             Note: After unbinding a public IP address, this IP address will still be allocated to the space and can be used to be bound to other containers.
          in: path
          name: ip
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. Your request to unbind a public IP address from a container has successfully been processed.
        "400":
          description: Bad request. The IP address that you entered does not exist. Run `cf ic ip list` or call the `GET /containers/floating-ips` endpoint to retrieve a list of available public IP addresses in your space.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: "Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container. "
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Unbind a public IP address from a container
      tags:
        - Public IP addresses
  "/containers/{name_or_id}/json":
    get:
      description: "This endpoint retrieves detailed information about a single container (corresponding IBM Containers command: `cf ic inspect <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name or ID of the container that you want to inspect. Run the `cf ic ps` command or call the `GET /containers/json` endpoint to retrieve a list of containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContainerInfo"
          description: "OK. A list with detailed information about the container is returned. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container name or ID that you entered, could not be found. Run the `cf ic ps` command or call the `GET /containers/json` to review the name or ID of the container that you want to inspect.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Inspect a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/pause":
    post:
      description: "Pause all processes in a running single container with a given container ID or name (corresponding IBM Containers command: `cf ic pause <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to pause. Run `cf ic ps` or call the `GET /containers/json` endpoint to review all containers in your space that are currently in a running state.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The pausing of all processes inside the container has been initiated.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps` or call the `GET /containers/json` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Pause a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/rename":
    post:
      description: "Change the current name of an existing single container that is identified by the container ID or name (corresponding IBM Containers command: `cf ic rename <old_name> <new_name>`). "
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to rename. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review all containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: The new name for the container. The characters in the name can include uppercase letters, lowercase letters, numbers, periods (.), underscores (_), or hyphens (-), but the name must start with a letter.
          in: query
          name: name
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The request to rename the container has been initiated.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container.
        "409":
          description: "Conflict. A container with the same name already exists. Choose another name for your container and re-run the API call. "
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Rename a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/restart":
    post:
      description: "Restart a container with a given container ID or name (corresponding IBM Containers command: `cf ic restart <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to restart. Run `cf ic ps` or call the `GET /containers/json` endpoint to review all containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: The number of seconds to wait before the container is restarted. For example, if you want a container to restart after 10 seconds, enter `t=10`.
          in: query
          name: t
          required: false
          schema:
            type: integer
      responses:
        "204":
          description: No Content. The restart of the container has been initiated.
        "304":
          description: Not Modified. A request to restart the container with the specified name or ID has already been initiated. To review the current state of your container, run `cf ic ps` or call the `GET /containers/json` endpoint.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps` or call the `GET /containers/json` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Restart a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/start":
    post:
      description: "Start a single container with a given container name or ID (corresponding IBM Containers command: `cf ic start <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to start. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the containers in your space that are currently not in a running state.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The start of the container has been initiated.
        "304":
          description: Not Modified. A request to start the container with the specified name or ID has already been initiated. To review the current state of your container, run `cf ic ps` or call the `GET /containers/json` endpoint.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Start a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/stop":
    post:
      description: "Stop a single container with a given container name or ID (corresponding IBM Containers command: `cf ic stop <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to stop. Run `cf ic ps` or call the `GET /containers/json` endpoint to review the containers in your space that are currently in a running state.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
        - description: The number of seconds to wait before the container is stopped. For example, if you want a container to stop after 10 seconds, enter `t=10`.
          in: query
          name: t
          required: false
          schema:
            type: integer
      responses:
        "204":
          description: No Content. The stop of the container has been initiated.
        "304":
          description: Not Modified. A request to stop the container with the specified name or ID has already been initiated. To review the current state of your container, run `cf ic ps` or call the `GET /containers/json` endpoint.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps` or call the `GET /containers/json` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Stop a single container
      tags:
        - Single containers
  "/containers/{name_or_id}/unpause":
    post:
      description: "Unpause all processes that are currently stopped inside a single containers with a given container ID or name (corresponding IBM Containers command: `cf ic unpause <container>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier or name of the container that you want to unpause. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review all containers in your space.
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The unpausing of all processes inside the container has been initiated.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not Found. The container with the specified name or ID could not be found. Run `cf ic ps -a` or call the `GET /containers/json?all=true` endpoint to review the ID and name of your container.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Unpause a single container
      tags:
        - Single containers
  /images/json:
    get:
      description: "This endpoint returns a list of all available Docker images in a private Bluemix registry (corresponding IBM Containers command: `cf ic images`."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ImageInfo"
          description: OK. A list of all available Docker images in the private Bluemix registry is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: List all Docker images that are available in your private Bluemix registry.
      tags:
        - Images
  "/images/{id}":
    delete:
      description: "Remove a Docker image from the private Bluemix registry that is identified by the image ID (corresponding IBM Containers command: `cf ic rmi <image>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The unique identifier representing a Docker image. Run `cf ic images`, or call the `GET /images/json` endpoint to review the Docker images that are available in your private Bluemix registry.
          in: path
          name: id
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The image was successfully removed from your private Bluemix registry.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The specified Docker image ID could not be found. Run `cf ic images` or call the `GET /images/json` endpoint to list all images in your private Bluemix registry. Note the ID of the image that you want to delete.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Remove a Docker image.
      tags:
        - Images
  "/images/{name_or_id}/json":
    get:
      description: "This endpoint returns detailed information about a Docker image that is stored in the private Bluemix registry of an organization (corresponding IBM Containers command: `cf ic inspect <image_name_or_id>`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: "The full private Bluemix registry path to your image or the unique ID of the image that you want to inspect. Run `cf ic images` or call the `GET /images/json` endpoint to review the images in your private Bluemix registry. "
          in: path
          name: name_or_id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ImageDetail"
          description: OK. A list of details about the container image is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: The specified image name or ID could not be found. Run `cf ic images` or call the `GET /images/json` endpoint to retrieve the name or ID of your image.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Inspect a Docker image in private Bluemix registry
      tags:
        - Images
  /registry/namespaces:
    get:
      description: "This endpoint retrieves the namespace that was set for the organization that owns the current space (corresponding IBM Containers command: `cf ic namespace get`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Namespace"
          description: OK. The namespace of the organization is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. A namespace could not be found for the organization. Set a namespace by running `cf ic namespace set <namespace>`, or calling the `PUT /registry/namespaces/<namespace>` endpoint.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Retrieve the namespace of an organization.
      tags:
        - Private Docker images registry
  "/registry/namespaces/{namespace}":
    get:
      description: |-
        This endpoint checks whether a namespace is available in Bluemix and can be used to set up the private Docker images registry for an organization. When a HTTP code `201 Ok` is returned, the namespace is already assigned to another organization in Bluemix and cannot be used. When a HTTP code `404 Not found` is returned, the namespace can be used for your organization. 

         Consider the following rules when choosing a namespace for your organization: 

        - Every organization can have one namespace at a time only 
        - The namespace must be unique in Bluemix. 
        - The namespace can be 4-30 characters long. 
        - The namespace must start with at least one letter or number. 
        - The namespace can only contain lowercase letters, numbers or underscores (_). 
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the namespace that you would like to use for your organization and for which you would like to check availability in Bluemix.
          in: path
          name: namespace
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Namespace"
          description: OK. The namespace that you chose is already used in Bluemix. Choose another namespace and re-run the API call.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The namespace that you chose does not exist. You can use it to set it for your organization by running `cf ic namespace set <namespace>`, or calling the `PUT /registry/namespaces/<namespace>` endpoint.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Check the availability of a namespace
      tags:
        - Private Docker images registry
    put:
      description: |-
        Set up your own Docker images registry in Bluemix by defining a namespace for your organization (corresponding IBM Containers command: `cf ic namespace set <namespace>`). The namespace is used to generate a unique URL to your private Bluemix registry. In your private registry you store all Docker images that you want to share across your organization. To create a container from an image, you must first push the image to your registry. 

         The namespace cannot be changed after is has been set. Consider the following rules to choose a namespace for your organization: 

        - Every organization can have one namespace at a time only 
        - The namespace must be unique in Bluemix. 
        - The namespace can be 4-30 characters long. 
        - The namespace must start with at least one letter or number. 
        - The namespace can only contain lowercase letters, numbers or underscores (_).
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: "The name for your namespace to create your private Docker images registry in Bluemix. You cannot change the name afterward. The namespace can be 4-30 characters long, must start with at least one letter or number, and can only contain lowercase letters, numbers or underscores (_). You can test the availability of your namespace by calling the `GET /registry/namespaces/<namespace>` endpoint. When a HTTP code `404 Not Found` is returned, the namespace is available in Bluemix. "
          in: path
          name: namespace
          required: true
          schema:
            type: string
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Namespace"
          description: OK. The namespace is successfully set for your organization.
        "400":
          description: Bad request. The specified namespace does not meet the Bluemix namespace requirements. The namespace can be 4-30 characters long, must start with at least one letter or number, and can only contain lowercase letters, numbers or underscores (_). Verify your namespace and re-run the API request.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "409":
          description: Conflict. The namespace that you chose either already exists in Bluemix, or a namespace is already been set for your organization. Run `cf ic namespace get` or call the `GET /registry/namespaces` endpoint to retrieve your namespace information. If a namespace is not yet set for your organization, choose another name. You can test the namespace by calling the `GET /registry/namespaces/<namespace>` endpoint. Re-run the API call with the updated namespace.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Set a namespace for your private Bluemix registry.
      tags:
        - Private Docker images registry
  /tlskey:
    get:
      description: "This endpoint returns the TLS (Transport Layer Security) certificate to the user (corresponding IBM Containers command: `cf ic login`). The TLS certificate is a SSL certificate that is used to authenticate the user's CLI with the IBM Containers service and to establish a secure communication between the user's local machine and the container in Bluemix."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Certificate"
          description: Ok. A list of certificates is returned
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Retrieve the TLS Certificate
      tags:
        - Authentication
  /tlskey/refresh:
    put:
      description: "This endpoint requests to generate a new TLS (Transport Layer Security) certificate on the server and to update the existing user TLS certificate (corresponding IBM Containers command: `cf ic init`)."
      parameters:
        - description: "The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token. "
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/CertificateRefresh"
          description: Ok. A list of updated certificates is returned.
        "401":
          description: Authentication failed. The Access Token is invalid or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Refresh the TLS Certificate
      tags:
        - Authentication
  /volumes/create:
    post:
      description: |-
        This endpoints creates a new volume in your space (corresponding IBM Containers command: `cf ic volume create VOLNAME`). A volume is used to persist and access app data between container restarts. Volumes are hosted on file shares that define the available actual storage in Bluemix and the number of input and output transactions per second (IOPS). 

         After you have created a volume, you must mount it to a container by using the `--volume` option in the `cf ic run` (single containers) or `cf ic group create` (container groups) command. You can also define the volume as part of the HTTP body and send a request to the `POST /containers/create` (single containers) or `POST /containers/groups` (container groups) endpoints. 

         Note: If you mount multiple containers in a space to the same volume, they share the data in the volume and can access them anytime. When a container is deleted, the associated volume is not removed.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the volume. The name must be unique for a space and can contain uppercase letters, lowercase letters, numbers, underscores (_), and hyphens (-).
          in: query
          name: name
          required: true
          schema:
            type: string
        - description: The name of the file share that the volume is hosted on. File shares can have different storage sizes and IOPS based on the required workload. If this field is left blank, the volume is hosted on the default file share.
          in: query
          name: fsName
          required: false
          schema:
            type: string
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Volume"
          description: Created. Your volume was successfully created in your space.
        "400":
          description: Bad request. Your request could not be processed due to missing parameter. Make sure to enter a name for your volume as part of your query and re-run the request
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "409":
          description: Conflict. A volume with the same name already exists. Choose a new name for your volume and re-run the API call.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Create a volume in a space
      tags:
        - Volumes
  /volumes/fs/create:
    post:
      description: |-
        This endpoint creates a new file share in a space (corresponding IBM Containers command: `cf ic volume fs-create FSNAME FSSIZE FSIOPS`). 

         A file share is a persistent NFS-based (Network File System) storage system that hosts Docker volumes in a Bluemix space and allows a user to store and access container and app-related files. To store files in a file share, you must create a container volume and save the data into this volume.

         As soon as you create your first volume in a space with the `cf ic volume create VOLNAME` command or the `POST /volumes/create` API endpoint, a default file share with 20 GB at 4 IOPS (Input Output operations Per Second) is created at no cost. 

        The organization manager can create file shares with specific storage size and IOPS to meet the storage needs of the space. File shares can be provisioned in sizes from 20 GB to 12 TB and at IOPS per GB of 0.25, 2 or 4. Run `cf ic volume fs-flavor-list` or call the `GET /volumes/fs/flavors/json` API endpoint to retrieve a list of available file share sizes. The file share size in relation to the number of IOPS impacts the speed that data can be read and written from and to the container volume.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/FileshareParam"
        description: The input parameter to create a new file share in a space.
        required: true
      responses:
        "202":
          description: "Accepted. A new fileshare has been created. "
        "400":
          description: Bad request. The input parameter in the request body are either incomplete or in the wrong format. Be sure to include the file share name, size and number of IOPS as part of your request in JSON format.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID. If your access token and space ID are correct, verify that you have been granted organization manager rights. Only organization managers can create file shares in a space.
        "409":
          description: Conflict. A file share with the same name already exists. Run `cf ic volume fs-list` or call the `GET /volumes/fs/json` API endpoint to get a list with all available file shares in this space. Choose a new name for your file share and re-run the API call.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Create a file share in a space
      tags:
        - File shares
  /volumes/fs/flavors/json:
    get:
      description: "This endpoint returns a list of available file shares in gigabyte (corresponding IBM Containers command: `cf ic volume fs-flavor-list`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  type: integer
                type: array
          description: OK. A list of available file share sizes in gigabyte is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: List available file share sizes
      tags:
        - File shares
  /volumes/fs/json:
    get:
      description: "This endpoint returns a list of all file shares that are availble in a space (corresponding IBM Containers command: `cf ic volume fs-list`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/Fileshare"
                type: array
          description: OK. A list of available file shares is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: List available file shares in a space
      tags:
        - File shares
  "/volumes/fs/{name}":
    delete:
      description: |-
        This endpoint deletes a file share from a space (corresponding IBM Containers command: `cf ic volume fs-rm FSNAME`).

         Before you can delete a file share, all mounted volumes must be deleted first. To delete a volume, run `cf ic volume rm VOLNAME` or call the `DELETE /volumes/{name}` API endpoint. 

         **Note:** To delete a file share you must have been granted organization developer rights.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the file share that you want to delete. Run `cf ic volume fs-list` or call the `GET /volumes/fs/json` API endpoint to retrieve a list of available file shares in your space.
          in: path
          name: name
          required: true
          schema:
            type: string
      responses:
        "204":
          description: No Content. The file share was successfully deleted.
        "400":
          description: "Bad request. The specified file share could not be deleted as it has mounted volumes. Run `cf ic volume rm VOLNAME` or call the `DELETE /volumes/{name}` API endpoint to delete the volume. After all mounted volumes are deleted, delete the file share. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: The specified file share name could not be found. Run `cf ic volume fs-list` or call the `GET /volumes/fs/json` endpoint to retrieve a list of available file shares in your space. Enter the name for your file share and re-run the API call.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Delete a file share
      tags:
        - File shares
  "/volumes/fs/{name}/json":
    get:
      description: "This endpoint returns detailed information about a file share (corresponding IBM Containers command: `cf ic volume fs-inspect FSNAME`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the file share that you want to inspect. Run `cf ic volume fs-list` or call the `GET /volumes/fs/json` endpoint to retrieve a list of available file shares in your space.
          in: path
          name: name
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/GetFileshareDetails"
                type: array
          description: OK. Detailed information about a file share is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: The specified file share name could not be found. Run `cf ic volume fs-list` or call the `GET /volumes/fs/json` endpoint to retrieve a list of available file shares in your space. Enter the name for your file share and re-run the API call.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: Inspect a file share
      tags:
        - File shares
  /volumes/json:
    get:
      description: "This endpoint returns a list of all volumes that are available in the given space (corresponding IBM Containers command: `cf ic volume list`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                items:
                  $ref: "#/components/schemas/Volume"
                type: array
          description: OK. A list containing all volumes of a given space is returned.
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: List all volumes for a space
      tags:
        - Volumes
  "/volumes/{name}":
    delete:
      description: "Delete a volume with a given name from a space (corresponding IBM Containers command: `cf ic volume rm VOLNAME`). To delete a volume, all mounted containers must be unmounted first. After the volume is deleted, the data that are stored in the volume are lost. "
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the volume that you want to delete. Run `cf ic volume list` or call the `GET /volumes/json` endpoint to retrieve a list of all volumes that are available in your space.
          in: path
          name: name
          required: true
          schema:
            type: string
      responses:
        "204":
          description: "No Content. Your request to delete the volume has successfully been processed. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The volume could not be found. Verify that the name is correct by running the `cf ic volume list` command or by calling the `GET /volumes/json` endpoint. Enter the correct name and re-run the API call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Delete a volume
      tags:
        - Volumes
    post:
      description: This endpoint provisions an existing volume that was created in one space to another space within the same organization. Single containers and container groups in each space can read and write to the shared volume. The volume remains owned by the original space it was created in, including management and billing. For example, the volume can be deleted from the original space only.
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the volume that you want to share with another space in your organization.
          in: path
          name: name
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/UpdateVolume"
        description: Input parameter that are required to provision an existing volume to a new space and to unprovision it from a space.
        required: true
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Volume"
          description: Ok. A list with detailed information about the volume is returned. Review the changes in the `otherSpaceVisibility` property.
        "400":
          description: "Bad request. The data that you entered in the request body are either incomplete or in the wrong format. Be sure to include either the space ID where you want to provision your volume, or the space ID from which you want to unprovision your volume in JSON format. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The specified volume could not be found. Verify that the name is correct by running the `cf ic volume list` command or by calling the `GET /volumes/json` endpoint. Enter the correct name and re-run the API call.
        "500":
          description: Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support.
      summary: Share a volume with another space
      tags:
        - Volumes
  "/volumes/{name}/json":
    get:
      description: "Retrieve a detailed list of information about a volume that is identified by the volume name (corresponding IBM Containers command: `cf ic volume inspect VOLNAME`)."
      parameters:
        - description: The Bluemix JSON web token that you receive when logging into Bluemix. Run `cf oauth-token` to retrieve your access token.
          in: header
          name: X-Auth-Token
          required: true
          schema:
            type: string
        - description: The unique ID of your organization space where you want to create or work with your containers. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
          in: header
          name: X-Auth-Project-Id
          required: true
          schema:
            type: string
        - description: The name of the volume, for which you want to retrieve detailed information. Run `cf ic volume list` or call the `GET /volumes/json` endpoint to retrieve a list of all volumes that are available in your space.
          in: path
          name: name
          required: true
          schema:
            type: string
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Volume"
          description: "Ok. A list with detailed information about the volume is returned. "
        "401":
          description: Authentication failed. The Access Token is invalid, or the Space ID that you entered could not be found. Run `cf oauth-token` to retrieve your access token. Run `cf space <space_name> --guid`, where `<space_name>` is the name of your space, to retrieve your space ID.
        "404":
          description: Not found. The specified volume could not be found. Verify that the name is correct by running the `cf ic volume list` command or by calling the `GET /volumes/json` endpoint. Enter the correct name and re-run the API call.
        "500":
          description: "Internal Server Error. The IBM Containers service is currently unavailable. Your request could not be processed. Please wait a few minutes and try again. If you still encounter this problem, note the incident ID and contact the IBM Bluemix support. "
      summary: "Retrieve detailed information about a volume. "
      tags:
        - Volumes
components:
  schemas:
    Binding:
      properties:
        ContainerId:
          description: Unique identifier representing a container
          type: string
    Certificate:
      properties:
        ca_cert:
          description: Certificate Authority (CA) certificate including the CA public key.
          type: string
        server_cert:
          description: Server certificate including the server's public key.
          type: string
        user_cert:
          description: User certificate including the user's public key.
          type: string
        user_key:
          description: User's private key.
          type: string
      required:
        - ca_cert
        - server_cert
        - user_cert
        - user_key
      type: object
    CertificateRefresh:
      properties:
        ca_cert:
          description: Certificate Authority (CA) certificate including the CA public key.
          type: string
        reg_host:
          description: Full URL to the IBM Bluemix registry.
          type: string
        server_cert:
          description: Server certificate including the server's public key.
          type: string
        user_cert:
          description: User certificate including the user's public key.
          type: string
        user_key:
          description: User's private key.
          type: string
    Container:
      properties:
        Command:
          description: The command and arguments that were passed to the container during container creation. This command is executed when the container is started.
          type: string
        ContainerState:
          description: "The current status of the container. The status can either be a transient state, such as BUILDING, and NETWORKING or a non-transient state, such as RUNNING, SHUTDOWN, CRASHED, PAUSED, or SUSPENDED. "
          type: string
        Created:
          description: The time when the container was created.
          format: float
          type: number
        Env:
          description: A list of all the environment variables of the container.
          items:
            type: string
          type: array
        Group:
          $ref: "#/components/schemas/Group"
        Id:
          description: Unique identifier representing a container.
          type: string
        Image:
          description: Full path to the container image in your private Bluemix registry.
          type: string
        ImageId:
          description: Unique identifier representing a container image.
          type: string
        Labels:
          description: List of custom metadata that was added to the container. Labels serve a wide range of uses, such as adding notes to a container. Every label is a key/ value pair.
          type: object
        Memory:
          description: The amount of container memory in Megabyte that was assigned to your container. The memory is counted towards the quota that is allocated for the space.
          format: int32
          type: integer
        Name:
          description: "The name of the container. "
          type: string
        Names:
          description: The name of the container.
          items:
            type: string
          type: array
        NetworkSettings:
          $ref: "#/components/schemas/NetworkSetting"
        Ports:
          $ref: "#/components/schemas/Port"
        SizeRootFs:
          description: "Total size of all the files in the container, in bytes. "
          type: integer
        SizeRw:
          description: The size of the files which have been created or changed, if you compare the container to its base image. Just after creation, this should be zero. Ass you modify (or create) files, this size will increase.
          type: integer
        Started:
          description: Time when the container was started.
          format: float
          type: number
        Status:
          description: The current status of the container. The status can either be a transient state, such as BUILDING, and NETWORKING or a non-transient state, such as RUNNING, SHUTDOWN, CRASHED, PAUSED, or SUSPENDED
          type: string
        VCPU:
          description: Number of virtual CPUs that are assigned to the container.
          type: integer
    ContainerConfig:
      properties:
        ArgsEscaped:
          description: ""
          type: boolean
        AttachStderr:
          description: Attaches the container to stderr.
          type: string
        AttachStdin:
          description: Attaches the container to sdtin.
          type: string
        AttachStdout:
          description: Attaches the container to stdout.
          type: string
        Cmd:
          description: |
            The command and arguments in this list are passed to the container to be executed when the container is started. This command must be a long-running command. Do not use a short-lived command, for example, /bin/date, because it might cause the container to crash. <br>Sample long-running commands:<br>["ping","localhost"]<br>["tail","-f","/dev/null"]<br>["sh","-c","while true; do date; sleep 20; done"]
          items:
            type: string
          type: array
        Domainname:
          description: The domain name to be used for the container.
          type: string
        Env:
          description: A list of environment variables in the form of key=value pairs. All keys in this list have to be unique. List multiple keys separately and if you include quotation marks, include them around both the environment variable name and the value.
          items:
            type: string
          type: array
        ExposedPorts:
          description: "List of public ports that were exposed during container creation. "
          items:
            type: string
          type: array
        Hostname:
          description: The host name to be used for the container.
          type: string
        Image:
          description: Full path to the image that the container is based on in your private Bluemix registry.
          type: string
        ImageArchitecture:
          description: The hardware architecture the image is based on. It can either be 'amd64' indicating an Intel-based architecture, or 'ppc64le' representing a Power-based architecture.
          type: string
        Labels:
          description: List of custom metadata that was added to the container. Labels serve a wide range of uses, such as adding notes to a container. Every label is a key/ value pair.
          items:
            type: string
          type: array
        Memory:
          description: The amount of container memory that is assigned to the container in Megabyte.
          format: int32
          type: integer
        MemorySwap:
          description: The total container memory limit (memory + swap)
          type: string
        OpenStdin:
          description: "When set to true, it opens stdin. "
          type: string
        PortSpecs:
          description: Not supported by IBM Containers, empty string.
          type: string
        StdinOnce:
          description: When set to true it closes stdin after the attached client disconnects.
          type: string
        Tty:
          description: When set to true, attach standard streams to a tty, including stdin if it is not closed.
          type: string
        User:
          description: User to be used inside the container.
          type: string
        VCPU:
          description: Number of virtual CPUs that are assigned to the container.
          format: int32
          type: integer
        VolumesFrom:
          description: List of volumes to inherit from another container. This feature is not supported in IBM Containers.
          type: string
        WorkingDir:
          description: "The working directory inside the container where specified commands are executed. "
          type: string
    ContainerId:
      properties:
        Id:
          description: Unique ID representing a container.
          type: string
        flavor_id:
          description: The ID of the container size.
          type: integer
        mem:
          description: The amount of container memory that has been assigned to the container. If the container memory was not specified in the API request, a container with 64 Megabyte container memory is created by default.
          type: integer
        vcpu:
          description: Number of virtual CPUs that are assigned to the container.
          type: integer
    ContainerInfo:
      properties:
        BluemixApp:
          description: The name of the Cloud Foundry app that was bound to the container during creation.
          type: string
        BluemixServices:
          description: The name of the Bluemix service instance that was bound to the container during creation.
          type: string
        Config:
          $ref: "#/components/schemas/ContainerConfig"
        ContainerState:
          description: The current status of the container. This state can either be transient, such as BUILDING or NETWORKING, or non-transient, such as RUNNING, SHUTDOWN, CRASHED, or SUSPENDED.
          type: string
        Created:
          description: The date and time the container was created.
          format: date-time
          type: string
        Group:
          $ref: "#/components/schemas/Group"
        HostConfig:
          $ref: "#/components/schemas/HostConfig"
        HostId:
          description: The ID representing the physical compute host.
          type: string
        Human_Id:
          description: "The name of the container. "
          type: string
        Id:
          description: Unique identifier representing a container.
          type: string
        Image:
          description: Unique identifier representing a container image.
          type: string
        Mounts:
          description: A list of volumes that are mounted to the container.
          items:
            type: string
          type: array
        Name:
          description: The name of the container.
          type: string
        NetworkSettings:
          $ref: "#/components/schemas/NetworkSetting"
        Path:
          description: The environment variable indicating the binary location.
          type: string
        ResolveConfPath:
          description: Path to the resolve.conf file inside the container. The resolve.conf file is used to resolve the DNS servers.
          type: string
        State:
          $ref: "#/components/schemas/ContainerState"
        Volumes:
          $ref: "#/components/schemas/Volume"
        VolumesRW:
          description: LIst of volumes that is mounted to the container.
          items:
            type: string
          type: array
    ContainerState:
      properties:
        ExitCode:
          description: "The exit code indicating the root cause of why the container exited. Review the Docker API documentation to find a list of exit codes and their meaning. "
          type: string
        FinishedAt:
          description: Time when the container stopped.
          type: string
        Ghost:
          description: Not supported by IBM Containers, empty string
          type: string
        Pid:
          description: The process ID on the compute host that runs the container process.
          type: integer
        Running:
          description: "If set to true, the container is in a RUNNING state. If set to false, the container has stopped or crashed. "
          type: boolean
        StartedAt:
          description: Time when the container started.
          type: string
        Status:
          description: The current status of the container. This state can either be transient, such as BUILDING or NETWORKING, or non-transient, such as RUNNING, SHUTDOWN, CRASHED, or SUSPENDED.
          type: string
    ContainersGroupsGetListItem:
      properties:
        Creation_time:
          description: Time when the container group is created.
          type: string
        Id:
          description: Unique identifier of the container group.
          type: string
        Name:
          description: Name of the container group.
          type: string
        Port:
          description: The port number that is exposed to the public during container group creation.
          format: int32
          type: integer
        Routes:
          description: The public route that is mapped to the container group. You can use this route to access your container group from the Internet.
          items:
            type: string
          type: array
        Status:
          description: Current status of the container group. The container group status is a composite of ACTION and STATUS:<br><br> ACTIONS = (CREATE, DELETE, UPDATE, ROLLBACK, SUSPEND, RESUME, ADOPT, SNAPSHOT, CHECK, RESTORE)<br><br> STATUSES = (IN_PROGRESS, FAILED, COMPLETE)
          type: string
        Updated_time:
          description: Time when the container group is changed and updated.
          type: string
    ContainersGroupsNameOrIdGetDetails:
      properties:
        Anti-affinity:
          description: "If set to `true` the container instances in the group are spread across separate physical compute nodes, which reduces the likelihood of containers crashing due to hardware failures. If set to `false`, the container instances in the group share the same physical compute node. "
          type: string
        Autorecovery:
          description: Can be either true or false. If set to true, the Autorecovery mode is enabled for your container group. In case a container instance crashes or stops, this instance is removed and a new one is automatically recreated. If set to false, the Autorecovery mode is disabled. In case a container instances crashes or stops, it is not automatically recreated by IBM Containers.
          type: string
        AvailabilityZone:
          description: "Current IBM Containers availability zone on Openstack. "
          type: string
        Cmd:
          description: "The Docker command that was specified to be run when the container instances are started. "
          items:
            type: string
          type: array
        Creation_time:
          description: Timestamp when the container group was created.
          type: string
        Env:
          description: The list of environmental variables that were defined for the container group. Each environment variable consists of a unique key and a value.
          items:
            type: string
          type: array
        Id:
          description: Unique identifier representing a specific container group.
          type: string
        Image:
          description: The unique ID of the container image your container group instances are based on.
          type: string
        ImageName:
          description: The full path to the container image in your private Bluemix repository.
          type: string
        Memory:
          description: The size of each container instance that runs in the container group in MegaByte.
          format: int32
          type: integer
        Name:
          description: The name of the container group.
          type: string
        NumberInstances:
          properties:
            CurrentSize:
              description: "The current number of container instances that are running in your container group. "
              format: int32
              type: integer
            Desired:
              description: The number of container instances that you require.
              format: int32
              type: integer
            Max:
              description: The maximum number of container instance that you want to run in your container group.
              format: int32
              type: integer
            Min:
              description: The minimum number of container instances that you want to run in your container group.
              format: int32
              type: integer
          type: object
        Port:
          description: "The public port that has been exposed. If you specified a route, your container group is accessible from the Internet. "
          format: int32
          type: integer
        Route_Status:
          properties:
            in_progress:
              description: Can be either true or false. If set to true, then the route is in the process of being mapped to the container group and set up in the GoRouter. Is set to false, then the set up of the route is completed.
              type: boolean
            message:
              description: Info message for the user.
              type: string
            successful:
              description: Can be either true or false. If set to true, then the route is successfully registrered with the GoRouter. If set to false, then the route registration has not yet finished yet or could not be completed without errors.
              type: boolean
          type: object
        Routes:
          description: The public route that is mapped to the container group. When you expose a public port, you can use the route to access your container group from the Internet.
          items:
            type: string
          type: array
        Status:
          description: The current status of the container group. The container group status is a composite of ACTION and STATUS:<br><br> ACTIONS = (CREATE, DELETE, UPDATE, ROLLBACK, SUSPEND, RESUME, ADOPT, SNAPSHOT, CHECK, RESTORE)<br><br> STATUSES = (IN_PROGRESS, FAILED, COMPLETE)
          type: string
        UpdatedTime:
          description: Timestamp when the container group was updated. If the container group was not updated before, `null` is returned.
          type: string
        Volumes:
          description: List of volumes to be associated with the container, in the format of volume name:path:mode where mode can be ro or rw.
          items:
            type: string
          type: array
    ContainersGroupsNameOrIdMaproutePostInfo:
      allOf:
        - $ref: "#/components/schemas/ContainersGroupsPostCreatedInfo"
        - type: object
    ContainersGroupsNameOrIdPatchUpdatedInfo:
      properties:
        Autorecovery:
          description: "Enable or disable the Autorecovery mode for your container group. To enable it, enter true. If you want to disable it, enter false. Note: You can only enable/ disable Autorecovery mode if your container group was initially created with Autorecovery mode enabled."
          type: string
        Environment:
          description: A list of environment variables that you want to add to your container group. Every environment variable needs to be a key=value pair. Every key that you use needs to be unique for this container group. Multiple environment variables are separated with comma (,)
          items:
            type: string
          type: array
        NumberInstances:
          properties:
            Desired:
              description: The number of container instances that you require.
              format: int32
              type: integer
            Max:
              description: The maximum number of container instances that you want to run in your container group.
              format: int32
              type: integer
            Min:
              description: The minimum number of container instances that you want to run in your container group.
              format: int32
              type: integer
          type: object
    ContainersGroupsPostCreatedInfo:
      properties:
        Id:
          description: Unique identifier representing a specific container group.
          type: string
        Warnings:
          description: Warning information (Initial warning is empty).
          items:
            type: string
          type: array
      type: object
    ContainersGroupsPostRequiredAttributes:
      properties:
        Autorecovery:
          description: (Optional) Enable the Auto-recovery mode for your container group. If set to true, IBM Containers checks the health of each instance with an HTTP request to the port that is assigned. If the health check does not receive a TCP response from a container instance in two subsequent 90-second intervals, the instance is removed and replaced with a new instance. If set to false and container instances crash, they are not recovered by IBM Containers.
          type: string
        BluemixApp:
          description: (Optional) The name of the Cloud Foundry app that you created in your organization space.
          type: string
        Cmd:
          description: (Optional) Docker command that is passed to the container group to be run when the container instances are started. This command must be a long-running command. Do not use a short-lived command, for example, /bin/date, because it might cause the container to crash.
          items:
            type: string
          type: array
        Env:
          description: (Optional) List of environmental variables. Every environment variable that is listed here needs to be a key=value pair. Every key that you use needs to be unique for this container group. Multiple environment variables are separated with comma (,).
          items:
            type: string
          type: array
        Image:
          description: "(Required) The full path to your private Bluemix repository. If you want to use an image in your private Bluemix repository, specify the image in the following format: registry.ng.bluemix.net/NAMESPACE/IMAGE. If you want to use an IBM Containers provided image, do not include your organization's namespace. Specify the image in the following format: registry.ng.bluemix.net/IMAGE"
          type: string
        Memory:
          description: "(Optional) The size of each container instance in the container group. The size of each container instance in the group. Choose one of the following sizes and enter the size in MegaBytes: Pico 64 MB, Nano 128 MB, Micro 256 MB, Tiny 512 MB, Small 1 GB (1024 MB), Medium 2 GB (2048 MB), Large 4 GB (4096 MB) XLarge 8GB (8192 MB) and 2XLarge 16 GB (16384 MB). If you do not specify a size, all container instances in this group are created with 256 MB."
          format: int32
          type: integer
        Name:
          description: (Required) Name of the container group that you want to create. The name needs to be unique in your organization space and must start with a letter. Then, you can include uppercase letters, lowercase letters, numbers, periods (.), underscores (_), or hyphens (-).
          type: string
        NumberInstances:
          properties:
            Desired:
              description: (Optional) The number of container instances that you require.
              format: int32
              type: integer
            Max:
              description: (Optional) The maximum number of container instances that you want to run in your container group.
              format: int32
              type: integer
            Min:
              description: (Optional) The minimum number of container instances that need to run in your container group.
              format: int32
              type: integer
          type: object
        Port:
          description: '(Optional) Expose a port for HTTP traffic to make your container group available from the Internet. Every container instance that is started for this group, listens on this port. Container groups cannot expose multiple ports. Note: You need to expose a port, when "Autorecovery" is set to true.'
          format: int32
          type: integer
        Route:
          properties:
            domain:
              description: The default system domain is mybluemix.net and already provides a SSL certificate, so you can access your container groups with HTTPS without any additional configuration.
              type: string
            host:
              description: "The host name of your container group, such as mycontainerhost. Do not include underscores (_) in the host name. The host and the domain combined form the full public route URL, such as http://mycontainerhost.mybluemix.net. "
              type: string
          type: object
        Volumes:
          description: "(Optional) List of volumes to be mounted to the container instances of your container group. You need to create the volume first by using the cf ic volume-create command before you can mount a volume to a container group. When you specify a volume, use the following format: NAME:PATH:MODE. For NAME, use either the name or ID of the volume. For the PATH, enter the absolute path to the volume directory in the container. For MODE, enter either ro (read-only) or rw (read-write)."
          items:
            type: string
          type: array
      required:
        - Name
        - Image
    ContainersQuotaInfo:
      properties:
        account_type:
          description: The Bluemix account type indicating the quota limits and how the organization is billed.
          type: string
        country_code:
          description: The country in which the account was opened.
          type: string
        org_quota:
          properties:
            floating_ips_max:
              description: The number of public IP addresses that can be assigned across all spaces of the organization.
              type: string
            floating_ips_space_default:
              description: "The number of public IP addresses that are required for one space. If the number of public IP addresses is not available, then a new space cannot be created to be used with IBM Containers. "
              type: string
            floating_ips_usage:
              description: The number of public IP addresses that are currently assigned to the spaces of the organization.
              format: int32
              type: integer
            ram_max:
              description: The maximum amount of container memory on the compute host that can be assigned across the spaces of the organization.
              format: int32
              type: integer
            ram_space_default:
              description: "The amount of container memory that is required to be used for one space. If this amount is not available, then a new space cannot be created to be used with IBM Containers. "
              format: int32
              type: integer
            ram_usage:
              description: The amount of container memory that is currently used across all spaces of the organization.
              format: int32
              type: integer
            subnet_usage:
              description: The number of subnets that were created across all spaces of the organization.
              format: int32
              type: integer
            subnets_default:
              description: The number of subnets that is required to create a new space. If this number is not available, then a new space cannot be created to be used with IBM Containers.
              format: int32
              type: integer
            subnets_max:
              description: The maximum number of container private subnet that can be created across all spaces of the organization.
              format: int32
              type: integer
          type: object
        space_quota:
          properties:
            floating_ips_max:
              description: The maximum number of public IP addresses that can be allocated to a space.
              type: string
            ram_max:
              description: The maximum amount of container memory that can be shared across all containers that are created in a space.
              format: int32
              type: integer
            subnets_max:
              description: The maximum number of private subnets that can be created in one space.
              format: int32
              type: integer
          type: object
    ContainersQuotaList:
      properties:
        floating_ips:
          description: The new number of public IP addresses that you want to assign to your space.
          format: int32
          type: integer
        ram:
          description: The amount of container memory that you want to assign to your space.
          format: int32
          type: integer
    ContainersUsageInfo:
      properties:
        AvailableSizes:
          items:
            $ref: "#/components/schemas/ContainersUsageInfoAvailableSizes"
          type: array
        Environment:
          description: The IBM Containers machine where the space is located
          type: string
        Limits:
          properties:
            containers:
              description: "The number of containers that can be created in the space. If -1 is returned, then an unlimited number of containers can be created. The number however is counted towards and limited by the container memory. "
              format: int32
              type: integer
            floating_ips:
              description: The number of public IP addresses that can be allocated to the space.
              format: int32
              type: integer
            memory_MB:
              description: The amount of container memory that can be used in the space in megabyte.
              format: int32
              type: integer
            vcpu:
              description: The number of virtual CPUs that are assigned to the space.
              format: int32
              type: integer
          type: object
        Usage:
          properties:
            containers:
              description: The number of containers that were created in the space. All containers that count towards the quota limit are listed independent on their current state.
              format: int32
              type: integer
            floating_ips:
              description: The number of public IP addresses that are allocated to the space.
              format: int32
              type: integer
            floating_ips_bound:
              description: The number of public IP addresses that are bound to a container in the space.
              format: int32
              type: integer
            images:
              description: The number of private images that were added to the private Bluemix registry.
              format: int32
              type: integer
            memory_MB:
              description: The amount of container memory that is already used by the containers that were created in the space in megabyte.
              format: int32
              type: integer
            running:
              description: The number of containers that are currently in a running state.
              format: int32
              type: integer
            vcpu:
              description: The number of virtual CPUs that are allocated to the space.
              format: int32
              type: integer
          type: object
    ContainersUsageInfoAvailableSizes:
      properties:
        disk:
          description: The amount of disk space on the compute host that is assigned to the container in gigabyte
          format: int32
          type: integer
        id:
          description: The ID of the container size.
          type: string
        memory_MB:
          description: The amount of container memory on the compute host that is assigned to the container in megabyte.
          format: int32
          type: integer
        name:
          description: The IBM Containers name of the container size.
          type: string
        vcpus:
          description: The number of virtual CPUs that can be assigned to the container.
          format: int32
          type: integer
    ContainersVersionGetInfo:
      properties:
        ApiVersion:
          description: The current API version.
          type: string
        Arch:
          description: The current Arch version.
          type: string
        BuildDetail:
          properties:
            api:
              description: The build ID of the current API version.
              type: string
            automount:
              description: The build ID of the current automount microservice version.
              type: string
            grupdater:
              description: The build ID of the current grupdater microservice version.
              type: string
            harmony:
              description: The build ID of the current harmony microservice version.
              type: string
            health-monitor:
              description: The build ID of the current health-monitor microservice version.
              type: string
            hijack:
              description: The build ID of the current hijack microservice version.
              type: string
            ldap:
              description: The build ID of the current ldap microservice version.
              type: string
            logmet:
              description: The build ID of the current logmet microservice version.
              type: string
            lumberjack:
              description: The build ID of the current lumberjack microservice version.
              type: string
            redis-cluster:
              description: The build ID of the current redis-cluster version.
              type: string
            sgwatcher:
              description: The build ID of the current sgwatcher microservice version.
              type: string
            volmgr:
              description: The build ID of the current volumes manager microservice version.
              type: string
          type: object
        BuildID:
          description: ""
          type: string
        BuildNumber:
          description: ""
          type: string
        BuildTime:
          description: Timestamp when the API version and all attached microservices were built.
          type: string
        GitCommit:
          description: ""
          type: string
        GoVersion:
          description: The latest Go version.
          type: string
        KernelVersion:
          description: The latest Kernel version.
          type: string
        Os:
          description: Bluemix Containers
          type: string
        Version:
          description: The latest API version.
          type: string
    CreateContainer:
      properties:
        BluemixApp:
          description: The name of the Cloud Foundry app that you want to bind to your container. The Cloud Foundry app must be created in the same space where you want to create your container.
          type: string
        Cmd:
          description: |
            The command and arguments in this list are passed to the container to be executed when the container is started. This command must be a long-running command. Do not use a short-lived command, for example, /bin/date, because it might cause the container to crash. <br>Sample long-running commands:<br>["ping","localhost"]<br>["tail","-f","/dev/null"]<br>["sh","-c","while true; do date; sleep 20; done"]
          items:
            type: string
          type: array
        Cpuset:
          description: "Pins the container processes to a specific CPU core on the compute host. For example: 0 means that processes are executed on the first core only."
          type: string
        Env:
          description: A list of environment variables in the form of key=value pairs. All keys in this list have to be unique. List multiple keys separately and if you include quotation marks, include them around both the environment variable name and the value.
          items:
            type: string
          type: array
        ExposedPorts:
          description: All public ports that need to be exposed for the container, so the container can be accessed from the Internet.
          items:
            type: string
          type: array
        HostConfig:
          $ref: "#/components/schemas/HostConfig"
        Image:
          description: "Full path to the image in your private Bluemix registry in the format `registry.ng.bluemix.net/namespace/image`. "
          type: string
        Memory:
          description: "The container memory that is set for the container in Megabyte. Choose one of the following sizes: Pico 64 MB, Nano 128 MB, Micro 256 MB, Tiny 512 MB, Small 1 GB (1024 MB), Medium 2 GB (2048 MB), Large 4 GB (4096 MB) XLarge 8GB (8192 MB) and 2XLarge 16 GB (16384 MB)."
          format: int32
          type: integer
        NumberCpus:
          description: Number of virtual CPUs that are allocated to the container.
          format: int32
          type: integer
        Volumes:
          description: "Mount a volume to a container by specifying the details in the following format: `VOLUME_NAME:/DIRECTORY_PATH[:ro]`. Example: testvolume:/volumedata/temp:rw. By default, all volumes will be set up with read-write access inside the container (rw). If you wish to set up your volume with read-only access, enter `ro`.  Note: To mount a volume to a container, you must create the volume in your space first by using the `cf ic volume-create` command, or calling the `POST /volumes/create endpoint`."
          type: string
      required:
        - Image
    Fileshare:
      properties:
        capacity:
          description: The size of the file share in gigabyte.
          type: integer
        created_date:
          description: The timestamp when the file share was created.
          type: string
        fsName:
          description: The name of the file share.
          type: string
        hostPath:
          description: The path to the volume on the host node.
          type: string
        iops:
          description: "The number of Input/Output operations per second. "
          format: double
          type: number
        iopsTotal:
          description: The total number of IOPS considering the size of the file share. The size of your file share in gigabyte multiplied with the number of IOPS indicates the total number of IOPS. The higher the number of IOPS the faster you can read from and write to your volumes.
          type: integer
        orderId:
          description: The ID received from softlayer when the file share was ordered to be set up in softlayer.
          type: string
        provider:
          description: The provider of the file share.
          type: string
        spaceGuid:
          description: The unique ID representing a Bluemix space in which the file share was created.
          type: string
        state:
          description: The current state of the file share. When the file share is ready to be used, this attribute is set to `READY`.
          type: string
        updated_date:
          description: The timestamp when the file share last was updated.
          type: string
      type: object
    FileshareParam:
      properties:
        fsIOPS:
          description: The number of input/output transactions per second. Available values are 0.25, 2 or 4.
          format: double
          type: number
        fsName:
          description: The name of the new file share that you want to create. The name can contain uppercase letters, lowercase letters, numbers, underscores (_), and hyphens (-).
          type: string
        fsSize:
          description: "The size of the file share in gigabyte. Run `cf ic volume fs-flavor-list` or call the GET /volumes/fs/flavors/json API endpoint to retrieve a list of available file share sizes. "
          type: integer
      required:
        - fsName
        - fsSize
        - fsIOPS
      type: object
    FileshareUsage:
      properties:
        available_space:
          description: The amount of space that is available in the file share in gigabytes.
          type: string
        total_space:
          description: The total size of the file share in gigabytes.
          type: string
        used_space:
          description: "The amount of space that is currently used from the file share. "
          type: string
        used_space_percentage:
          description: The amount of space that is currently used from the file share in percentage.
          type: string
      type: object
    FloatingIP:
      properties:
        Bindings:
          $ref: "#/components/schemas/Binding"
        IpAddress:
          description: The public IP address that is allocated to the organization space.
          type: string
    GetFileshareDetails:
      properties:
        fs:
          items:
            $ref: "#/components/schemas/Fileshare"
          type: array
        fsUsage:
          items:
            $ref: "#/components/schemas/FileshareUsage"
          type: array
        volnames:
          description: A list of volume names that are mounted to the file share.
          items:
            type: string
          type: array
      type: object
    Group:
      properties:
        Id:
          description: Unique identifier representing a group.
          type: string
        Name:
          description: Name of the group.
          type: string
    HostConfig:
      properties:
        Binds:
          description: "A list of volumes to be bound to the container. Each volume must be listed in the following format: VOLNAME:/CONTAINER_PATH:rw [ro]. "
          items:
            type: string
          type: array
        ExtraHosts:
          description: |
            A list of hostnames/IP mappings to be added to the container’s /etc/hosts file. Specified in the form ["hostname:IP"]
          items:
            type: string
          type: array
        Links:
          description: A list of containers that need to be linked.
          items:
            type: string
          type: array
        PortBindings:
          description: |
            The container ports that you want to expose to the public. Ports need to be specified in the form of &lt;port&gt;/&lt;protocol&gt;: [{ "HostIp": "&lt;IP&gt;", "HostPort": "&lt;port&gt;" }]
          items:
            type: string
          type: array
      type: object
    ImageDetail:
      properties:
        Architecture:
          description: "The hardware architecture for which the image was built for. The architecture can either be Intel (amd64) or Power (ppc64le). "
          type: string
        Config:
          properties:
            ArgsEscaped:
              description: ""
              type: boolean
            AttachStderr:
              description: Attaches the container to stderr.
              type: boolean
            AttachStdin:
              description: Attaches the container to stdin.
              type: boolean
            AttachStdout:
              description: Attaches the container to stdout.
              type: boolean
            Cmd:
              description: |
                The command and arguments in this list are passed to the container to be executed when the container is started. This command must be a long-running command. Do not use a short-lived command, for example, /bin/date, because it might cause the container to crash. <br>Sample long-running commands:<br>["ping","localhost"]<br>["tail","-f","/dev/null"]<br>["sh","-c","while true; do date; sleep 20; done"]
              items:
                type: string
              type: array
            Domainmame:
              description: The domain name to be used for the container.
              type: string
            Entrypoint:
              description: The entrypoint specifies a command that will always be executed when the container starts.
              type: string
            Env:
              description: A list of environment variables in the form of key=value pairs. All keys in this list have to be unique. List multiple keys separately and if you include quotation marks, include them around both the environment variable name and the value.
              items:
                type: string
              type: array
            ExposedPorts:
              description: A list of all udp and tcp ports that have been publicly exposed during the container creation.
              items:
                type: string
              type: array
            Hostname:
              description: "The host name of the container provided by Openstack. "
              type: string
            Image:
              description: "The unique ID of the image. "
              type: string
            Labels:
              description: List of custom metadata that was added to the image. Labels serve a wide range of uses, such as adding notes or license requirements to an image. Every label is a key/ value pair.
              items:
                type: string
              type: array
            OnBuild:
              description: ???
              items:
                type: string
              type: array
            OpenStdin:
              description: When set to true, it opens stdin.
              type: boolean
            StdinOnce:
              description: When set to true it closes stdin after the attached client disconnects.
              type: boolean
            Tty:
              description: When set to true, attach standard streams to a tty, including stdin if it is not closed.
              type: boolean
            User:
              description: The user to be used inside the container.
              type: string
            Volumes:
              description: Docker specific. Not supported by IBM Containers. The path to the volume that is created when deploying a container from the image. To use a volume in IBM Containers, you must first create a volume and then mount it to your container during creation.
              type: string
            WorkingDir:
              description: The working directory inside the container where specified commands are executed.
              type: string
          type: object
        Container:
          description: ???
          type: string
        ContainerConfig:
          $ref: "#/components/schemas/ContainerConfig"
        Created:
          description: The time when the image was created.
          type: string
        DockerVersion:
          description: ???
          type: string
        Id:
          description: "Unique ID of the image that you inspected. "
          type: string
        Os:
          description: ???
          type: string
        Parent:
          description: The ID of the parent image that was used to build this image.
          type: string
        Size:
          description: "The real size of the image. "
          format: int32
          type: integer
        Tag:
          description: "The version of the image "
          type: string
        Throwaway:
          description: ???
          type: string
        VirtualSize:
          description: The virtual size of the image.
          format: int32
          type: integer
      type: object
    ImageInfo:
      properties:
        Created:
          description: "The time when your container image was created. "
          format: float
          type: number
        Id:
          description: "The unique identifier representing a container image. "
          type: string
        Image:
          description: The name of your container image.
          type: string
        RepoTags:
          description: The full path to the private Bluemix registry where the image is stored including the registry name, the organization namespace, and image tag.
          items:
            type: string
          type: array
        Size:
          description: The real size of the container image.
          format: int32
          type: integer
        VirtualSize:
          description: The virtual size of the container image.
          format: int32
          type: integer
    Namespace:
      properties:
        namespace:
          description: The namespace that is either set for an organization, or a namespace that is not available to be used in Bluemix.
          type: string
      type: object
    Network:
      properties:
        Aliases:
          description: Alternative name of the private container network the container is connected to.
          type: string
        EndpointID:
          description: Unique ID representing a container.
          type: string
        Gateway:
          description: The private IP address of the network gateway in IPv4 format.
          type: string
        GlobalIPv6Address:
          description: Private IP address of the container in IPv6 format. IBM Containers only supports IPv4 format. This attribute is returned as empty.
          type: string
        GlobalIPv6PrefixLen:
          description: Not supported by IBM Containers, empty string.
          type: integer
        IPAMConfig:
          description: Specific configurations for the network driver.
          type: string
        IPPrefixLen:
          description: "The prefix of the subnet in the private container network. The prefix indicates that 16 bits out of 32 bits are used to address the network. As every IPv4 IP adress consists of 32 bits, the last 16 bits are used to assign private IP addresses to the container. "
          type: string
        IPv6Gateway:
          description: The private IP address of the network gateway in IPv6 format. IBM Containers only supports IPv4 format. This attribute is returned as empty.
          type: string
        Links:
          description: "List of container names that are linked to the container. "
          type: string
        MacAddress:
          description: The MAC address that is assigned to the container.
          type: string
        NetworkID:
          description: Unique identifier representing the private container network.
          type: string
    NetworkSetting:
      properties:
        Bridge:
          description: The name of the private network bridge.
          type: string
        Gateway:
          description: The IP address of the private network gateway in IPv4 format.
          type: string
        IpAddress:
          description: The private IP address that is assigned to the container.
          type: string
        IpPrefixLen:
          description: ""
          format: int32
          type: integer
        MacAddress:
          description: "The MAC address that was assigned to the container. "
          type: string
        Network:
          $ref: "#/components/schemas/Network"
        PortMapping:
          description: "Specific to Docker. List of private container ports and their mapping to the host ports. In IBM Containers all container ports are exposed on the host by default. This attribute is returned as an empty list. "
          type: string
        Ports:
          description: All ports of the container that were exposed to the public.
          items:
            type: string
          type: array
        PublicIpAddress:
          description: The Public IP address that was bound to the container.
          type: string
      required:
        - IpAddress
        - PublicIpAddress
    Port:
      properties:
        IP:
          description: Public IP address that was bound to the container in IPv4 format.
          type: string
        PrivatePort:
          description: The private port of the container on which the container listens during run time.
          type: string
        PublicPort:
          description: The public port that was exposed during container creation. When a public port is exposed, a public IP address can be bound to the container which makes the container accessible from the internet.
          type: string
        Type:
          description: "The type of IP protocol that is used for the port. It can either be `udp` or `tcp`.  "
          type: string
    Route:
      description: The public route that is mapped to the container group. You can use this route to access your container group from the Internet.
      properties:
        domain:
          description: The default system domain is mybluemix.net and already provides a SSL certificate, so you can access your container groups with HTTPS without any additional configuration.
          type: string
        host:
          description: The host name of your container group, such as mycontainerhost. Do not include underscores (_) in the host name. The host and the domain combined form the full public route URL, such as http://mycontainerhost.mybluemix.net.
          type: string
      type: object
    UpdateVolume:
      properties:
        addSpaces:
          description: "The name or ID of the space where you want to provision your existing volume. Run `cf spaces` to retrieve the name, or `cf space <space_name> --guid` to retrieve the space ID. "
          items:
            type: string
          type: array
        removeSpaces:
          description: The name or ID of the space from which you want to unprovision your existing volume. Run `cf spaces` to retrieve the name, or `cf space <space_name> --guid` to retrieve the space ID.
          items:
            type: string
          type: array
    Volume:
      properties:
        fsID:
          description: " Unique identifier representing the file share on which the volume is hosted. "
          type: string
        hostPath:
          description: Full path to the mounted volume inside the container.
          type: string
        otherSpaceVisibility:
          description: "List of space IDs in which the volume is visible and can be used by all the single containers and container groups. "
          items:
            type: string
          type: array
        spaceGuid:
          description: Unique identifier representing the space where the volume got created.
          type: string
        volName:
          description: The name of the volume.
          type: string
    getContainerStatus:
      properties:
        NameOrId:
          description: "The unique identifier of the container. "
          type: string
        Status:
          description: "The current status of the container. The status can either be a transient one, such as BUILDING or NETWORKING, or a non-transient one, such as RUNNING, SHUTDOWN, CRASHED, or SUSPENDED. "
          type: string
        Transient:
          description: When set to true, the current container state is temporary and will change soon. An example for a transient state is the BUILDING state. A container that is created will be set to the BUILDING state until all container layers are created and the container is started. When set to false, the container state is permanent, such as CRASHED.
          type: boolean
      required:
        - NameOrId
