/// <summary>
 /// Deletes a defined channel for the tenant and removes the defined site associations. After deleting this channel, assign its associated sites to another channel.
 /// </summary>
 /// <param name="code">User-defined code that identifies the channel to delete.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteChannel( code);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteChannelClient(string code)
 {
     var url = Mozu.Api.Urls.Commerce.ChannelUrl.DeleteChannelUrl(code);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Returns.Return"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=CreateReturn( ret);
 ///   var returnClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> CreateReturnClient(Mozu.Api.Contracts.CommerceRuntime.Returns.Return ret)
 {
     var url = Mozu.Api.Urls.Commerce.ReturnUrl.CreateReturnUrl();
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.CommerceRuntime.Returns.Return>(ret);
     return mozuClient;
 }

 /// <summary>
 /// Retrieves the details of the specified administrator user account.
 /// </summary>
 /// <param name="userId">Unique identifier of the administrator account to retrieve.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Core.User"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=GetUser( userId);
 ///   var userClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Core.User> GetUserClient(string userId)
 {
     var url = Mozu.Api.Urls.Platform.Adminuser.AdminUserUrl.GetUserUrl(userId);
     const string verb = "GET";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Core.User>()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Creates a new development or release package for the application version specified in the request.
 /// </summary>
 /// <param name="applicationVersionId">Unique identifier of the application version. Application version IDs are unique across all applications associated with the developer account.</param>
 /// <param name="package">Properties of the development or release package to define.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AppDev.Package"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AddPackage( pkg,  applicationVersionId);
 ///   var packageClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.AppDev.Package> AddPackageClient(Mozu.Api.Contracts.AppDev.Package pkg, int applicationVersionId)
 {
     var url = Mozu.Api.Urls.Platform.Developer.ApplicationVersionUrl.AddPackageUrl(applicationVersionId);
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.AppDev.Package>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.AppDev.Package>(pkg);
     return mozuClient;
 }

 /// <summary>
 /// Removes a previously defined record in the Mozu database.
 /// </summary>
 /// <param name="dbEntryQuery">The database entry string to delete.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteDBValue( dbEntryQuery);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteDBValueClient(string dbEntryQuery)
 {
     var url = Mozu.Api.Urls.Platform.UserData.UserDataUrl.DeleteDBValueUrl(dbEntryQuery);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Creates a shipment from one or more package associated with an order and assign a label and tracking number to an order shipment.
 /// </summary>
 /// <param name="orderId">Unique identifier of the order for this shipment.</param>
 /// <param name="packageIds">List of unique identifiers for each package associated with this shipment. Not all packages must belong to the same shipment.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package"/>}}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=CreatePackageShipments( packageIds,  orderId);
 ///   var packageClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<List<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package>> CreatePackageShipmentsClient(List<string> packageIds, string orderId)
 {
     var url = Mozu.Api.Urls.Commerce.Orders.ShipmentUrl.CreatePackageShipmentsUrl(orderId);
     const string verb = "POST";
     var mozuClient = new MozuClient<List<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package>>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody(packageIds);
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="appId"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.InstalledApplications.Application"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=GetApplication( appId);
 ///   var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.InstalledApplications.Application> GetApplicationClient(string appId)
 {
     var url = Mozu.Api.Urls.Platform.ApplicationUrl.GetApplicationUrl(appId);
     const string verb = "GET";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.InstalledApplications.Application>()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Applies a defined attribute to the customer account specified in the request and assigns a value to the customer attribute.
 /// </summary>
 /// <param name="accountId">Unique identifier of the customer account.</param>
 /// <param name="attribute"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAttribute"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AddAccountAttribute( attribute,  accountId);
 ///   var customerAttributeClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Customer.CustomerAttribute> AddAccountAttributeClient(Mozu.Api.Contracts.Customer.CustomerAttribute attribute, int accountId)
 {
     var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.AddAccountAttributeUrl(accountId);
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.CustomerAttribute>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.Customer.CustomerAttribute>(attribute);
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="accountId"></param>
 /// <param name="attributeFQN"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteAccountAttribute( accountId,  attributeFQN);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteAccountAttributeClient(int accountId, string attributeFQN)
 {
     var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.DeleteAccountAttributeUrl(accountId, attributeFQN);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Creates a new store credit for the customer account specified in the request.
 /// </summary>
 /// <param name="credit">Properties of the store credit to create.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.Credit.Credit"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AddCredit( credit);
 ///   var creditClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit> AddCreditClient(Mozu.Api.Contracts.Customer.Credit.Credit credit)
 {
     var url = Mozu.Api.Urls.Commerce.Customer.CreditUrl.AddCreditUrl();
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.Customer.Credit.Credit>(credit);
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="code"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.Credit.Credit"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AssociateCreditToShopper( code);
 ///   var creditClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit> AssociateCreditToShopperClient(string code)
 {
     var url = Mozu.Api.Urls.Commerce.Customer.CreditUrl.AssociateCreditToShopperUrl(code);
     const string verb = "PUT";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit>()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Retrieve the details of all master catalog associated with a tenant.
 /// </summary>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=GetMasterCatalogs();
 ///   var masterCatalogCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection> GetMasterCatalogsClient()
 {
     var url = Mozu.Api.Urls.Commerce.Catalog.Admin.MasterCatalogUrl.GetMasterCatalogsUrl();
     const string verb = "GET";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection>()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="accountAndAuthInfo"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AddAccountAndLogin( accountAndAuthInfo);
 ///   var customerAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> AddAccountAndLoginClient(Mozu.Api.Contracts.Customer.CustomerAccountAndAuthInfo accountAndAuthInfo)
 {
     var url = Mozu.Api.Urls.Commerce.Customer.CustomerAccountUrl.AddAccountAndLoginUrl();
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.Customer.CustomerAccountAndAuthInfo>(accountAndAuthInfo);
     return mozuClient;
 }

 /// <summary>
 /// Initializes an application with the necessary configured settings.
 /// </summary>
 /// <param name="application">Properties of the application to update.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.SiteSettings.Application.Application"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=ThirdPartyUpdateApplication( application);
 ///   var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.SiteSettings.Application.Application> ThirdPartyUpdateApplicationClient(Mozu.Api.Contracts.SiteSettings.Application.Application application)
 {
     var url = Mozu.Api.Urls.Commerce.Settings.ApplicationUrl.ThirdPartyUpdateApplicationUrl();
     const string verb = "PUT";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.SiteSettings.Application.Application>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.SiteSettings.Application.Application>(application);
     return mozuClient;
 }

 /// <summary>
 /// Creates a new shopper wish list for the associated customer account. Although customer accounts are maintained at the tenant level, the system stores wish lists at the site level. Newly created wish lists do not have any items.
 /// </summary>
 /// <param name="wishlist">Properties of the wish list to create.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=CreateWishlist( wishlist);
 ///   var wishlistClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist> CreateWishlistClient(Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist wishlist)
 {
     var url = Mozu.Api.Urls.Commerce.WishlistUrl.CreateWishlistUrl();
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist>(wishlist);
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="location"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Location.Location"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=AddLocation( location);
 ///   var locationClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.Location.Location> AddLocationClient(Mozu.Api.Contracts.Location.Location location)
 {
     var url = Mozu.Api.Urls.Commerce.Admin.LocationUrl.AddLocationUrl();
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.Location.Location>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.Location.Location>(location);
     return mozuClient;
 }

 /// <summary>
 /// Deletes the shopper wish list specified in the request and all items associated with it.
 /// </summary>
 /// <param name="wishlistId">Unique identifier of the wish list to delete.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteWishlist( wishlistId);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteWishlistClient(string wishlistId)
 {
     var url = Mozu.Api.Urls.Commerce.WishlistUrl.DeleteWishlistUrl(wishlistId);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="locationCode"></param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteLocation( locationCode);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteLocationClient(string locationCode)
 {
     var url = Mozu.Api.Urls.Commerce.Admin.LocationUrl.DeleteLocationUrl(locationCode);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Deletes the shipment specified in the request.
 /// </summary>
 /// <param name="orderId">Unique identifier of the order to cancel shipment.</param>
 /// <param name="shipmentId">Unique identifier of the shipment to cancel.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=DeleteShipment( orderId,  shipmentId);
 ///mozuClient.WithBaseAddress(url).Execute();
 /// </code>
 /// </example>
 public static MozuClient DeleteShipmentClient(string orderId, string shipmentId)
 {
     var url = Mozu.Api.Urls.Commerce.Orders.ShipmentUrl.DeleteShipmentUrl(orderId, shipmentId);
     const string verb = "DELETE";
     var mozuClient = new MozuClient()
                             .WithVerb(verb).WithResourceUrl(url)
     ;
     return mozuClient;
 }

 /// <summary>
 /// Creates an authentication ticket for the supplied user to specify in API requests associated with the supplied tenant.
 /// </summary>
 /// <param name="tenantId">Unique identifier of the development or production tenant for which to generate the user authentication ticket.</param>
 /// <param name="userAuthInfo">The user authentication information required to generate the user authentication ticket, which consists of a user name and password.</param>
 /// <returns>
 ///  <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket"/>}
 /// </returns>
 /// <example>
 /// <code>
 ///   var mozuClient=CreateUserAuthTicket( userAuthInfo,  tenantId);
 ///   var tenantAdminUserAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
 /// </code>
 /// </example>
 public static MozuClient<Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket> CreateUserAuthTicketClient(Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int? tenantId =  null)
 {
     var url = Mozu.Api.Urls.Platform.Adminuser.TenantAdminUserAuthTicketUrl.CreateUserAuthTicketUrl(tenantId);
     const string verb = "POST";
     var mozuClient = new MozuClient<Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket>()
                             .WithVerb(verb).WithResourceUrl(url)
                             .WithBody<Mozu.Api.Contracts.Core.UserAuthInfo>(userAuthInfo);
     return mozuClient;
 }