Pool Resource Model Object Reference #

The PoolResourceModel object describes resources, demand, consumption, events, costs, rules, and constraints that govern future pool resource states, quantities, and license positions with respect to time.

  {
    "Settings": {},
    "SimulationRules": {},
    "EvolutionRules": {},
    "ValuationRules": {},
    "NewServerConfiguration": {},
    "PowerConsumptionTerms": {},
    "FacilityConsumptionTerms": {},
    "SoftwareResources":{
        "PoolSoftwareStack":[],
        "SoftwareInventoryTerms":[]
    },
    "ServerInventory":[],
    "JumpEvents":[],
    "Constraints":[]
  }

Attributes #

Settings - object - required #

Properties for scenario handling. #

SimulationRules - object - required #

Sets the objective function of the simulation and related attributes. #

EvolutionRules - object - required #

Rules for how pool resources evolve over time. #

ValuationRules - object - required #

Defines financial attributes for how resources are valued. #

PowerConsumptionTerms - object - required #

Defines terms for electricity consumption. #

FacilityConsumptionTerms - object - required #

Defines terms for facility space consumption. #

NewServerConfiguration - object - required #

Sets configuration of a new server or rack inventory that will be added to the pool. #

SoftwareResources - object - required #

Parent object of PoolSoftwareStack and SoftwareInventoryTerms objects. #

PoolSoftwareStack - array of integers - required #

Array that contains license ids which defines the initial software stack of the pool. License ids correspond to license terms defined in SoftwareInventoryTerms object. #

SoftwareInventoryTerms - array of objects - required #

Array that contains objects which describe license counting (i.e., consumption) and cost terms. #

ServerInventory - array of objects - required #

Array that contains objects which describe initial server or rack inventory of the pool. #

JumpEvents - array of objects - required #

Array that contains objects which define discrete events which may influence a pool's compositional state. #

Constraints - array of objects - optional #

Array that contains objects which define constraints to restrict a pool's acceptable compositional state. #

Settings #

This object is for configuring scenario properties.

  {
    "Version:": "1.0",
    "ScenarioName": "My Scenario Name",
    "ModelEffectiveDate": "2022-10-07T00:00-05",
    "EmailResults": true,
    "Pool": {
      "Id": "ATL1_42_PROD",
      "Name": "Name of service pool",
      "Description": "A long description of pool"
    }
  }

Attributes #

Version - string - optional #

Pool Resource Model version number. Default value is '1.0'. #

ScenarioName - string #

Name of this scenario. #

ModelEffectiveDate - date (YYYY-MM-DDT00:00:Z) - optional #

Sets the ScenarioStartDate property to this value. If left blank, the scenario start date of the resources forecast is set to the date the scenario is created. The ModelEffectiveDate cannot be a future date beyond the current date. To designate your local time zone, enter the time offset from universal time (e.g., New York on standard time would be Z-05:00). If only the date portion is entered, the time zone will be set to universal time. #

EmailResults - boolean - optional #

An email is sent notifying you the simulation request has completed. A successfully completed simulation will have attached the ResourceRequirementsForecast object. The default setting of this property is false. If a critical error is encountered by the simulator or the host that is running the simulator, an email is sent notifying you. Non-critical errors, such as your model fails validation, do not trigger an email notification. #

Pool - object - optional #

A reserved property name to custom describe attributes of a resource pool. This property is only validated for well-formed JSON. Users may append any valid JSON, which will be returned on the Scenario object when the Scenario object includes the ResourceRequirementsForecast. #

Simulation Rules #

This SimulationRules object defines the objective function of a scenario with respect to cost scope and time.

  {
    "SimulationType": "Optimal",
    "SimulationCostScope": "All",
    "ScenarioDuration": "5",
    "FindSolutionMetricType": "TotalCumulativeCostPerYear",
    "ServerReplacementTime": ""
  }

Attributes #

SimulationType - string - required #

Sets type of simulation. #

SimulationCostScope - string - required #

Sets which resource costs are included in simulation. #

ScenarioDuration - numeric - required #

Sets the minimum duration for time-series solution. Unit is years. #

FindSolutionMetricType - string - required #

Sets metric used to find solution for SimulationType 'Optimal' #

ServerReplacementTime - numeric - conditionally required #

Sets preferred time of server refresh. Required when SimulationType property 'Fixed' is selected. #

Evolution Rules #

This EvolutionRules object defines the boundary conditions and rules for how pool server inventory is permitted to evolve.

  {
    "PoolUtilizationPercentCurrent": 63.5,
    "PoolUtilizationBoundaryPercentLower": 63.0,
    "PoolUtilizationBoundaryPercentUpper": 65.0,
    "ServiceDemandGrowthPercent": 20.5,
    "InventoryQueueBias":  "Auto",
    "LotUnit": "Server"
  }

Attributes #

ServerUtilizationPercentCurrent - numeric - required #

Actual pool utilization percent at start of scenario. #

ServerUtilizationPercentBase - numeric - required #

Targeted minimum utilization percent for pool. This value constrains how much hardware capacity is added to the pool at a capacity addition event. #

ServerUtilizationPercentPeak - numeric - required #

Targeted maximum utilization percent for pool. This value, when reached, triggers a capacity addition event to the pool. #

ServiceDemandGrowthPercent - numeric - required #

Projected service demand growth percent for pool. The minimum accepted value is one percent. #

InventoryQueueBias - string - optional #

Queue order for how server inventory is sequenced for removal when SimulationType property is 'Optimal'. Queue order is based on hardware unit performance rating. Default is 'Auto'. #

LotUnit - object - optional #

Sets the inventory lot unit used in add/remove transactions. Default value is 'Server'. #

Valuation Rules #

This ValuationRule object defines parameters for defining the financial value of pool resources.

  {
    "DiscountPercent": 10,
    "IncludeServerResidualValue": true,
    "ResidualValueBidAskSpreadPercent": 40,
    "InitialServerInventoryIsNew": false
  }

Attributes #

DiscountRate - numeric - required #

Percentage used to convert future financial data into present value. #

IncludeServerResidualValue - boolean - optional #

Determines if server residual value is included in a server's net cost when removed from a pool. The default value is 'true'. #

InitialInventoryIsNew - boolean - optional #

Determines if initial inventory in ServerInventory object is new and therefore the current server ServerUnitCost property is applied. Default value is 'false'. #

New Server Configuration #

This NewServerConfiguration object sets the configuration attributes for new servers that are added to a pool consistent with the lot unit indicated by the LotUnit property in the EvolutionRules object.

This code block defines the object when the lot unit is 'Server'.

  "EvolutionRules": {
    "LotUnit": "Server"
    } 

  "NewServerConfiguration": {
    "ServerCost": 10000,
    "ServerPerf": 130,
    "ServerWatts": 435,
    "ServerSize": 2,
    "ProcessorSetSize": 2,
    "CoreSetSize": 24,
    "Tag": {
      "Model":"SZ260"
    }
    }

Attributes (unique to server lot unit) #

ServerCost - numeric #

Unit cost of server added to inventory. #

  This code block defines the object when the lot unit is 'Rack'.

  "EvolutionRules": {
    "LotUnit": "Rack"
    } 

  "NewServerConfiguration": {
    "RackSize": 42,
    "RackServerQty": 21,
    "RackCost": 210000,
    "ServerPerf": 130,
    "ServerWatts": 435,
    "ServerSize": 2,
    "ProcessorSetSize": 2,
    "CoreSetSize": 24,
    "Tag": {
      "Model":"RZ260"
    }
  }

Attributes (unique to rack lot unit) #

RackSize - integer #

Quantity of available rack units using rack unit 'U' rating. #

RackServerQty - integer #

Quantity of servers that populate the rack. #

RackCost - integer #

Unit cost of a populated rack added to inventory. #

Attributes (common) #

ServerPerf - numeric - required #

Scalar value representing server's relative performance rating. #

ServerWatts - integer - required #

Electrical power consumption rating in watts. #

ServerSize - integer - required #

Rack unit 'U' rating. Valid values are 1, 2, 4, 8 (i.e., 1U, 2U, 4U, 8U). #

ProcessorSetSize - integer - required #

Quantity of physical processors contained in a server's cpu sockets. #

CoreSetSize - integer - required #

Quantity of cores contained in physical processor. #

Tag - object - optional #

A reserved property name to custom describe a hardware unit (e.g., model) to minimally cross-reference to a user-maintained list. The property is only validated for well-formed JSON. #

Power Consumption Terms #

This PowerConsumptionTerms object defines power consumption and its cost.

  {
    "PoolPowerDrawPercent": "80",
    "DatacenterPowerkWhCostRate": ".115",
    "DatacenterPue": "1.6",
    "PowerCostInflationPercent": "3.5"
  }

Attributes #

PoolPowerDrawPercent - numeric - required #

Adjustment factor to tune actual consumption with respect to server watts rating versus metered use. #

DatacenterPowerkWhCostRate - numeric - required #

Unit cost rate per kilowatt hour. #

DatacenterPue - numeric - required #

Power Usage Effectiveness (PUE) rating. #

PowerCostInflationPercent - numeric - required #

Annual inflation percent for DatacenterPowerkWhCostRate property. #

Facility Consumption Terms #

This FacilityConsumptionTerms object defines data center space consumption and its cost.

  {
    "PowerConsumptionMarkupPercent": "0",
    "FacilitySpaceUnitCost": "65",
    "UnitCostInflationPercent": "2.75"
  }

Attributes #

PowerConsumptionMarkupPercent - numeric - optional #

Markup percentage on power consumption cost if facility fee includes or is solely based on power consumption. Default is 0. #

FacilitySpaceUnitCost - numeric - optional #

Represents the annualized unit cost for physical space based on 1U rack unit. Default is 0. #

UnitCostInflationPercent - numeric - optional #

Annual inflation factor applied to FacilitySpaceUnitCost property only. Default is 0. #

Software Resources #

This SoftwareResources object defines the initial software stack of a pool and software inventory terms.

  {
    "PoolSoftwareStack": [1,2,3],
    "SoftwareInventoryTerms": [..]
  }

Attributes #

PoolSoftwareStack - array of integers - conditionally required #

Integer value corresponding to LicenseId property in SoftwareItem object. Sets the initial software stack for servers or racks included in ServerInventory object. Required when the SimulationCostScope property in SimulationRules object includes software costs. #

Software Inventory Terms - array of objects - conditionally required #

List of SoftwareItem objects. Required when the SimulationCostScope property in SimulationRules object includes software costs. #

Software Item #

This SoftwareItem object defines software license terms and initial entitlement quantity.

  {
    "LicenseId": 1,
    "LicenseMetric": "Processor",
    "LicenseClass": "Perpetual",
    "ContractType": "Coterminous",
    "ContractTerms": {..},
    "Fee": 6000,
    "PerpetualSupportPercent": 25,
    "InitialPosition": null,
    "ConsumptionRules":  {..},
    "Tag": {
      "SKU": xx-xxx-xxx-xxx"
    }
  }

Attributes #

LicenseId - integer - required #

Unique number for identifying the specific license terms. #

LicenseMetric - string - required #

Hardware unit used by vendor for counting license consumption. #

LicenseClass - string - required #

Valid license classes are: 'Perpetual', 'Subscription'. A perpetual license governed by a ContractType of 'Coterminous' will have an accompanying financial obligation for support (see Software Cost Rules), whereas a ContractType of 'Instance' does not include any support. #

ContractType - string - required #

Determines the rules and costs of software consumption. #

ContractTerms - object - conditionally required #

Contains properties to define software consumption terms. Required when ContractType property is 'Coterminous'. Not applicable to 'Instance' contract type. #

Fee - numeric - required #

Amount paid per license. Fee may represent a one-time perpetual license fee, or the annualized fee for a subscription license. #

PerpetualSupportPercent - numeric - optional #

Percentage of one-time perpetual license fee that is incurred annually. #

InitialPosition - integer - optional #

Indicates the starting license position (i.e., quantity of paid licenses). Default is null. #

ConsumptionRules - object - optional #

This ConsumptionRules object defines how required license position is determined with respective to hardware configuration, transactions and inventory balances. Consumption rules may be applied to both coterminous and instance contract types.

If license consumption is defined based upon "conditional rules", Zypr invokes its rule engine to evaluate the conditional logic. The code block below illustrates a rule with no conditional logic. How to define more conditional rules is covered in Software License Rule Engine section. #

  {
    "ConsumptionRules":  {
        "Id": "1",  
        "RequiredLicenseQty": "1"
    }
  }

Tag - object - optional #

A reserved property name to custom describe a software item (e.g., SKU property ) to minimally cross-reference to a user-maintained list. The property is only validated for well-formed JSON. #

Software Contract Terms #

This ContractTerms object defines key elements of a software publisher's license terms. Zypr uses this information to auto-generate a settlement calendar and schedule of how vendor prices might change over time.

This object is required when the ContractType property value is 'Coterminous'.

"ContractTerms": {			
    "AnniversaryDate" : "2024-06-1T00:00:00 -5",  // TZ - Eastern Standard Time 
    "TermLength": 3,
    "AnnualTrueUpMonth": 9,
    "CreateSettlementCalendar": "Custom",
    "RenewalSchedule": "Contract",
    "AttemptPositionReset": true, 
    "CostRules": []
} 

AnniversaryDate - date - required #

The next upcoming actual (or planned) date when the controlling license agreement ends and subsequently renews. Therefore, this date needs to be after the simulation ModelStartDate property value, which will be the same as the ModelEffectiveDate property value if set, or if not set, then the ScenarioCreateDate property value. #

TermLength - numeric - required #

Number of years a contract or license is in effect. Please note that a non-whole number will impact settlement calendar generation options (i.e., generated schedules will not all coincide on the same month and day). #

AnnualTrueUpMonth - integer - optional #

Annual month when true-up will occur. Default is month of AnniversaryDate property value. #

CreateSettlementCalendar - string - required #

Determines the unique settlement schedule Zypr automatically creates for this software item. Refer to the Settlement Calendar Codes for how to shape the calendar to your needs. #

RenewalSchedule - string - optional #

Schedule used to generate automatic renewals. Valid values are: 'TrueUp' or 'Contract'. Default is 'Contract'. #

AttemptPositionReset - boolean - optional #

Set this property to 'true' permit attempt license position reduction. A license position reduction is not guaranteed. Default is 'false'. This feature can only be used on multiple software items with the same LicenseMetric property value. #

CostRules - array of objects - optional #

Defines publisher's rules that Zypr uses to generate the unit price rate schedule with respect to annual true-up and/or contract anniversary date. For subscription licenses or perpetual support agreements, defines publisher's rules that Zypr uses to generate the fix unit duration charge schedule with respect to annual true-up and/or contract anniversary date. #

Software Cost Rules #

This CostRules object enables customizations to define a software vendor's price schedule, fixed duration fees, and when costs are posted in the time-series output.

This object is optional. If the LicenseClass property value is 'Perpetual', and the CostRules property is omitted, empty, or null, Zypr will automatically generate the following default object.

This default setting means there will be no change to either the Fee or PerpetualSupportPercent properties in the SoftwareItem object. Any incremental cost associated to an incremental increase in software consumption will be posted at 'FirstUse'.

Duration-based costs are calculated based on actual use duration.

"CostRules": [		
  {			
    "LicenseType" : "Perpetual", 
    "PostAt": "FirstUse",  
    "Rate": {
      "Schedule": "None",
      "ChangePercent": 0,
    }
  },
  {			
    "LicenseType" : "PerpetualSupport", 
    "PostAt": "FirstUse",
    "Rate":{
      "Schedule": "None",
      "ChangePercent": 0,
      },
    "Duration": {
      "Schedule": "None",
      "IntervalPercent": 0
      }
  }
]

If the LicenseClass property value is 'Subscription', and the CostRules property is omitted, empty, or null, Zypr will automatically generate the following default object.

Any incremental cost associated to an incremental increase in software consumption will be posted at 'FirstUse'.

"CostRules": [		
  {			
    "LicenseType" : "Subscription", 
    "PostAt": "FirstUse",  
    "Rate": {
      "Schedule": "None",
      "ChangePercent": 0,
    },
    "Duration": {
      "Schedule": "None",
      "IntervalPercent": 0
    }
  }
]  

Attributes #

LicenseType - string - conditionally required #

Required if LicenseClass property is 'Perpetual' in order to distinguish between perpetual license and annual support fees. Valid values are: Perpetual, PerpetualSupport, Subscription. If LicenseClass is 'Subscription', this property may be omitted. #

PostAt - string - optional #

Identifies when an incremental cost is recorded in the time-series. Default is 'FirstUse'. Valid values are: FirstUse, TrueUp, Contract. Value of 'TrueUp', or 'Contract' means an incurred incremental cost is recorded at the next respective anniversary date. #

Rate - object - optional #

Sets the fee schedule. #

Schedule (Rate) - string - optional #

Sets schedule to use for determining the effective date of a price change. Valid values are: 'None', 'TrueUp', 'Contract'. A value of 'None' means the ChangePercent property value, if specified, will be applied as a continuous rate. Values of either 'TrueUp' or 'Contract' means the ChangePercent property value is only applied at the start of schedule interval and remains unchanged until the start of the next interval period. Default value is 'None'. #

ChangePercent - numeric - conditionally required #

Annualized percentage change that is applied to fees in SoftwareItem object. Value can be positive or negative percentage. Only required if Schedule property value is either 'TrueUp' or 'Contract'. Default value is 0; #

Duration - object - optional #

Converts variable duration costs into a fixed duration cost for an incremental increase in a required license position. May only be applied to duration dependent subscription fee and/or perpetual support license types. #

Schedule (Duration) - string - optional #

Sets calendar to use when calculating a fixed duration. Valid values are: FirstUse, TrueUp, Contract. 'FirstUse' means use duration is not modified and remains the duration of actual consumption. When 'TrueUp' or 'Contract' is selected, their respective interval duration is applied to the IntervalPercent property value to arrive at a fixed duration. Default value is 'FirstUse'. #

IntervalPercent - numeric - conditionally required #

Percentage of interval time, per selected schedule, used to set fixed duration. Value must be between 0-100, inclusive. Only required if Schedule property value is 'TrueUp' or 'Contract'. Default value is 0. #

Software Consumption Rule Engine #

Zypr's rule engine supports rule nesting using the Rules array property. Conditional rules always start with two root properties: Operator and Rules. When defining nested rules, it is important to ensure rules are mutually exclusive, yet account for all feasible values to which the rule might be applied.

At the root-level, the "Or" operator is mandatory and denotes its chid rules are mutually exclusive. At this level, the rules must account for all feasible "counting" outcomes and not overlap (i.e., an outcome can be evaluated as true for two or more rules). A publisher's specific counting methodology can then be further expressed using nested rules, as illustrated in the code block below.

For example, both consumption rule objects below correspond to a processor-based license (i.e., LicenseMetric property is 'Processor').

  
  "ConsumptionRules": {
      "Operator": "Or",
      "Rules": [
        {
          "Id": "1",
          "RequiredLicenseQty": 1,
          "MetricName": "CoreSetSize",
          "Operator": "LessThanOrEqual",
          "TargetValue": 32
        },
        {
          "Id": "2",
          "RequiredLicenseQty": 2,
          "MetricName": "CoreSetSize",
          "Operator": "GreaterThan",
          "TargetValue": 32
        }
      ]
    }

"ConsumptionRules": {
    "Operator": "Or",
    "Rules": [
      {
        "Id": "1",
        "RequiredLicenseQty": 1,
        "MetricName": "CoreSetSize",
        "Operator": "LessThanOrEqual",
        "TargetValue": 32
      },
      {
        "Id": "2",
        "Operator": "And",
        "RequiredLicenseQty": 2,
        "Rules": [
            {
              "Id": "2.1",
              "MetricName": "CoreSetSize",
              "Operator": "GreaterThan",
              "TargetValue": 32
            },
            {
              "Id": "2.2",
              "MetricName": "CoreSetSize",
              "Operator": "LessThanOrEqual",
              "TargetValue": 64
            }
        ]
      },
      {
        "Id": "3",
        "RequiredLicenseQty": 3,
        "MetricName": "CoreSetSize",
        "Operator": "GreaterThan",
        "TargetValue": 64
      }
    ]
  }

Attributes #

Operator - string - conditionally required #

Logical operator for comparing multiple Rules. Valid values are: Or, And. #

Id - string - required #

Unique id for identifying different rules. #

RequiredLicenseQty - numeric - required #

Required quantity of licenses for "Basic" rule, or if "Conditional" rule, when boolean logic resolves to true. #

MetricName - string - required #

Physical inventory target. Valid values are: ProcessorSetSize, CoreSetSize. #

Operator - string - required #

Comparison operator. Valid values are: #

• Equal
• GreaterThan
• GreaterThanOrEqual
• LessThan
• LessThanOrEqual

TargetValue - integer - required #

Quantity to which actual use (i.e., consumption) is compared. #

Server Inventory #

This ServerInventory object defines a collection of initial server inventory of a pool.

  {
    "ServerInventory": []
  }

Attributes #

ServerInventory - array of objects - required #

List of ServerItem objects. #

Server Inventory Item #

This object defines a collection of servers (or racks) with the same configuration. A record for each server is not required.

Each item must represent a unique configuration and will fail validation if duplicate entries are discovered. Uniqueness is defined by all an inventory item properties, except Code and ServerQty (or RackQty) properties.

The Code property provides a means to describe the inventory item (e.g., reference to a master list). Zypr doesn't validate or use this value.

This code block defines the object when the lot unit is a server.

"ServerInventory": [
  {
    "ServerQty": 5,
    "ServerPerf": 105,
    "ServerWatts": 425,
    "ServerSize": 1,
    "ProcessorSetSize": 2,
    "CoreSetSize": 8,
    "InitialAge": 3.75,
    "Tag": {
      "Model": SQ320"
    }
  }
]

Attributes (unique to server lot unit) #

ServerQty - integer - required #

Quantity of servers. #

This code block defines the object when the lot unit is a rack.

 "ServerInventory": [
  {
    "RackQty": 8,
    "RackSize": 42,
    "RackServerQty": 21,
    "ServerPerf": 105,
    "ServerWatts": 425,
    "ServerSize": 1,
    "ProcessorSetSize": 2,
    "CoreSetSize": 8,
    "InitialAge": 3.75,
    "Tag": {
      "Model": SQ320"
    }
  }
]

Attributes (unique to rack lot unit) #

RackQty - integer - required #

Quantity of racks. #

RackSize - integer - required #

Quantity of available rack units using rack unit 'U' rating. #

RackServerQty - integer - required #

Quantity of servers that populate the rack. #

Attributes (common) #

ServerPerf - numeric - required #

A scalar value indicating server's relative efficiency rating to other servers. #

ServerWatts - integer - required #

Electrical power consumption rating in watts. #

ServerSize - integer - required #

Represents 'U' unit rating. Valid values are 1, 2, 4, 8 (i.e., 1U, 2U, 4U, 8U). #

ProcessorSetSize - integer - required #

Quantity of physical processors contained in a server's cpu socket. #

CoreSetSize - integer - required #

Quantity of cores contained in physical processor. #

InitialAge - numeric - optional #

Chronological age of servers. Only required when SimulationType property is set to 'Fixed' #

Tag - object - optional #

A reserved property name to custom describe a hardware unit (e.g., model) or cross-reference to a user-maintained list. The property is only validated for well-formed JSON. #

Jump Events #

This JumpEvents array defines a collection of jump events.

  {
    "JumpEvents": []
  }

Attributes #

JumpEvents - array of objects - required #

List of jump events that describe discrete changes to the evolution state of pool resources. Valid jump events are listed in the Jump Event Types object reference. #

Constraints #

This Constraints object defines a collection of Constraint objects that limit the feasible solution space.

  {
    "Constraints": [
      {
        ConstraintTypeName : {..}
      }
    ]
  }

Attributes #

Constraints - array of objects - required #

List of constraint items to limit feasible solutions. #

ConstraintTypeName - string - required #

Name of constraint object type. Valid values are: HardwareBalance, PowerUsage. #

Constraint #

Purpose #

This Constraint object defines a constraint type.

  {
    "HardwareBalance": {
      "Id": 1,
      "MetricName": "Server",
      "MetricConstraintOperator": "GreaterThan",
      "MetricTargetValue": 128,
      "TimeConstraintOperator": "After",
      "TargetTime": 2.0
    }
  },
  { 
    "PowerUsage": {
      "Id": 2,
      "MetricName": "kWh",
      "MetricConstraintOperator": "GreaterThan",
      "MetricTargetValue": 1150000,
      "TimeConstraintOperator": "After",
      "TargetTime": 3.5
    }
  }

Attributes #

Id - integer - required #

Unique number to identify constraint. #

MetricName - string - required #

MetricConstraintOperator - string - required #

Comparison operator to set constraint scope with respect to selected metric unit.
Valid values are: #

• LessThan
• LessThanOrEqual
• GreaterThan
• GreaterThanOrEqual
• NotEqual
• Equal

Targeted metric unit for constraint type. #

MetricTargetValue - integer - required #

Value that sets desired limit. #

TimeConstraintOperator - string - required #

Comparison operator to set constraint scope with respect to time.
Valid values are: #

• Before
• BeforeOrAt
• AtOrAfter
• After
• At
• NotAt
• Any

TargetTime - integer - optional #

Time within time-series when the constraint is applied. #