/// <summary> 
		/// Retrieves the details of an extra attribute definition for the specified product type.
		/// <example> 
		///  <code> 
		/// var result = ProductTypeExtraFactory.GetExtra(handler : handler,  productTypeId :  productTypeId,  attributeFQN :  attributeFQN,  responseFields :  responseFields,  dataViewMode: dataViewMode,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<AttributeInProductType/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.ProductAdmin.AttributeInProductType GetExtra(ServiceClientMessageHandler handler, 
 		 int productTypeId, string attributeFQN, string responseFields = null,  DataViewMode dataViewMode= DataViewMode.Live, 
		 HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
		{
			SetSdKparameters();
			var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
			var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
			Debug.WriteLine(currentMethodName  + '.' + currentMethodName );
			var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeExtraClient.GetExtraClient(
				 productTypeId :  productTypeId,  attributeFQN :  attributeFQN,  responseFields :  responseFields, dataViewMode: dataViewMode		);
			try
			{
				apiClient.WithContext(handler.ApiContext).Execute();
			}
			catch (ApiException ex)
			{
				// Custom error handling for test cases can be placed here
				Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
				if (customException != null)
					throw customException;
				return null;
			}
			return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode) 
					 ? (apiClient.Result()) 
					 : null;

		}

        /// <summary> 
        /// 
        /// <example> 
        ///  <code> 
        /// var result = DocumentTypeFactory.GetDocumentTypes(handler : handler,  pageSize :  pageSize,  startIndex :  startIndex,  dataViewMode: dataViewMode,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<DocumentTypeCollection/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.Content.DocumentTypeCollection GetDocumentTypes(ServiceClientMessageHandler handler, 
 		 int? pageSize = null, int? startIndex = null,  DataViewMode dataViewMode= DataViewMode.Live, 
		 HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
        {
            SetSdKparameters();
            var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
            var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            Debug.WriteLine(currentMethodName  + '.' + currentMethodName );
            var apiClient = Mozu.Api.Clients.Content.DocumentTypeClient.GetDocumentTypesClient(
                 pageSize :  pageSize,  startIndex :  startIndex, dataViewMode: dataViewMode		);
            try
            {
                apiClient.WithContext(handler.ApiContext).Execute();
            }
            catch (ApiException ex)
            {
                // Custom error handling for test cases can be placed here
                Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
                if (customException != null)
                    throw customException;
                return null;
            }
            return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
                     ? (apiClient.Result())
                     : null;
        }

 /// <summary>
 /// Deletes a defined product attribute. You cannot delete an attribute assigned a value for a product.
 /// </summary>
 /// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
 /// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var attribute = new Attribute();
 ///   attribute.DeleteAttribute(dataViewMode,  attributeFQN);
 /// </code>
 /// </example>
 public virtual void DeleteAttribute(DataViewMode dataViewMode, string attributeFQN)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.AttributeClient.DeleteAttributeClient(dataViewMode,  attributeFQN);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Deletes the content associated with a document, such as a product image or PDF specifications file.
 /// </summary>
 /// <param name="documentListName">The name of the document list associated with the document.</param>
 /// <param name="documentName">The name of the document, which is unique within its folder.</param>
 /// <param name="stream"></param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var documenttree = new DocumentTree();
 ///   documenttree.DeleteTreeDocumentContent(dataViewMode,  stream,  documentListName,  documentName,  contentType);
 /// </code>
 /// </example>
 public virtual void DeleteTreeDocumentContent(DataViewMode dataViewMode, System.IO.Stream stream, string documentListName, string documentName, String  contentType= null)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Content.Documentlists.DocumentTree.DocumentTreeClient.DeleteTreeDocumentContentClient(dataViewMode,  stream,  documentListName,  documentName,  contentType);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

        /// <summary> 
        /// Configures a property attribute for the product specified in the request.
        /// <example> 
        ///  <code> 
        /// var result = ProductPropertyFactory.AddProperty(handler : handler,  productProperty :  productProperty,  productCode :  productCode,  dataViewMode: dataViewMode,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<ProductProperty/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.ProductAdmin.ProductProperty AddProperty(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.ProductAdmin.ProductProperty productProperty, string productCode,  DataViewMode dataViewMode= DataViewMode.Live, 
		 HttpStatusCode expectedCode = HttpStatusCode.Created, HttpStatusCode successCode = HttpStatusCode.Created)
        {
            SetSdKparameters();
            var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
            var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            Debug.WriteLine(currentMethodName  + '.' + currentMethodName );
            var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.AddPropertyClient(
                 productProperty :  productProperty,  productCode :  productCode, dataViewMode: dataViewMode		);
            try
            {
                apiClient.WithContext(handler.ApiContext).Execute();
            }
            catch (ApiException ex)
            {
                // Custom error handling for test cases can be placed here
                Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
                if (customException != null)
                    throw customException;
                return null;
            }
            return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
                     ? (apiClient.Result())
                     : null;
        }

 /// <summary>
 /// Deletes the facet specified by its unique identifier.
 /// </summary>
 /// <param name="facetId">Unique identifier of the facet to delete.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var facet = new Facet();
 ///   facet.DeleteFacetById(dataViewMode,  facetId);
 /// </code>
 /// </example>
 public virtual void DeleteFacetById(DataViewMode dataViewMode, int facetId)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.FacetClient.DeleteFacetByIdClient(dataViewMode,  facetId);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

        /// <summary> 
        /// Deletes a discount specified by its discount ID.
        /// <example> 
        ///  <code> 
        /// var result = DiscountFactory.DeleteDiscount(handler : handler,  discountId :  discountId,  dataViewMode: dataViewMode,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<void/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static void DeleteDiscount(ServiceClientMessageHandler handler, 
 		int discountId,  DataViewMode dataViewMode= DataViewMode.Live, 
		 HttpStatusCode expectedCode = HttpStatusCode.NoContent, HttpStatusCode successCode = HttpStatusCode.NoContent)
        {
            SetSdKparameters();
            var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
            var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            Debug.WriteLine(currentMethodName  + '.' + currentMethodName );
            var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.DiscountClient.DeleteDiscountClient(
                 discountId :  discountId, dataViewMode: dataViewMode		);
            try
            {
                apiClient.WithContext(handler.ApiContext).Execute();
            }
            catch (ApiException ex)
            {
                // Custom error handling for test cases can be placed here
                Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
                if (customException != null)
                    throw customException;
            }
            var noResponse = ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
                     ? (apiClient.Result())
                     : null;
        }

 /// <summary>
 /// Removes an option attribute definition for the specified product type.
 /// </summary>
 /// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
 /// <param name="productTypeId">Identifier of the product type.</param>
 /// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var producttypeoption = new ProductTypeOption();
 ///   producttypeoption.DeleteOption(dataViewMode,  productTypeId,  attributeFQN);
 /// </code>
 /// </example>
 public virtual void DeleteOption(DataViewMode dataViewMode, int productTypeId, string attributeFQN)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionClient.DeleteOptionClient(dataViewMode,  productTypeId,  attributeFQN);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Publishes the draft version of product changes for each product code specified in the request, and changes the product publish state to "live".
 /// </summary>
 /// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
 /// <param name="publishScope">Properties of the pending product changes to include in this operation.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var publishingscope = new PublishingScope();
 ///   publishingscope.PublishDrafts(dataViewMode,  publishScope);
 /// </code>
 /// </example>
 public virtual void PublishDrafts(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.PublishingScope publishScope)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.PublishingScopeClient.PublishDraftsClient(dataViewMode,  publishScope);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Deletes a variation, based on the supplied variation key, for the specified product code.
 /// </summary>
 /// <param name="productCode">Merchant-created code that uniquely identifies the product such as a SKU or item number. Once created, the product code is read-only.</param>
 /// <param name="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var productvariation = new ProductVariation();
 ///   productvariation.DeleteProductVariation(dataViewMode,  productCode,  variationKey);
 /// </code>
 /// </example>
 public virtual void DeleteProductVariation(DataViewMode dataViewMode, string productCode, string variationKey)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductVariationClient.DeleteProductVariationClient(dataViewMode,  productCode,  variationKey);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Deletes the configuration of a property attribute for the product specified in the request.
 /// </summary>
 /// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
 /// <param name="productCode"></param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var productproperty = new ProductProperty();
 ///   productproperty.DeleteProperty(dataViewMode,  productCode,  attributeFQN);
 /// </code>
 /// </example>
 public virtual void DeleteProperty(DataViewMode dataViewMode, string productCode, string attributeFQN)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.DeletePropertyClient(dataViewMode,  productCode,  attributeFQN);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Deletes a specific document based on the specified document ID.
 /// </summary>
 /// <param name="documentId">Identifier of the document being deleted.</param>
 /// <param name="documentListName">The name of the document list associated with the document list being deleted.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var document = new Document();
 ///   document.DeleteDocument(dataViewMode,  documentListName,  documentId);
 /// </code>
 /// </example>
 public virtual void DeleteDocument(DataViewMode dataViewMode, string documentListName, string documentId)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Content.Documentlists.DocumentClient.DeleteDocumentClient(dataViewMode,  documentListName,  documentId);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Deletes the drafts of the specified documents. Published documents cannot be deleted.
 /// </summary>
 /// <param name="documentLists">List of document lists that contain documents to delete.</param>
 /// <param name="documentIds">Unique identifiers of the documents to delete.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var documentdraftsummary = new DocumentDraftSummary();
 ///   documentdraftsummary.DeleteDocumentDrafts(dataViewMode,  documentIds,  documentLists);
 /// </code>
 /// </example>
 public virtual void DeleteDocumentDrafts(DataViewMode dataViewMode, List<string> documentIds, string documentLists =  null)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Content.DocumentDraftSummaryClient.DeleteDocumentDraftsClient(dataViewMode,  documentIds,  documentLists);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

		/// <summary> 
		/// Retrieves a list of all product inventory definitions for the location code specified in the request.
		/// <example> 
		///  <code> 
		/// var result = LocationInventoryFactory.GetLocationInventories(handler : handler,  locationCode :  locationCode,  startIndex :  startIndex,  pageSize :  pageSize,  sortBy :  sortBy,  filter :  filter,  filterFunctions :  filterFunctions,  responseFields :  responseFields,  dataViewMode: dataViewMode,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<LocationInventoryCollection/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection GetLocationInventories(ServiceClientMessageHandler handler, 
 		 string locationCode, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null, string filterFunctions = null, string responseFields = null,  DataViewMode dataViewMode= DataViewMode.Live, 
		 HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
		{
			SetSdKparameters();
			var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
			var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
			Debug.WriteLine(currentMethodName  + '.' + currentMethodName );
			var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.LocationInventoryClient.GetLocationInventoriesClient(
				 locationCode :  locationCode,  startIndex :  startIndex,  pageSize :  pageSize,  sortBy :  sortBy,  filter :  filter,  filterFunctions :  filterFunctions,  responseFields :  responseFields, dataViewMode: dataViewMode		);
			try
			{
				apiClient.WithContext(handler.ApiContext).Execute();
			}
			catch (ApiException ex)
			{
				// Custom error handling for test cases can be placed here
				Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
				if (customException != null)
					throw customException;
				return null;
			}
			return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode) 
					 ? (apiClient.Result()) 
					 : null;

		}

 /// <summary>
 /// Deletes a discount specified by its discount ID.
 /// </summary>
 /// <param name="discountId">Unique identifier of the discount. System-supplied and read-only.</param>
 /// <returns>
 /// 
 /// </returns>
 /// <example>
 /// <code>
 ///   var discount = new Discount();
 ///   discount.DeleteDiscount(dataViewMode,  discountId);
 /// </code>
 /// </example>
 public virtual void DeleteDiscount(DataViewMode dataViewMode, int discountId)
 {
     MozuClient response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.DiscountClient.DeleteDiscountClient(dataViewMode,  discountId);
     client.WithContext(_apiContext);
     response= client.Execute();
 }

 /// <summary>
 /// Retrieves the details of a product variation based on the supplied product code and variation key.
 /// </summary>
 /// <param name="productCode">Merchant-created code that uniquely identifies the product such as a SKU or item number. Once created, the product code is read-only.</param>
 /// <param name="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariation"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var productvariation = new ProductVariation();
 ///   var productVariation = productvariation.GetProductVariation(dataViewMode,  productCode,  variationKey);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.ProductVariation GetProductVariation(DataViewMode dataViewMode, string productCode, string variationKey)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariation> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductVariationClient.GetProductVariationClient(dataViewMode,  productCode,  variationKey);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Retrieves a list of attribute type rules according to optional filter criteria and sort options. Attribute type rules help drive the behavior of attributes on a storefront page.
 /// </summary>
 /// <param name="filter">A set of expressions that consist of a field, operator, and value and represent search parameter syntax when filtering results of a query. Valid operators include equals (eq), does not equal (ne), greater than (gt), less than (lt), greater than or equal to (ge), less than or equal to (le), starts with (sw), or contains (cont). For example - "filter=IsDisplayed+eq+true"</param>
 /// <param name="pageSize">The number of results to display on each page when creating paged results from a query. The maximum value is 200.</param>
 /// <param name="sortBy"></param>
 /// <param name="startIndex"></param>
 /// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var attributetyperule = new AttributeTypeRule();
 ///   var attributeTypeRuleCollection = attributetyperule.GetAttributeTypeRules(dataViewMode,  startIndex,  pageSize,  sortBy,  filter);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection GetAttributeTypeRules(DataViewMode dataViewMode, int? startIndex =  null, int? pageSize =  null, string sortBy =  null, string filter =  null)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Attributes.AttributeTypeRuleClient.GetAttributeTypeRulesClient(dataViewMode,  startIndex,  pageSize,  sortBy,  filter);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Configures a property attribute for the product specified in the request.
 /// </summary>
 /// <param name="productCode"></param>
 /// <param name="productProperty">Properties of the property attribute to configure for a product.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.ProductProperty"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var productproperty = new ProductProperty();
 ///   var productProperty = productproperty.AddProperty(dataViewMode,  productProperty,  productCode);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.ProductProperty AddProperty(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductProperty productProperty, string productCode)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductProperty> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.AddPropertyClient(dataViewMode,  productProperty,  productCode);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Creates a discount.
 /// </summary>
 /// <param name="discount">Properties of the discount to create. Required properties: Content.Name, AmountType, StartDate, and Target.Type.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.Discount"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var discount = new Discount();
 ///   var discount = discount.CreateDiscount(dataViewMode,  discount);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.Discount CreateDiscount(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Discount discount)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.Discount> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.DiscountClient.CreateDiscountClient(dataViewMode,  discount);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Creates a new category, price, or attribute facet. Supply the category or attribute source to use for the facet values.
 /// </summary>
 /// <param name="facet">Properties of the new facet to create. Required properties: Source, FacetType, IsHidden, and CategoryId.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.Facet"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var facet = new Facet();
 ///   var facet = facet.AddFacet(dataViewMode,  facet);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.Facet AddFacet(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Facet facet)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.Facet> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.FacetClient.AddFacetClient(dataViewMode,  facet);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }