anchor.diff:  			{"isBundle", IsBundle}
   	end.
   
  --spec prod_status(Prefix, Product) -> Result
  -	when
  -		Prefix	:: erl_term | json,
  -		Product	:: list() | #product{},
  +-spec prod_status(Product) -> Result
  +	when
  +		Product	:: [tuple()] | #product{},
   		Result	:: string() | tuple().
   %% @private
  -prod_status(erl_term, Product) ->
  +prod_status(Product) when is_list(Product) ->
   	case lists:keyfind("lifecycleStatus", 1, Product) of
   		{_, FindStatus} ->
   			find_status(FindStatus);
   		false ->
   			undefined
   	end;
  -prod_status(json, Product) ->
  +prod_status(#product{} = Product) ->
   	case Product#product.status of
   		undefined ->
   			{"lifecycleStatus", ""};
  
positive.code: 		false ->
  			{undefined, undefined}
  	end;
  prod_price_alter_vf(json, PAlter) ->
  	ValidFor = PAlter#alteration.valid_for,
  	case ValidFor of
  		{undefined, undefined} ->
  			{"validFor", {struct, []}};
  
negative.code: %%----------------------------------------------------------------------
  %%  internal functions
  %%----------------------------------------------------------------------
  -spec product_offering_price(Product) -> Result
  	when
  		Product	:: [tuple()] | #product{},
  		Result	:: [#price{}] | [tuple()] | {error, Status},
  		Status	:: 400.
  %% @doc Encode/decode product offering price.
  %% @private
  product_offering_price([]) ->
  	{error, 400};
  product_offering_price(ObjectMembers) when is_list(ObjectMembers) ->
  	{_, {array, ProductOfferPrice}} = lists:keyfind("productOfferingPrice",
  			1, ObjectMembers),
  	case product_offering_price(ProductOfferPrice, []) of
  		{error, Status} ->
  			{error, Status};
  		Prices ->
  			Prices
  	end;
  product_offering_price(#product{} = Product) ->
  	case product_offering_price(Product#product.price, []) of
  		{error, Status} ->
  			{error, Status};
  		ProductOfferPrice ->
  			{"productOfferingPrice", {array, ProductOfferPrice}}
  	end.
  
  -spec product_offering_price(ProductOfPrice, Prices) -> Result
  	when
  		ProductOfPrice	:: [tuple()] | [#price{}],
  		Prices	::	list(),
  		Result	:: [#price{}] | [tuple()] | {error, Status},
  		Status	:: 400 | 500.
  %% @hidden
  product_offering_price([], Prices) ->
  	Prices;
  product_offering_price([{struct, ObjectMembers} | T], Prices) ->
  	try
  		ProdName = prod_price_name(ObjectMembers),
  		{_ProdSTime, _ProdETime} = prod_price_vf(ObjectMembers),
  		ProdPriceType = prod_price_type(ObjectMembers),
  		{_, {struct, ProdPriceObj}} = lists:keyfind("price", 1, ObjectMembers),
  		ProdAmount = prod_price_price_amount(ProdPriceObj),
  		CurrencyCode = prod_price_price_c_code(ProdPriceObj),
  		ProdVF = prod_price_vf(ObjectMembers),
  		RCPeriod = prod_price_rc_period(ObjectMembers),
  		ProdDescription = prod_price_description(ObjectMembers),
  		{ProdUnits, ProdSize} = prod_price_ufm(ObjectMembers),
  		Size = product_size(ProdUnits, octets, ProdSize),
  		Price1 = #price{name = ProdName, description = ProdDescription,
  				type = ProdPriceType, units = ProdUnits, size = Size, valid_for = ProdVF,
  				currency = CurrencyCode, period = RCPeriod, %validity = ProdValidity,
  				amount = ProdAmount},
  		case lists:keyfind("productOfferPriceAlteration", 1, ObjectMembers) of
  			false ->
  				product_offering_price(T, [Price1 | Prices]);
  			{_, {struct, ProdAlterObj}} ->
  				case po_alteration(ProdAlterObj) of
  					{error, Status} ->
  						{error, Status};
  					Alteration ->
  						Price2 = Price1#price{alteration = Alteration},
  						product_offering_price(T, [Price2 | Prices])
  				end
  		end
  	catch
  		_:_ ->
  			{error, 400}
  	end;
  product_offering_price([], Prices) ->
  	Prices;
  product_offering_price([#price{} = Price | T], Prices) ->
  	try
  		Name = prod_price_name(Price),
  		ValidFor = prod_price_vf(Price),
  		PriceType = prod_price_type(Price),
  		Amount = prod_price_price_amount(Price),
  		CurrencyCode = prod_price_price_c_code(Price),
  		PriceObj = {"price", {struct, [Amount, CurrencyCode]}},
  		RCPeriod = prod_price_rc_period(Price),
  		Description = prod_price_description(Price),
  		UOMeasure = prod_price_ufm(Price),
  		if
  			Price#price.alteration == undefined ->
  				Price1 = {struct, [Name, Description, ValidFor,
  					PriceType, PriceObj, UOMeasure, RCPeriod]},
  				product_offering_price(T, [Price1 | Prices]);
  			true ->
  				case po_alteration(Price#price.alteration) of
  					{error, Status} ->
  						{error, Status};
  					Alteration ->
  						Price1 = {struct, [Name, Description, PriceType,
  							ValidFor, PriceObj, UOMeasure, RCPeriod, Alteration]},
  						product_offering_price(T, [Price1 | Prices])
  				end
  		end
  	catch
  