var product = await productService.GetAsync(productId);
product.SomeProperty = newValue;
product = await productService.UpdateAsync(productId, product);

var service = new ProductService(myShopifyUrl, shopAccessToken);

var service = new ProductService(myShopifyUrl, privateAppPassword)

string urlFromUser = "https://example.myshopify.com";
bool isValidDomain = await AuthorizationService.IsValidShopDomainAsync(urlFromUser).

//This is the user's store URL.
string usersMyShopifyUrl = "https://example.myshopify.com";

// A URL to redirect the user to after they've confirmed app installation.
// This URL is required, and must be listed in your app's settings in your Shopify app dashboard.
// It's case-sensitive too!
string redirectUrl = "https://example.com/my/redirect/url";

//An array of the Shopify access scopes your application needs to run.
var scopes = new List<AuthorizationScope>()
{
    AuthorizationScope.ReadCustomers,
    AuthorizationScope.WriteCustomers
};

//Or, use an array of string permissions
var scopes = new List<string>()
{
    "read_customers",
    "write_customers"
}

//You can find your API key over at https://shopify.dev/tutorials/authenticate-a-private-app-with-shopify-admin
string shopifyApiKey = "";

//All AuthorizationService methods are static.
Uri authUrl = AuthorizationService.BuildAuthorizationUrl(scopes, usersMyShopifyUrl, shopifyApiKey, redirectUrl);

//The querystring will have several parameters you need for authorization.
string code = Request.QueryString["code"];
string myShopifyUrl = Request.QueryString["shop"];

string accessToken = await AuthorizationService.Authorize(code, myShopifyUrl, shopifyApiKey, shopifySecretKey);

var qs = Request.QueryString;

if(AuthorizationService.IsAuthenticRequest(qs, shopifySecretKey))
{
    //Request is authentic.
}
else
{
    //Request is not authentic and should not be acted on.
}

var qs = Request.QueryString;

if(AuthorizationService.IsAuthenticProxyRequest(qs, shopifySecretKey))
{
    //Request is authentic.
}
else
{
    //Request is not authentic and should not be acted on.
}

NameValueCollection requestHeaders = Request.Headers;
Stream inputStream = Request.InputStream;

if(AuthorizationService.IsAuthenticWebhook(requestHeaders, inputStream, shopifySecretKey))
{
    //Webhook is authentic.
}
else
{
    //Webhook is not authentic and should not be acted on.
}

NameValueCollection requestHeaders = Request.Headers;
string requestBody = null;

//Reset the input stream. MVC controllers often read the stream to determine which parameters to pass to an action.
Request.InputStream.Position = 0;

//Read the stream into a string
using(StreamReader reader = new StreamReader(Request.InputStream))
{
    requestBody = await reader.ReadToEndAsync();
}

if(AuthorizationService.IsAuthenticWebhook(requestHeaders, requestBody, shopifySecretKey))
{
    //Webhook is authentic.
}
else
{
    //Webhook is not authentic and should not be acted on.
}

var service = new RecurringChargeService(myShopifyUrl, shopAccessToken);
var charge = new RecurringCharge()
{
    Name = "Lorem Ipsum Plan",
    Price = 12.34,
    Test = true, //Marks this charge as a test, meaning it won't charge the shop owner.
    TrialDays = 21
}

charge = await service.CreateAsync(charge);

var service = new RecurringChargeService(myShopifyUrl, shopAccessToken);

var charge = await service.GetAsync(chargeId);

var service = new RecurringChargeService(myShopifyUrl, shopAccessToken);

IEnumerable<RecurringCharge> charges = await service.ListAsync();

var service = new RecurringChargeService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(chargeId);

var service = new ChargeService(myShopifyUrl, shopAccessToken);
var charge = new Charge()
{
    Name = "Lorem Ipsum Charge",
    Price = 12.34,
    Test = true, //Marks this charge as a test, meaning it won't charge the shop owner.
}

charge = await service.CreateAsync(charge);

var service = new ChargeService(myShopifyUrl, shopAccessToken);

var charge = await service.GetAsync(chargeId);

var service = new ChargeService(myShopifyUrl, shopAccessToken);

IEnumerable<Charge> charges = await service.ListAsync();

var service = new ChargeService(myShopifyUrl, shopAccessToken);

await service.ActivateAsync(chargeId);

var service = new UsageChargeService(myShopifyUrl, shopAccessToken);

string description = "Used 1000 emails";
double price = 1.00;

var usageCharge = await service.CreateAsync(recurringChargeId, description, price);

var service = new UsageChargeService(myShopifyUrl, shopAccessToken);

var usageCharge = await service.GetAsync(recurringChargeId, usageChargeId);

var service = new UsageChargeService(myShopifyUrl, shopAccessToken);

var usageCharges = await service.ListAsync(recurringChargeId);

var service = new ShopService(myShopifyUrl, shopAccessToken);

var shop = await service.GetAsync();

var service = new ShopService(myShopifyUrl, shopAccessToken);

var shop = await service.UninstallAppAsync()

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
var customer = new Customer()
{
    FirstName = "John",
    LastName = "Doe",
    Email = "[email protected]",
    Addresses = new List<Address>()
    {
        new Address()
        {
            Address1 = "123 4th Street",
            City = "Minneapolis",
            Province = "Minnesota",
            ProvinceCode = "MN",
            Zip = "55401",
            Phone = "555-555-5555",
            FirstName = "John",
            LastName = "Doe",
            Company = "Tomorrow Corporation",
            Country = "United States",
            CountryCode = "US",
            Default = true,
        }
    },
    VerifiedEmail = true,
    Note = "Test note about the customer.",
    State = "enabled"
};

customer = await service.CreateAsync(customer);

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
var customer = await service.GetAsync(customerId);

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
var customer = await service.GetAsync(customerId, "first_name,last_name,email");

//Returns a customer with only FirstName, LastName and Email fields. All other fields are null.

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
var customer = await service.UpdateAsync(customerId, new Customer()
{
    Email = "[email protected]"
});

var service =  new CustomerService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(customerId);

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
int customerCount = await service.CountAsync();

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
IEnumerable<Customer> customers = await Service.ListAsync();

var service =  new CustomerService(myShopifyUrl, shopAccessToken);
IEnumerable<Order> orders = await service.ListOrdersForCustomerAsync(customerId);

var service = new CustomerService(myShopifyUrl, shopAccessToken); 
var filter = new CustomerSearchListFilter
{
  //Searches for a customer from the United States with a name like 'Jane'.
  Query = "Jane country:United States"
};
IEnumerable<Customer> customers = await Service.SearchAsync(filter);

var service = new OrderService(myShopifyUrl, shopAccessToken);
var order = new Order()
{
    CreatedAt = DateTime.UtcNow,
    BillingAddress = new Address()
    {
        Address1 = "123 4th Street",
        City = "Minneapolis",
        Province = "Minnesota",
        ProvinceCode = "MN",
        Zip = "55401",
        Phone = "555-555-5555",
        FirstName = "John",
        LastName = "Doe",
        Company = "Tomorrow Corporation",
        Country = "United States",
        CountryCode = "US",
        Default = true,
    },
    LineItems = new List<LineItem>()
    {
        new LineItem()
        {
            Name = "Test Line Item",
            Title = "Test Line Item Title"
        }
    },
    FinancialStatus = "paid",
    TotalPrice = 5.00,
    Email = Guid.NewGuid().ToString() + "@example.com",
    Note = "Test note about the customer.",
};

order = await service.CreateAsync(order);

var service = new OrderService(myShopifyUrl, shopAccessToken);
var order = await service.GetAsync(orderId);

var service = new OrderService(myShopifyUrl, shopAccessToken);
var order = await service.UpdateAsync(orderId, new Order()
{
    Notes = "test notes."
});

var service = new OrderService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(orderId);

var service = new OrderService(myShopifyUrl, shopAccessToken);
int orderCount = await service.CountAsync();

var service = new OrderService(myShopifyUrl, shopAccessToken);
IEnumerable<Order> orders = await service.ListAsync();

var service = new OrderService(myShopifyUrl, shopAccessToken);

await service.CloseAsync(orderId);

var service = new OrderService(myShopifyUrl, shopAccessToken);

await service.OpenAsync(orderId);

var service = new OrderService(myShopifyUrl, shopAccessToken);

await service.CancelAsync(orderId);

var service = new ProductService(myShopifyUrl, shopAccessToken);
var product = new Product()
{
    Title = "Burton Custom Freestlye 151",
    Vendor = "Burton",
    BodyHtml = "<strong>Good snowboard!</strong>",
    ProductType = "Snowboard",
    Images = new List<ProductImage>
    {
        new ProductImage
        {
            Attachment = "R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=="
        }
    },
};

product = await service.CreateAsync(product);

//By default, creating a product will publish it. To create an unpublished product:+1:
product = await service.CreateAsync(product, new ProductCreateOptions() { Published = false });

var service = new ProductService(myShopifyUrl, shopAccessToken);
var product = await service.GetAsync(productId);

var service = new ProductService(myShopifyUrl, shopAccessToken);
var product = await service.UpdateAsync(productId, new Product()
{
    Title = "New product title"
});

var service = new ProductService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(productId);

var service = new ProductService(myShopifyUrl, shopAccessToken);
int productCount = await service.CountAsync();

var service = new ProductService(myShopifyUrl, shopAccessToken);
IEnumerable<Product> products = await service.ListAsync();

//Optionally filter the results
var filter = new ProductFilterOptions()
{
    Ids = new[]
    {
        productId1,
        productId2,
        productId3
    }
};
products = await service.ListAsync(filter);

var service = new ProductService(myShopifyUrl, shopAccessToken);
var product = await service.PublishAsync(productId);

var service = new ProductService(myShopifyUrl, shopAccessToken);
var product = await service.UnpublishAsync(productId);

var service = new WebhookService(myShopifyUrl, shopAccessToken);
Webhook hook = new Webhook()
{
    Address = "https://my.webhook.url.com/path",
    CreatedAt = DateTime.Now,
    Fields = new List<string>() { "field1", "field2" },
    Format = "json",
    MetafieldNamespaces = new List<string>() { "metafield1", "metafield2" },
    Topic = "app/uninstalled",
};

hook = await service.CreateAsync(hook);

var service = new WebhookService(myShopifyUrl, shopAccessToken);
var webhook = await service.GetAsync(webhookId);

var service = new WebhookService(myShopifyUrl, shopAccessToken);
var webhook = await service.UpdateAsync(webhookId, new Webhook()
{
    Address = "https://my.webhook.url.com/new/path
});

var service = new WebhookService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(webhookId);

var service = new WebhookService(myShopifyUrl, shopAccessToken);
int webhookCount = await service.CountAsync();

var service = new WebhookService(myShopifyUrl, shopAccessToken);
IEnumerable<Webhook> webhooks = await service.ListAsync();

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);
var tag = new ScriptTag()
{
    Event = "onload",
    Src  = "https://example.com/my-javascript-file.js",
    DisplayScope = 'all'
}

tag = await service.CreateAsync(tag);

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);
var tag = await service.GetAsync(tagId);

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);
var tag = await service.UpdateAsync(tagId, new ScriptTag()
{
    Src = "https://example.com/my-new-javascript-file.js";
});

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(tagId);

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);
int tagCount = await service.CountAsync();

//Optionally filter the count to only those tags with a specific Src
int filteredTagCount = await service.CountAsync("https://example.com/my-filtered-url.js");

var service = new ScriptTagService(myShopifyUrl, shopAccessToken);
var tags = await service.ListAsync();

//Optionally filter the list to only those tags with a specific Src
var filteredTags = await service.ListAsync(new ScriptTagListOptions() {
    Src = FilteredSrc
});

var service = new AssetService(myShopifyUrl, shopAccessToken);
var asset = new Asset()
{
    ContentType = "text/x-liquid",
    Key = "templates/test.liquid",
    Value  = "<h1>Hello, world!</h1>"
}

//Note: Creating an asset does not return it's 'Value' property.
//You must specifically refresh it with service.GetAsync
asset = await service.CreateAsync(themeId, asset);

var service = new AssetService(myShopifyUrl, shopAccessToken);
var key = "templates/index.liquid";

var asset = await service.GetAsync(themeId, key);

var service = new AssetService(myShopifyUrl, shopAccessToken);

var assets = await service.ListAsync(themeId);

var service = new AssetService(myShopifyUrl, shopAccessToken);

//Note: Updating an asset does not return it's 'Value' property.
//You must specifically refresh it with service.GetAsync
var asset = await service.UpdateAsync(themeId, assetId, new Asset()
{
    Value = "<h1>Hello, world! I've been updated.</h1>";
});

var service = new AssetService(myShopifyUrl, shopAccessToken);
var asset = new Asset()
{
    Key = "templates/test.liquid",
    SourceKey = originalAsset.Key
};

//Note: Creating an asset does not return it's 'Value' property.
//You must specifically refresh it with service.GetAsync
asset = await service.UpdateAsync(themeId, assetId, asset);

var service = new ThemeService(myShopifyUrl, shopAccessToken);
var theme = new Theme()
{
    Name = "My new theme.",
    Role = "unpublished"
}

theme = await service.CreateAsync(theme);

//Or, create a theme and copy its files from a .zip file URL
theme = await service.CreateAsync(theme, 'https://my-domain.com/my-theme-files.zip');

var service = new ThemeService(myShopifyUrl, shopAccessToken);
var theme = await service.GetAsync(themeId);

var service = new ThemeService(myShopifyUrl, shopAccessToken);
var theme = await service.UpdateAsync(themeId, new Theme()
{
    Role = ThemeRole.Main,
    Name = "My updated theme."
});

var service = new ThemeService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(themeId);

var service = new ThemeService(myShopifyUrl, shopAccessToken);
var themes = await service.ListAsync();

var service = new RedirectService(myShopifyUrl, shopAccessToken);
var redirect = new Redirect()
{
    Path = "/ipod",
    Target  = "https://apple.com/ipod"
}

redirect = await service.CreateAsync(redirect);

var service = new RedirectService(myShopifyUrl, shopAccessToken);
var redirect = await service.GetAsync(redirectId);

var service = new RedirectService(myShopifyUrl, shopAccessToken);
var redirect = await service.UpdateAsync(redirectId, new Redirect()
{
    Target = "https://apple.com/ipad",
    Path = "/ipad"
});

var service = new RedirectService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(redirectId);

var service = new RedirectService(myShopifyUrl, shopAccessToken);
int redirectCount = await service.CountAsync();

//Optionally filter the count to only those redirects with a specific path or target
int filteredRedirectCount = await service.CountAsync(path: "/ipod", target: "https://apple.com/ipod/");

var service = new RedirectService(myShopifyUrl, shopAccessToken);
var redirects = await service.ListAsync();

//Optionally filter the list to only those redirects with a specific path or target
var filteredRedirects = await service.ListAsync(new RedirectListOptions() {
    Path = "/ipod",
    Target = "https://apple.com/ipod"
});

var service = new CollectService(myShopifyUrl, shopAccessToken);
var collect = new Collect()
{
    CollectionId = collectionId,
    ProductId = productId
}

collect = await service.CreateAsync(collect);

var service = new CollectService(myShopifyUrl, shopAccessToken);
var collect = await service.GetAsync(collectId);

var service = new CollectService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(collectId);

var service = new CollectService(myShopifyUrl, shopAccessToken);
int collectCount = await service.CountAsync();

//Optionally filter the count to only those collects for a certain product or collection
int filteredCollectCount = await service.CountAsync(new CollectFilterOptions()
{
    ProductId = productId,
    CollectionId = collectionId
});

var service = new CollectService(myShopifyUrl, shopAccessToken);
var collects = await service.ListAsync();

//Optionally filter the list to only those collects for a certain product or collection
var filteredCollects = await service.CountAsync(new CollectFilterOptions()
{
    ProductId = productId,
    CollectionId = collectionId
});

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
var fulfillmentShipping = new FulfillmentShipping()
{
    Message = "Items will be shipped now.",
    NotifyCustomer = true,
    TrackingInfo = new TrackingInfo()
    {
        Number = "123456789",
        Url = "https://example.com/123456789",
        Company = "Jack Black's Pack, Stack and Track"
    },
    FulfillmentRequestOrderLineItems = []
};

fulfillment = await service.CreateAsync(fulfillmentShipping);

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
var fulfillmentShipping = new FulfillmentShipping()
{
    Message = "Items will be shipped now.",
    NotifyCustomer = true,
    TrackingInfo = new TrackingInfo()
    {
        Number = "123456789",
        Url = "https://example.com/123456789",
        Company = "Jack Black's Pack, Stack and Track"
    },
    FulfillmentRequestOrderLineItems = new List<LineItemsByFulfillmentOrder>()
    {
        new LineItemsByFulfillmentOrder() 
        {
            FulfillmentOrderId = 1,
            FulfillmentRequestOrderLineItems = []
        }
    }
};

fulfillment = await service.CreateAsync(fulfillmentShipping);

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
var fulfillment = await service.GetAsync(orderId, fulfillmentId);

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
var fulfillment = await service.UpdateAsync(orderId, fulfillmentId, new Fulfillment()
{
    TrackingCompany = "John Doe's Tracking Company"
});

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
int fulfillmentCount = await service.CountAsync(orderId);

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
var fulfillments = await service.ListAsync(orderId);

var service = new FulfillmentService(myShopifyUrl, shopAccessToken);
await service.CancelAsync(fulfillmentId)

var service = new AssignedFulfillmentOrderService(myShopifyUrl, shopAccessToken);

//Optionally filter the list to only those assigned fulfillments with a specific status
var filterStatus = new AssignedFulfillmentOrderFilter()
{
    AssignmentStatus = "fulfillment_requested"
});

var assignedFulfillments = await service.ListAsync(filterStatus);

var service = new CancellationRequestService(myShopifyUrl, shopAccessToken);
var fulfillmentOrder = await service.CreateAsync(fulfillmentOrderId, "The customer changed his mind.");

var service = new CancellationRequestService(myShopifyUrl, shopAccessToken);
var fulfillmentOrder = await service.AcceptAsync(fulfillmentOrderId, "We had not started any processing yet.");

var service = new CancellationRequestService(myShopifyUrl, shopAccessToken);
var fulfillmentOrder = await service.AcceptAsync(fulfillmentOrderId, "We have already sent the shipment out.");

var service = new FulfillmentEventService(myShopifyUrl, shopAccessToken);
var fulfillmentEvent = new FulfillmentEvent()
{
    OrderId = 1234532,
    FulfillmentId = 156185165,
    Status = "confirmed"
};

fulfillmentEvent = await service.CreateAsync(orderId, fulfillmentId, fulfillmentEvent);

var service = new FulfillmentEventService(myShopifyUrl, shopAccessToken);
var fulfillmentEvents = await service.ListAsync(orderId, fulfillmentId);

var service = new FulfillmentEventService(myShopifyUrl, shopAccessToken);
var fulfillmentEvent = await service.GetAsync(orderId, fulfillmentId, fulfillmentEventId);

var service = new FulfillmentEventService(myShopifyUrl, shopAccessToken);
await service.DeleteAsync(orderId, fulfillmentId, fulfillmentEventId);

var service = new FulfillmentOrderService(myShopifyUrl, shopAccessToken);
var fulfillmentOrders = await service.ListAsync(orderId);

var service = new FulfillmentRequestService(myShopifyUrl, shopAccessToken);

// Optionally, you can request only specific item to fulfilled.
var fulfillmentRequest = new FulfillmentRequest()
{
    FulfillmentRequestOrderLineItems = new List<FulfillmentRequestOrderLineItems>(){}
};
var fulfillmentOrder = await service.CreateAsync(fulfillmentOrderId, fulfillmentRequest);

var service = new FulfillmentRequestService(myShopifyUrl, shopAccessToken);
var fulfillmentOrder = await service.AcceptAsync(fulfillmentOrderId, "Your order will be filled shortly.");

var service = new FulfillmentRequestService(myShopifyUrl, shopAccessToken);
var fulfillmentOrder = await service.AcceptAsync(fulfillmentOrderId, "Fulfillment services have been suspended for this store.");

var service = new FulfillmentServiceService(myShopifyUrl, shopAccessToken);
var fulfillmentService = await service.CreateAsync(new FulfillmentServiceEntity()
{
    Name = "Your Company Name", 
    CallbackUrl = "http://yourcompany.com", 
    InventoryManagement = true,
    TrackingSupport = true,
    FulfillmentOrdersOptIn = true,
    RequiresShippingMethod = true, 
    Format = "json"
});

var service = new FulfillmentServiceService(myShopifyUrl, shopAccessToken);
// Optional Filter
var filter = new FulfillmentServiceListFilter(){ Scope = "all"};
var fulfillmentServices = await service.ListAsync(filter);

var service = new FulfillmentServiceService(myShopifyUrl, shopAccessToken);
// Optional Filter
var fields = "id,name,email";
var fulfillmentService = await service.GetAsync(fulfillmentServiceId, fields);

var service = new FulfillmentServiceService(myShopifyUrl, shopAccessToken);
var fulfillmentService = await service.UpdateAsync(fulfillmentServiceId, fulfillmentServiceEntity);

var service = new FulfillmentServiceService(myShopifyUrl, shopAccessToken);
var fulfillmentService = await service.DeleteAsync(fulfillmentServiceId);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transaction = new Transaction()
{
    Kind = "capture"
};

await service.CreateAsync(orderId, transaction);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transaction = new Transaction()
{
    Kind = "capture",
    Amount = 5.00
};

await service.CreateAsync(orderId, transaction);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transaction = new Transaction()
{
    Kind = "refund",
    Amount = 5.00
};

await service.CreateAsync(orderId, transaction);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transaction = new Transaction()
{
    Kind = "void"
};

//Throws an error.
await service.CreateAsync(orderId, transaction);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transaction = await service.GetAsync(orderId, transactionId);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync(orderId);

var service = new TransactionService(myShopifyUrl, shopAccessToken);
var transactions = await service.ListAsync(orderId);

//Optionally filter the list to those after the given id
var transactions = await service.ListAsync(orderId, sinceId);

var service = new TenderTransactionService(myShopifyUrl, shopAccessToken);
var tenderTransactions = await service.ListAsync();

//Optionally filter the list to transactions processed after the specified date/time
var transactions = await service.ListAsync(new TenderTransactionListFilter
{
    ProcessedAtMin = DateTimeOffset.Now.AddHours(-1)
});

var service = new PageService(myShopifyUrl, shopAccessToken);
var page = new Page()
{
    CreatedAt = DateTime.UtcNow,
    Title = "Burton Custom Freestlye 151",
    BodyHtml = "<strong>Good snowboard!</strong>",
};

page = await service.CreateAsync(page);

var service = new PageService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new PageService(myShopifyUrl, shopAccessToken);
var pages = await service.ListAsync();

var service = new PageService(myShopifyUrl, shopAccessToken);
var page = await service.GetAsync(pageId);

var service = new PageService(myShopifyUrl, shopAccessToken);
var page = await service.UpdateAsync(pageId, new Page()
{
    Title = "My new page title"
});

var service = new PageService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(pageId);

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
var metafield = new MetaField()
{
    Namespace = "myNamespace",
    Key = "myKey",
    Value = "5",
    ValueType = "integer",
    Description = "This is a test meta field. It is an integer value."
};

//Create a new metafield on a product
metafield = await service.CreateAsync(metafield, productId, "products");

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync(productId, "products");

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
var metafields = await service.ListAsync(productId, "products");

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
var metafield = await service.GetAsync(metafieldId);

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
var metafield = await service.UpdateAsync(metafieldId, new MetaField()
{
    Value = "45"
});

var service = new MetaFieldService(myShopifyUrl, shopAccessToken);
await service.DeleteAsync(metafieldId);

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);
var collection = await service.CreateAsync(new CustomCollection()
{
    Title = "My Custom Collection",
    Published = true,
    PublishedAt = DateTime.UtcNow,
    Image = new CustomCollectionImage()
    {
        Src = "https://placekitten.com/250/250"
    }
});

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);
var collection = await service.GetAsync(collectionId);

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);
var collections = await service.ListAsync();

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);
var collection = await service.UpdateAsync(collectionId, new Collection()
{
    Title = "My new collection title"
});

var service = new CustomCollectionService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(collectionId);

var service = new ProductImageService(myShopifyUrl, shopAccessToken);
var image = await service.CreateAsync(productId, new ProductImage()
{
    Metafields = new List<MetaField>()
    {
        new MetaField()
        {
            Key = "alt",
            Value = "new alt tag content",
            ValueType = "string",
            Namespace = "tags"
        }
    },
    Src = "https://placekitten.com/200/300"
});

var service = new ProductImageService(myShopifyUrl, shopAccessToken);
var image = await service.GetAsync(productId, imageId);

var service = new ProductImageService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync(productId);

var service = new ProductImageService(myShopifyUrl, shopAccessToken);
var images = await service.ListAsync(productId);

var service = new ProductImageService(myShopifyUrl, shopAccessToken);
var image = await service.UpdateAsync(productId, imageId, new Image()
{
    Position = 2
});

var service = new ProductImageService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(productId, imageId);

var service = new LocationService(myShopifyUrl, shopAccessToken);
var locations = await service.ListAsync();

var service = new LocationService(myShopifyUrl, shopAccessToken);
var location = await service.GetAsync(locationId);

var service = new EventService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new EventService(myShopifyUrl, shopAccessToken);
var event = await service.GetAsync(eventId);

var service = new EventService(myShopifyUrl, shopAccessToken);
var events = await service.ListAsync();

var service = new EventService(myShopifyUrl, shopAccessToken);
var subjectType = "Order";
var orderEvents = await service.ListAsync(orderId, subjectType);

var service = new OrderRiskService(myShopifyUrl, shopAccessToken);
var risk = await service.CreateAsync(orderId, new OrderRisk()
{
    Message = "This looks risk!",
    Score = (decimal)0.85,
    Recommendation = "cancel",
    Source = "External",
    CauseCancel = false,
    Display = true,
});

var service = new OrderRiskService(myShopifyUrl, shopAccessToken);
var risk = await service.GetAsync(orderId, riskId);

var service = new OrderRiskService(myShopifyUrl, shopAccessToken);
var risk = await service.UpdateAsync(orderId, riskId, new Risk()
{
    Message = "An updated risk message"
});

var service = new OrderRiskService(myShopifyUrl, shopAccessToken);
var risks = await service.ListAsync(orderId);

var service = new OrderRiskService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(orderId, riskId);

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);
var smartCollection = await service.CreateAsync(new SmartCollection()
{
   Title = "My Smart Collection",
   Handle = "my-url-slug",
   BodyHtml = "\<h1\>Hello world!\</h1\>",
   Image = new SmartCollectionImage()
   {
       // Base-64 image attachment
       Attachment = "R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==\n"
   }
});

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);
var smartCollection = await service.UpdateAsync(smartCollectionId, new SmartCollection()
{
    Title = "My updated title"
});

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);
var smartCollection = await service.GetAsync(smartCollectionId);

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);
var smartCollections = await service.ListAsync();

var service = new SmartCollectionService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(smartCollectionId);

 var product = new Product()
 {
     Title = "Test Product Walter",
     Vendor = "Burton",
     BodyHtml = "<strong>Good snowboard!</strong>",
     ProductType = "Snowboard",
     Images = images,
     //Make sure to give your product the correct variant option
     Options = new List<ProductOption>
     {
         new ProductOption
         {
             Name = "Color"
         }
     },
     //And then create a collection of variants or assign the "Variants" property
     //to an already defined collection.
     Variants = new List<ProductVariant>
     {
         new ProductVariant
         {
             Option1 = "Black",
         },
         new ProductVariant
         {
             Option1 = "Green",
         },
     }
 };

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);
var variant = await service.CreateAsync(productId, new ProductVariant()
{
    Option1 = "blue",
    Price = 123.45,
});

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);
var variant = await service.GetAsync(variantId);

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);
var variant = await service.UpdateAsync(variantId, new Variant()
{
    Price = 543.21
});

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);
var variants = await service.ListAsync(productId);

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync(productId);

var service = new ProductVariantService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(productId, variantId);

var service = new BlogService(myShopifyUrl, shopAccessToken);
var blog = await service.CreateAsync(new Blog()
{
    Title = "My new blog"
});

var service = new BlogService(myShopifyUrl, shopAccessToken);
var blog = await service.GetAsync(blogId);

var service = new BlogService(myShopifyUrl, shopAccessToken);
var blog = await service.UpdateAsync(blogId, new Blog()
{
    Comments = "moderate"
});

var service = new BlogService(myShopifyUrl, shopAccessToken);
var blogs = await service.ListAsync();

var service = new BlogService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new BlogService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(blogId);

var service = new ArticleService(myShopifyUrl, shopAccessToken);
var article = await service.CreateAsync(blogId, new Article()
{
    Title = "My new Article title",
    Author = "John Smith",
    Tags = "This Post, Has Been Tagged",
    BodyHtml = "<h1>Hello world!</h1>",
    Image = new ArticleImage()
    {
        Attachment = "R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==\n"
    }
});

var service = new ArticleService(myShopifyUrl, shopAccessToken);
var article = await service.GetAsync(blogId, articleId);

var service = new ArticleService(myShopifyUrl, shopAccessToken);
var article = await service.UpdateAsync(blogId, articleId, new Article()
{
    Title = "My new title"
});

var service = new ArticleService(myShopifyUrl, shopAccessToken);
var articles = await service.ListAsync(blogId);

var service = new ArticleService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync(blogId);

var service = new ArticleService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(blogId, articleId);

var service = new ArticleService(myShopifyUrl, shopAccessToken);
IEnumerable<string> authors = await service.ListAuthorsAsync();

var service = new ArticleService(myShopifyUrl, shopAccessToken);
IEnumerable<string> tags = await service.ListTagsAsync();

var service = new ArticleService(myShopifyUrl, shopAccessToken);
IEnumerable<string> tags = await service.ListTagsForBlogAsync(blogId);

var service = new ApplicationCreditService(myShopifyUrl, shopAccessToken);
var credit = await service.CreateAsync(new ApplicationCredit()
{
    Description = "Refund for Foo",
    Amount = 10.00m
});

var service = new ApplicationCreditService(myShopifyUrl, shopAccessToken);
var charge = await service.GetAsync(creditId);

var service = new ApplicationCreditService(myShopifyUrl, shopAccessToken);
var charges = await service.ListAsync();

var service = new DiscountService(myShopifyUrl, shopAccessToken);
var discount = await service.CreateAsync(new Discount()
{
    DiscountType = "fixed_amount",
    Value = "10.00",
    DiscountCode = "AuntieDot",
    MinimumOrderAmount = "40.00",
});

var service = new DiscountService(myShopifyUrl, shopAccessToken);
var discount = await service.GetAsync(discountId):

var service = new DiscountService(myShopifyUrl, shopAccessToken);
var discounts = await service.ListAsync();

var service = new DiscountService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(discountId);

var service = new DiscountService(myShopifyUrl, shopAccessToken);

await service.DisableAsync(discountId);

var service = new DiscountService(myShopifyUrl, shopAccessToken);

await service.EnableAsync(discountId);

var service = new PolicyService(myShopifyUrl, shopAccessToken);
var policies = await service.ListAsync();

var service = new ShippingZoneService(myShopifyUrl, shopAccessToken);
var shippingZones = await service.ListAsync();

var service = new GiftCardService(myShopifyUrl, shopAccessToken);
var giftCards = await service.ListAsync();

var service = new GiftCardService(myShopifyUrl, shopAccessToken);
var giftCard = await service.CreateAsync(new GiftCard()
{
    InitialValue = 100,
    Code = "abc-bcd-efg"
});

var service = new GiftCardService(myShopifyUrl, shopAccessToken);
var giftCard = await service.GetAsync(giftCardId):

var service = new GiftCardService(myShopifyUrl, shopAccessToken);

await service.DisableAsync(discountId);

var service =  new GiftCardService(myShopifyUrl, shopAccessToken);
int giftCardCount = await service.CountAsync();

var service =  new GiftCardService(myShopifyUrl, shopAccessToken);
IEnumerable<GiftCard> giftCards = await Service.SearchAsync("code: abc-bcd-efg");

var service = new GiftCardAdjustmentService(myShopifyUrl, shopAccessToken);
var giftCardAdjustments = await service.ListAsync(giftCardId);

var service = new GiftCardAdjustmentService(myShopifyUrl, shopAccessToken);
var giftCard = await service.CreateAsync(giftCardId, new GiftCardAdjustment()
{
    Amount = -1.00,
});

var service = new GiftCardAdjustmentService(myShopifyUrl, shopAccessToken);
var giftCardAdjustment = await service.GetAsync(giftCardId, adjustmentId):

var service = new PriceRuleService(myShopifyUrl, shopAccessToken);
var priceRule = await service.CreateAsync(new PriceRule()
{
    Title = "My price rule",
    ValueType = "percentage",
    TargetType = "line_item",
    TargetSelection = "all",
    AllocationMethod = "across",
    Value = -10.0m,
    CustomerSelection = "all",
    OncePerCustomer = false,
    PrerequisiteSubtotalRange = new PrerequisiteValueRange()
    {
        GreaterThanOrEqualTo = 40m
    },
    StartsAt = new DateTimeOffset(DateTime.Now)
});

var service = new PriceRuleService(myShopifyUrl, shopAccessToken);
var updatedRule = await service.UpdateAsync(ruleId, new PriceRule()
{
    Value = -15.0m
});

var service = new PriceRuleService(myShopifyUrl, shopAccessToken);
var priceRule = await service.GetAsync(ruleId);

var service = new PriceRuleService(myShopifyUrl, shopAccessToken);
var priceRules = await service.ListAsync();

var service = new PriceRuleService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(ruleId);

var service = new UserService(myShopifyUrl, shopAccessToken);
var users = await service.ListAsync();

var service = new UserService(myShopifyUrl, shopAccessToken);
var user = await service.GetAsync(userId):

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkouts = await service.ListAsync();

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var draftOrders = await service.ListAsync();

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var count = await service.CountAsync();

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var draftOrder = await service.GetAsync(draftOrderId);

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var draftOrder = await Service.CreateAsync(new DraftOrder()
{
    LineItems = new List<DraftLineItem>()
    {
        new DraftLineItem()
        {
            Title = "My custom line item",
            Price = 15.00m,
            Quantity = 1,
        }
    },
    Note = "Hello world!"
});

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var original = await Service.GetAsync(originalOrderId);
original.Note = "My new note";

var updated = await Service.UpdateAsync(originalOrderId, original);

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);

await service.DeleteAsync(orderId);

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
var invoice = await service.SendInvoiceAsync(new DraftOrderInvoice()
{
    To = "[email protected]",
    Subject = "Your order is ready to pay",
    CustomMessage = "Please pay!"
});

var service = new DraftOrderService(myShopifyUrl, shopAccessToken);
bool paymentPending = false;
var draftOrder = await service.CompleteAsync(orderId, paymentPending);

var service = new AccessScopeService(myShopifyUrl, shopAccessToken);
var scopes = await service.ListAsync();

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkout = await service.CreateAsync(new Checkout
{
    Email = "[email protected]"
});

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkoutToken = "token";
var checkout = await service.CompleteAsync(checkoutToken);

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkoutToken = "token";
var checkout = await service.GetAsync(checkoutToken);

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkoutToken = "token";
var checkout = await service.UpdateAsync(checkoutToken, new Checkout
{
    Email = "[email protected]"
});

var service = new CheckoutService(myShopifyUrl, shopAccessToken);
var checkoutToken = "token";
var shippingRates = await service.ListShippingRatesAsync(checkoutToken);

var service = new CollectionService(myShopifyUrl, shopAccessToken);
var collection = await service.GetAsync(collectionId);

var service = new CollectionService(myShopifyUrl, shopAccessToken);
var products = await service.ListAsync(collectionId);

var service = new StorefrontAccessTokenService(myShopifyUrl, shopAccessToken);
var token = await service.CreateAsync("My storefront access token");