> ## Documentation Index
> Fetch the complete documentation index at: https://docs.m1amdocs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Post external runtime entity events

> API to notify MarketONE of significant runtime (devices) lifecycle events occured outside MarketONE.



## OpenAPI

````yaml /marketONE/MarketONEAPIs.yaml post /eventmgr/v1/event/runtime
openapi: 3.0.1
info:
  title: MarketONE APIs
  description: >
    The MarketONE OpenAPIs provide a quick and easy way to access MarketONE
    features and your data. These APIs let Resellers (Service Providers) and
    Merchants work together to resell products and handle billing on a single
    platform.


    With an API key, you can authenticate and perform various tasks, like
    accessing and managing data. You can use an HTTP client in any programming
    language to send HTTP requests to MarketONE to create, edit, or delete data.
    The data you work with, like subscriptions or entitlements, are called
    resources, and each resource has its own endpoint (URL).


    The MarketONE OpenAPIs use built-in HTTP features, like HTTP authentication
    and HTTP verbs, which are easy for standard HTTP clients to understand. They
    also use HTTP response codes to indicate errors. All responses, including
    errors, are in JSON format, but our API libraries convert them into objects
    that are specific to the programming language you're using. 


    You can also download the MarketONE OpenAPIs in a YAML file, which is easy
    to read and manage.


    For more information about the MarketONE OpenAPIs, see the [API Reference
    Guide for Merchants](https://docs.saas.amdocs.com/bundle/b_partnerAPIGuide/)
    and the [API Reference Guide for Resellers (Service
    Providers)](https://docs.saas.amdocs.com/bundle/b_aggregatorAPIGuide).


    ## Other MarketONE APIs


    Other MarketONE APIs, such as the [Reseller (CSP) Adapter
    OpenAPIs](https://docs.saas.amdocs.com/bundle/MarketONECSPAdapter/page/index.html),
    the [Merchant (OTT) Service
    Callbacks](https://docs.saas.amdocs.com/bundle/MarketONEOTTServiceCallbacks/page/index.html),
    and the [Commerce Gateway
    OpenAPIs](https://docs.saas.amdocs.com/bundle/Amdocs_Media-Commerce-Gateway-Latest-resolved/page/index.html),
    are available to provide additional services for specific organizations.


    # Environments


    MarketONE provides two distinct environments for testing and production:

    - **Prodtest environment**: this is a pre-production environment allowing
    you to test your application with test data. Use server
    <https://int-prodtest.m1amdocs.io/>.

    - **Production environment**: this is the live environment for the
    real-world implementation of  data. Use server <https://int.m1amdocs.com/>.


    # HTTP Verbs


    The MarketONE OpenAPIs support the following HTTP verbs:

    - **GET**: Retrieve resources (as a list or single record fetch).

    - **POST**:  Create new resources or update existing ones (overloading
    during create/update is permitted where specified).

    - **PUT**: Create a new resource or replace a resource with the request
    payload.

    - **DELETE**: Remove ownership or hierarchical association between certain
    resources.


    #  Example

     ## Request Example

     ```
    POST /v1/entitlement 

    Content-Type: application/json

    {
      "account": {
        "id": "2922fbf1-1dc4-2293-9d0e-c9a46630ad6e"
      },
      "subscriptionId": "ef1917b8-4a06-4595-9998-718799a33ed6",
      "productCodes": [
        "Basic_Addon"
      ],
      "metadata": {
        "email": "j.smith@email.com"
      }
    }

    ```

      ## Response Example

    ```

    Response: 200 OK

    Content-Type: application/json

    [
      {
        "partnerSubscriptionId": "80e08955-b0e9-4ba6-b882-b24230bfc703",
        "account": {
          "id": "0006fbf1-1ac4-4793-9d0e-c0a0080ad6e",
          "partnerCustomerId": "1bbbb3a5-0f05-4009-b4ae-b01f7eba7g"
        },
       "subscriptionId": "ef1417b8-4a06-7775-8518-718714a33ed2",
        "externalPartnerSubscriptionId": "7d50531-31eb-45f9-91ce-6355250f5501",
        "partnerCode": "PRTNR",
        "productCode": "Basic_Addon",
        "createdDate": "2024-05-04T17:38:10.889",
        "updatedDate": "2024-05-04T17:38:11.160",
        "startServiceDate": "2024-05-04T17:38:10.889",
        "serviceStatus": "PROVISION-COMPLETE"
      }
    ]

    ```


    # Status Codes


    MarketONE uses the following HTTP response codes to indicate the success or
    failure of an API request.


    | Code | Status | Description |

    | -------  | ------   | ------------------- |

    | **200** | OK | Everything worked as expected. |

    | **201** | OK | Everything worked as expected. |

    | **400** | Bad Request | The request was unacceptable, often due to missing
    a required parameter. Other possibilities include: <ul><li>A parameter
    doesn't fit the data type</li><li>A parameter is outside the maximum or
    minimum boundaries of what can be accepted.</li> |

    | **401** | Unauthorized | Couldn’t authenticate your request. This could be
    due to a wrong or invalid API key. |

    | **403** | Forbidden | Authentication failed. Check your username and
    password. |

    | **404** | Not Found | The requested resource doesn’t exist. |

    | **409** | Conflict | |

    | **429** | Too Many Requests | Too many requests were made to the API too
    quickly. |

    | **500** | Internal Server Error  | |

    | **501** | Not Implemented | |

    | **503** | Service Unavailable | We’re temporarily offline for maintenance.
    Please try again later. |


    # Authentication


    API keys are required to make requests to the MarketONE OpenAPIs. In Partner
    Ecosystem Management, Resellers (Service Providers) can conveniently
    [generate an API
    key](https://docs.saas.amdocs.com/bundle/b_userGuideForResellers/page/topics/apiKeysAggregatorManage_t.html).
    Merchants can also [generate an API key for each Reseller (Service Provider)
    partnership](https://docs.saas.amdocs.com/bundle/b_userGuideForMerchants/page/topics/apiKeysManage_t.html)
    in Partner Ecosystem Management. After you authenticate with your API
    key(s), you can access resources through the MarketONE OpenAPIs.


    Each API key is a JSON Web Token (JWT) that doesn't expire. For every API
    call you make to the MarketONE OpenAPIs, the API key must be included in the
    header (`X-API-KEY`) of the call to ensure trusted communication. All
    communication is HTTP(s) based and supports SSL/TLS encryption.


    # Errors


    All error responses will return an error object.


    # Attributes


    | Name | Type | Required/Optional | Description |

    | -------  | ------ | ------ | ------ |

    | **code** | string | required | The error type, such as
    "authentication-required" (401) or "not-found" (404). |

    | **message** | string | required | A human-readable message providing more
    detailed information about the error. |

    | **validationErrors** | object | optional | An array of validation errors
    with **code** and **message** attributes provided. |
  license:
    name: Amdocs Inc.
    url: http://www.amdocs.com
  version: Released
servers:
  - url: https://int-prodtest.m1amdocs.io/
    description: Sandbox server (uses test data)
  - url: https://int.m1amdocs.com/
    description: Production server (uses live data)
security: []
paths:
  /eventmgr/v1/event/runtime:
    post:
      tags:
        - event
      summary: Post external runtime entity events
      description: >-
        API to notify MarketONE of significant runtime (devices) lifecycle
        events occured outside MarketONE.
      operationId: runtimeEvent
      parameters:
        - name: X-B3-TraceId
          in: header
          description: >-
            The TraceId indicates the overall ID of the trace. Every span in a
            trace shares this ID. The X-B3-TraceId header is encoded as 32 or 16
            lower-hex characters. For example, a 128-bit TraceId header might
            look like 463ac35c9f6413ad48485a3953bb6124.
          required: false
          style: simple
          explode: false
          schema:
            type: string
        - name: X-B3-SpanId
          in: header
          description: >-
            The SpanId is 64-bit in length and indicates the position of the
            current operation in the trace tree. The value should not be
            interpreted; it may or may not be derived from the value of the
            TraceId. The X-B3-SpanId header is encoded as 16 lower-hex
            characters. For example, a SpanId header might look like
            a2fb4a1d1a96d312. Unless propagating only the Sampling State, the
            X-B3-SpanId header is required.
          required: false
          style: simple
          explode: false
          schema:
            type: string
        - name: X-B3-ParentSpanId
          in: header
          description: >-
            The ParentSpanId is 64-bit in length and indicates the position of
            the parent operation in the trace tree. When the span is the root of
            the trace tree, there is no ParentSpanId. The X-B3-ParentSpanId
            header may be present on a child span and must be absent on the root
            span. It is encoded as 16 lower-hex characters. For example, a
            ParentSpanId header might look like 0020000000000001.
          required: false
          style: simple
          explode: false
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/RuntimeEvent'
        required: true
      responses:
        '200':
          description: OK
        '400':
          description: Invalid Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/400Error'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/401Error'
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/404Error'
        '500':
          description: Server Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/500Error'
      security:
        - ApiKeyAuth: []
components:
  schemas:
    RuntimeEvent:
      required:
        - runtime
        - type
      type: object
      properties:
        id:
          maxLength: 36
          type: string
          description: the event id provided by application generating the event.
        applicationName:
          maxLength: 128
          type: string
          description: the name of the application sending this event
          example: BSS
        type:
          type: string
          enum:
            - deleted
            - updated
        runtime:
          $ref: '#/components/schemas/Runtime'
    400Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - invalid-request
        message:
          type: string
        validationErrors:
          type: array
          items:
            $ref: '#/components/schemas/400ValError'
    401Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - authentication-required
            - invalid-api-key
            - api-key-not-found
        message:
          type: string
    404Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - not-found
        message:
          type: string
    500Error:
      required:
        - code
      type: object
      properties:
        code:
          type: string
          enum:
            - server-error
        message:
          type: string
    Runtime:
      title: Runtime
      type: object
      properties:
        activatedDate:
          type: string
          description: The entity’s activation date and time, expressed in UNIX Epoch time
          format: date-time
        attributes:
          type: array
          description: A list of custom data fields that help to define the ULM entity.
          items:
            $ref: '#/components/schemas/Attribute'
        buildType:
          type: string
          description: >-
            The customer-defined build type of this specific runtime. This can
            be used to discriminate between known beta versus production
            hardware.
          example: Production
        createdDate:
          type: string
          description: The entity’s creation date and time in UNIX Epoch time
          format: date-time
        customer:
          type: string
          description: The customer-defined brand name that discriminates the runtime.
          example: Apple
        deactivatedDate:
          type: string
          description: >-
            The entity’s deactivation date and time, expressed in UNIX Epoch
            time
          format: date-time
        deviceType:
          type: string
          description: The runtime’s type of physical device
          example: phone
        displayName:
          type: string
          description: The display name of the entity
          example: Paul's iPad
        guid:
          type: string
          description: ' The global unique identifier of the runtime provided at login. If this is not provided by the customer, ULM will assign one for tracking purposes.'
          example: DEF123
        id:
          type: integer
          description: >-
            The unique ID number of the ULM entity, association, or activation
            template
          format: int64
          example: 1
        platformType:
          type: string
          description: The runtime’s platform type
          example: android
        status:
          type: string
          description: >-
            The status of the entity. Possible values include:

            • activating - The entity has been provisioned, but is not yet ready
            to be used or consumed.

            • activated - The entity is active, and the functionality to which
            it is tied is enabled.

            • suspended - The entity is temporarily deactivated, but can be
            reactivated in the future.

            • deactivated - The entity is permanently deactivated, and may be
            deleted from the system in the near future.

            • pending - The entity has been added but is not yet verified for
            use.  It may be linked to an existing entity in order to eventually
            replace the original entity.

            • unknown - This is a generic, catch all state for specific
            entities.


            Note: This  field is the current status in GET calls, and the
            desired status in PUT and POST calls.
          example: activated
        suspendedDate:
          type: string
          description: The entity’s suspension date and time, expressed in UNIX Epoch time
          format: date-time
        type:
          type: string
          description: >-
            Certain entities can have more than one type, and this depends on
            the client-specific implementation. 
          example: com.uxpsystems.ulm.entity.RegularEntityType
        updatedDate:
          type: string
          description: >-
            The most recent date and time that the entity was updated, expressed
            in UNIX Epoch time
          format: date-time
        userAgent:
          type: string
          description: The runtime’s browser and operating system information
          example: >-
            Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
            like Gecko) Chrome/71.0.3578.98 Safari/537.36
        version:
          type: string
          description: The runtime’s version
          example: 4.1.1
      description: >-
        The data model that contains the possible runtime properties. Some
        properties come on a ULM entity by default. Service providers can create
        and add their own additional properties in order to extend the ULM
        platform.
    400ValError:
      required:
        - code
      type: object
      properties:
        code:
          type: string
        message:
          type: string
    Attribute:
      title: Attribute
      type: object
      properties:
        details:
          type: object
          description: |
            A well-structured JSON format of the attributes. JSON could be: 

            • String - for example {
            "details":"emails":
            }. 

            • Integer - for example {
            "details":20
            }. 

            • Array of Objects - for example  {
            "details":[{"country":"ca",
             "id":12, 
            "number":"111-111-1111"}]
            }. 
        name:
          type: string
          description: The name of the attribute
          example: operationsSupportSystemNumber
        value:
          type: string
          description: The value of the attribute
          example: abc123
      description: >-
        Data fields used in an attribute. Not all fields may be present in a GET
        response. 


        Some attributes may come with a ULM entity by default. Service providers
        can create and add their own additional attributes in order to extend
        the ULM platform. Attributes must be whitelisted before they can be
        added and used.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      description: The authorization key obtained from MarketONE.
      name: X-API-KEY
      in: header

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.