/// <summary> 
        /// Creates a new product selection. A create occurs each time a shopper selects a product option as they configure a product. Once all the required product options are configured, the product can be added to a cart.
        /// <example> 
        ///  <code> 
        /// var result = ProductFactory.ConfiguredProduct(handler : handler,  productOptionSelections :  productOptionSelections,  productCode :  productCode,  includeOptionDetails :  includeOptionDetails,  skipInventoryCheck :  skipInventoryCheck,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<ConfiguredProduct/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct ConfiguredProduct(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.ProductRuntime.ProductOptionSelections productOptionSelections, string productCode, bool? includeOptionDetails = null, bool? skipInventoryCheck = null, 
		 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.Storefront.ProductClient.ConfiguredProductClient(
                 productOptionSelections :  productOptionSelections,  productCode :  productCode,  includeOptionDetails :  includeOptionDetails,  skipInventoryCheck :  skipInventoryCheck		);
            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 = OrderTaxContextFactory.EstimateTaxes(handler : handler,  taxableOrder :  taxableOrder,  responseFields :  responseFields,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<OrderTaxContext/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.PricingRuntime.OrderTaxContext EstimateTaxes(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.PricingRuntime.TaxableOrder taxableOrder, string responseFields = null, 
		 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.Storefront.OrderTaxContextClient.EstimateTaxesClient(
				 taxableOrder :  taxableOrder,  responseFields :  responseFields		);
			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 = ApplicationFactory.UpdateApplication(handler : handler,  application :  application,  appId :  appId,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<Application/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.InstalledApplications.Application UpdateApplication(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.InstalledApplications.Application application, string appId, 
		 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.Platform.ApplicationClient.UpdateApplicationClient(
                 application :  application,  appId :  appId		);
            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 = CredentialStoreEntryFactory.StoreCredentials(handler : handler,  credentials :  credentials,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<void/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static void StoreCredentials(ServiceClientMessageHandler handler, 
 		Mozu.Api.Contracts.InstalledApplications.CredentialStoreEntry credentials, 
		 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.Platform.Extensions.CredentialStoreEntryClient.StoreCredentialsClient(
				 credentials :  credentials		);
			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> 
		/// Assigns or associates an existing discount to a specified coupon set. Use the couponSetCode parameter to specify the coupon set.
		/// <example> 
		///  <code> 
		/// var result = AssignedDiscountFactory.AssignDiscount(handler : handler,  assignedDiscount :  assignedDiscount,  couponSetCode :  couponSetCode,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<void/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static void AssignDiscount(ServiceClientMessageHandler handler, 
 		Mozu.Api.Contracts.ProductAdmin.AssignedDiscount assignedDiscount, string couponSetCode, 
		 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.Couponsets.AssignedDiscountClient.AssignDiscountClient(
				 assignedDiscount :  assignedDiscount,  couponSetCode :  couponSetCode		);
			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> 
		/// Applies a price adjustment to the specified order.
		/// <example> 
		///  <code> 
		/// var result = AdjustmentFactory.ApplyAdjustment(handler : handler,  adjustment :  adjustment,  orderId :  orderId,  updateMode :  updateMode,  version :  version,  responseFields :  responseFields,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<Order/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.CommerceRuntime.Orders.Order ApplyAdjustment(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.CommerceRuntime.Commerce.Adjustment adjustment, string orderId, string updateMode = null, string version = null, string responseFields = null, 
		 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.Orders.AdjustmentClient.ApplyAdjustmentClient(
				 adjustment :  adjustment,  orderId :  orderId,  updateMode :  updateMode,  version :  version,  responseFields :  responseFields		);
			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 = DocumentListTypeFactory.UpdateDocumentListType(handler : handler,  list :  list,  documentListTypeFQN :  documentListTypeFQN,  responseFields :  responseFields,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<DocumentListType/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.Content.DocumentListType UpdateDocumentListType(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.Content.DocumentListType list, string documentListTypeFQN, string responseFields = null, 
		 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.DocumentListTypeClient.UpdateDocumentListTypeClient(
				 list :  list,  documentListTypeFQN :  documentListTypeFQN,  responseFields :  responseFields		);
			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> 
        /// Creates a new channel that defines a new logical business division to use for financial reporting.
        /// <example> 
        ///  <code> 
        /// var result = ChannelFactory.CreateChannel(handler : handler,  channel :  channel,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<Channel/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.CommerceRuntime.Channels.Channel CreateChannel(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.CommerceRuntime.Channels.Channel channel, 
		 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.ChannelClient.CreateChannelClient(
                 channel :  channel		);
            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>
 /// 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> 
        /// 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> 
		/// Generates a new developer account authentication ticket for the specified tenant by supplying the defined refresh token information.
		/// <example> 
		///  <code> 
		/// var result = PublicDeveloperAdminAuthTicketFactory.RefreshDeveloperAuthTicket(handler : handler,  existingAuthTicket :  existingAuthTicket,  developerAccountId :  developerAccountId,  responseFields :  responseFields,  expectedCode: expectedCode, successCode: successCode); 
		/// var optionalCasting = ConvertClass<DeveloperAdminUserAuthTicket/>(result); 
		/// return optionalCasting;
		///  </code> 
		/// </example> 
		/// </summary>
		public static Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket RefreshDeveloperAuthTicket(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket existingAuthTicket, int? developerAccountId = null, string responseFields = null, 
		 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.Platform.Developer.DeveloperAdminUserAuthTicketClient.RefreshDeveloperAuthTicketClient(
				 existingAuthTicket :  existingAuthTicket,  developerAccountId :  developerAccountId,  responseFields :  responseFields		);
			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> 
        /// Creates an authentication ticket for the supplied user to specify in API requests associated with the supplied tenant.
        /// <example> 
        ///  <code> 
        /// var result = TenantAdminUserAuthTicketFactory.CreateUserAuthTicket(handler : handler,  userAuthInfo :  userAuthInfo,  tenantId :  tenantId,  expectedCode: expectedCode, successCode: successCode); 
        /// var optionalCasting = ConvertClass<TenantAdminUserAuthTicket/>(result); 
        /// return optionalCasting;
        ///  </code> 
        /// </example> 
        /// </summary>
        public static Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket CreateUserAuthTicket(ServiceClientMessageHandler handler, 
 		 Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int? tenantId = null, 
		 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.Platform.Adminuser.TenantAdminUserAuthTicketClient.CreateUserAuthTicketClient(
                 userAuthInfo :  userAuthInfo,  tenantId :  tenantId		);
            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>
 /// Creates a new customer account based on the information specified in the request.
 /// </summary>
 /// <param name="account">Properties of the customer account to update.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.Customer.CustomerAccount"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var customeraccount = new CustomerAccount();
 ///   var customerAccount = customeraccount.AddAccount( account);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.Customer.CustomerAccount AddAccount(Mozu.Api.Contracts.Customer.CustomerAccount account)
 {
     MozuClient<Mozu.Api.Contracts.Customer.CustomerAccount> response;
     var client = Mozu.Api.Clients.Commerce.Customer.CustomerAccountClient.AddAccountClient( account);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="orderId"></param>
 /// <param name="validationResult"></param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var ordervalidationresult = new OrderValidationResult();
 ///   var orderValidationResult = ordervalidationresult.AddValidationResult( validationResult,  orderId);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult AddValidationResult(Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult validationResult, string orderId)
 {
     MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult> response;
     var client = Mozu.Api.Clients.Commerce.Orders.OrderValidationResultClient.AddValidationResultClient( validationResult,  orderId);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="userAuthInfo"></param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var customerauthticket = new CustomerAuthTicket();
 ///   var customerAuthTicket = customerauthticket.CreateUserAuthTicket( userAuthInfo);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.Customer.CustomerAuthTicket CreateUserAuthTicket(Mozu.Api.Contracts.Customer.CustomerUserAuthInfo userAuthInfo)
 {
     MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> response;
     var client = Mozu.Api.Clients.Commerce.Customer.CustomerAuthTicketClient.CreateUserAuthTicketClient( userAuthInfo);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Creates a new payment transaction for the specified order and performs the specified action.
 /// </summary>
 /// <param name="orderId">Unique identifier of the order for which to apply the payment.</param>
 /// <param name="action">To action to perform for the newly created payment. Possible values are AuthAndCapture, AuthorizePayment, CapturePayment, VoidPayment, CreditPayment, RequestCheck, ApplyCheck, DeclineCheck.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.Order"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var payment = new Payment();
 ///   var order = payment.CreatePaymentAction( action,  orderId);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.Order CreatePaymentAction(Mozu.Api.Contracts.CommerceRuntime.Payments.PaymentAction action, string orderId)
 {
     MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.Order> response;
     var client = Mozu.Api.Clients.Commerce.Orders.PaymentClient.CreatePaymentActionClient( action,  orderId);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Assigns an option attribute to the product type based on the information supplied in the request.
 /// </summary>
 /// <param name="productTypeId">Identifier of the product type.</param>
 /// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
 /// <param name="attributeInProductType">Properties of the option attribute to define for the specified product type.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.ProductAdmin.AttributeInProductType"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var producttypeoption = new ProductTypeOption();
 ///   var attributeInProductType = producttypeoption.AddOption(dataViewMode,  attributeInProductType,  productTypeId);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.ProductAdmin.AttributeInProductType AddOption(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.AttributeInProductType attributeInProductType, int productTypeId)
 {
     MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> response;
     var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionClient.AddOptionClient(dataViewMode,  attributeInProductType,  productTypeId);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// Creates a return for previously fulfilled items. Each return must either be associated with an original order or a product definition to represent each returned item.
 /// </summary>
 /// <param name="ret">Wrapper for the properties of the return to create.</param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.CommerceRuntime.Returns.Return"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var return = new Return();
 ///   var return = return.CreateReturn( ret);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.CommerceRuntime.Returns.Return CreateReturn(Mozu.Api.Contracts.CommerceRuntime.Returns.Return ret)
 {
     MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> response;
     var client = Mozu.Api.Clients.Commerce.ReturnClient.CreateReturnClient( ret);
     client.WithContext(_apiContext);
     response= client.Execute();
     return response.Result();
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="locationType"></param>
 /// <returns>
 /// <see cref="Mozu.Api.Contracts.Location.LocationType"/>
 /// </returns>
 /// <example>
 /// <code>
 ///   var locationtype = new LocationType();
 ///   var locationType = locationtype.AddLocationType( locationType);
 /// </code>
 /// </example>
 public virtual Mozu.Api.Contracts.Location.LocationType AddLocationType(Mozu.Api.Contracts.Location.LocationType locationType)
 {
     MozuClient<Mozu.Api.Contracts.Location.LocationType> response;
     var client = Mozu.Api.Clients.Commerce.Admin.LocationTypeClient.AddLocationTypeClient( locationType);
     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();
 }