# Cache ## Purge Cached Content `client.Cache.Purge(ctx, params) (*CachePurgeResponse, error)` **post** `/zones/{zone_id}/purge_cache` ### Purge All Cached Content Removes ALL files from Cloudflare's cache. All tiers can purge everything. ``` {"purge_everything": true} ``` ### Purge Cached Content by URL Granularly removes one or more files from Cloudflare's cache by specifying URLs. All tiers can purge by URL. To purge files with custom cache keys, include the headers used to compute the cache key as in the example. If you have a device type or geo in your cache key, you will need to include the CF-Device-Type or CF-IPCountry headers. If you have lang in your cache key, you will need to include the Accept-Language header. **NB:** When including the Origin header, be sure to include the **scheme** and **hostname**. The port number can be omitted if it is the default port (80 for http, 443 for https), but must be included otherwise. Single file purge example with files: ``` {"files": ["http://www.example.com/css/styles.css", "http://www.example.com/js/index.js"]} ``` Single file purge example with url and header pairs: ``` {"files": [{url: "http://www.example.com/cat_picture.jpg", headers: { "CF-IPCountry": "US", "CF-Device-Type": "desktop", "Accept-Language": "zh-CN" }}, {url: "http://www.example.com/dog_picture.jpg", headers: { "CF-IPCountry": "EU", "CF-Device-Type": "mobile", "Accept-Language": "en-US" }}]} ``` ### Purge Cached Content by Tag, Host or Prefix Granularly removes one or more files from Cloudflare's cache either by specifying the host, the associated Cache-Tag, or a Prefix. Flex purge with tags: ``` {"tags": ["a-cache-tag", "another-cache-tag"]} ``` Flex purge with hosts: ``` {"hosts": ["www.example.com", "images.example.com"]} ``` Flex purge with prefixes: ``` {"prefixes": ["www.example.com/foo", "images.example.com/bar/baz"]} ``` ### Availability and limits please refer to [purge cache availability and limits documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/#availability-and-limits). ### Parameters - `params CachePurgeParams` - `ZoneID param.Field[string]` Path param - `Tags param.Field[[]string]` Body param: For more information on cache tags and purging by tags, please refer to [purge by cache-tags documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-tags/). ### Returns - `type CachePurgeResponse struct{…}` - `ID string` ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.Purge(context.TODO(), cache.CachePurgeParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Body: cache.CachePurgeParamsBodyCachePurgeFlexPurgeByTags{ }, }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "023e105f4ecef8ad9ca31a8372d0c353" } } ``` # Cache Reserve ## Get Cache Reserve setting `client.Cache.CacheReserve.Get(ctx, query) (*CacheReserveGetResponse, error)` **get** `/zones/{zone_id}/cache/cache_reserve` Increase cache lifetimes by automatically storing all cacheable files into Cloudflare's persistent object storage buckets. Requires Cache Reserve subscription. Note: using Tiered Cache with Cache Reserve is highly recommended to reduce Reserve operations costs. See the [developer docs](https://developers.cloudflare.com/cache/about/cache-reserve) for more information. ### Parameters - `query CacheReserveGetParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type CacheReserveGetResponse struct{…}` - `ID CacheReserve` The identifier of the caching setting. - `const CacheReserveCacheReserve CacheReserve = "cache_reserve"` - `Editable bool` Whether the setting is editable. - `Value CacheReserveGetResponseValue` Value of the Cache Reserve zone setting. - `const CacheReserveGetResponseValueOn CacheReserveGetResponseValue = "on"` - `const CacheReserveGetResponseValueOff CacheReserveGetResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) cacheReserve, err := client.Cache.CacheReserve.Get(context.TODO(), cache.CacheReserveGetParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", cacheReserve.ID) } ``` #### Response ```json { "errors": [], "messages": [], "result": { "editable": true, "id": "cache_reserve", "value": "off" }, "success": true } ``` ## Change Cache Reserve setting `client.Cache.CacheReserve.Edit(ctx, params) (*CacheReserveEditResponse, error)` **patch** `/zones/{zone_id}/cache/cache_reserve` Increase cache lifetimes by automatically storing all cacheable files into Cloudflare's persistent object storage buckets. Requires Cache Reserve subscription. Note: using Tiered Cache with Cache Reserve is highly recommended to reduce Reserve operations costs. See the [developer docs](https://developers.cloudflare.com/cache/about/cache-reserve) for more information. ### Parameters - `params CacheReserveEditParams` - `ZoneID param.Field[string]` Path param: Identifier. - `Value param.Field[CacheReserveEditParamsValue]` Body param: Value of the Cache Reserve zone setting. - `const CacheReserveEditParamsValueOn CacheReserveEditParamsValue = "on"` - `const CacheReserveEditParamsValueOff CacheReserveEditParamsValue = "off"` ### Returns - `type CacheReserveEditResponse struct{…}` - `ID CacheReserve` The identifier of the caching setting. - `const CacheReserveCacheReserve CacheReserve = "cache_reserve"` - `Editable bool` Whether the setting is editable. - `Value CacheReserveEditResponseValue` Value of the Cache Reserve zone setting. - `const CacheReserveEditResponseValueOn CacheReserveEditResponseValue = "on"` - `const CacheReserveEditResponseValueOff CacheReserveEditResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.CacheReserve.Edit(context.TODO(), cache.CacheReserveEditParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Value: cloudflare.F(cache.CacheReserveEditParamsValueOn), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [], "messages": [], "result": { "editable": true, "id": "cache_reserve", "value": "on" }, "success": true } ``` ## Get Cache Reserve Clear `client.Cache.CacheReserve.Status(ctx, query) (*CacheReserveStatusResponse, error)` **get** `/zones/{zone_id}/cache/cache_reserve_clear` You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. ### Parameters - `query CacheReserveStatusParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type CacheReserveStatusResponse struct{…}` You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. - `ID CacheReserveClear` ID of the zone setting. - `const CacheReserveClearCacheReserveClear CacheReserveClear = "cache_reserve_clear"` - `StartTs Time` The time that the latest Cache Reserve Clear operation started. - `State State` The current state of the Cache Reserve Clear operation. - `const StateInProgress State = "In-progress"` - `const StateCompleted State = "Completed"` - `EndTs Time` The time that the latest Cache Reserve Clear operation completed. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.CacheReserve.Status(context.TODO(), cache.CacheReserveStatusParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [], "messages": [], "result": { "end_ts": "2023-10-02T12:00:00.12345Z", "id": "cache_reserve_clear", "start_ts": "2023-10-02T10:00:00.12345Z", "state": "Completed" }, "success": true } ``` ## Start Cache Reserve Clear `client.Cache.CacheReserve.Clear(ctx, params) (*CacheReserveClearResponse, error)` **post** `/zones/{zone_id}/cache/cache_reserve_clear` You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. ### Parameters - `params CacheReserveClearParams` - `ZoneID param.Field[string]` Path param: Identifier. - `Body param.Field[unknown]` Body param ### Returns - `type CacheReserveClearResponse struct{…}` You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. - `ID CacheReserveClear` ID of the zone setting. - `const CacheReserveClearCacheReserveClear CacheReserveClear = "cache_reserve_clear"` - `StartTs Time` The time that the latest Cache Reserve Clear operation started. - `State State` The current state of the Cache Reserve Clear operation. - `const StateInProgress State = "In-progress"` - `const StateCompleted State = "Completed"` - `EndTs Time` The time that the latest Cache Reserve Clear operation completed. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.CacheReserve.Clear(context.TODO(), cache.CacheReserveClearParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Body: map[string]interface{}{ }, }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [], "messages": [], "result": { "id": "cache_reserve_clear", "start_ts": "2023-10-02T10:00:00.12345Z", "state": "In-progress" }, "success": true } ``` ## Domain Types ### Cache Reserve - `type CacheReserve string` The identifier of the caching setting. - `const CacheReserveCacheReserve CacheReserve = "cache_reserve"` ### Cache Reserve Clear - `type CacheReserveClear string` ID of the zone setting. - `const CacheReserveClearCacheReserveClear CacheReserveClear = "cache_reserve_clear"` ### State - `type State string` The current state of the Cache Reserve Clear operation. - `const StateInProgress State = "In-progress"` - `const StateCompleted State = "Completed"` # Smart Tiered Cache ## Get Smart Tiered Cache setting `client.Cache.SmartTieredCache.Get(ctx, query) (*SmartTieredCacheGetResponse, error)` **get** `/zones/{zone_id}/cache/tiered_cache_smart_topology_enable` Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. ### Parameters - `query SmartTieredCacheGetParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type SmartTieredCacheGetResponse struct{…}` - `ID SmartTieredCacheGetResponseID` The identifier of the caching setting. - `const SmartTieredCacheGetResponseIDTieredCacheSmartTopologyEnable SmartTieredCacheGetResponseID = "tiered_cache_smart_topology_enable"` - `Editable bool` Whether the setting is editable. - `Value SmartTieredCacheGetResponseValue` Value of the Smart Tiered Cache zone setting. - `const SmartTieredCacheGetResponseValueOn SmartTieredCacheGetResponseValue = "on"` - `const SmartTieredCacheGetResponseValueOff SmartTieredCacheGetResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) smartTieredCache, err := client.Cache.SmartTieredCache.Get(context.TODO(), cache.SmartTieredCacheGetParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", smartTieredCache.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "tiered_cache_smart_topology_enable", "editable": true, "value": "on", "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Patch Smart Tiered Cache setting `client.Cache.SmartTieredCache.Edit(ctx, params) (*SmartTieredCacheEditResponse, error)` **patch** `/zones/{zone_id}/cache/tiered_cache_smart_topology_enable` Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. ### Parameters - `params SmartTieredCacheEditParams` - `ZoneID param.Field[string]` Path param: Identifier. - `Value param.Field[SmartTieredCacheEditParamsValue]` Body param: Enable or disable the Smart Tiered Cache. - `const SmartTieredCacheEditParamsValueOn SmartTieredCacheEditParamsValue = "on"` - `const SmartTieredCacheEditParamsValueOff SmartTieredCacheEditParamsValue = "off"` ### Returns - `type SmartTieredCacheEditResponse struct{…}` - `ID SmartTieredCacheEditResponseID` The identifier of the caching setting. - `const SmartTieredCacheEditResponseIDTieredCacheSmartTopologyEnable SmartTieredCacheEditResponseID = "tiered_cache_smart_topology_enable"` - `Editable bool` Whether the setting is editable. - `Value SmartTieredCacheEditResponseValue` Value of the Smart Tiered Cache zone setting. - `const SmartTieredCacheEditResponseValueOn SmartTieredCacheEditResponseValue = "on"` - `const SmartTieredCacheEditResponseValueOff SmartTieredCacheEditResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.SmartTieredCache.Edit(context.TODO(), cache.SmartTieredCacheEditParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Value: cloudflare.F(cache.SmartTieredCacheEditParamsValueOn), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "tiered_cache_smart_topology_enable", "editable": true, "value": "on", "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Delete Smart Tiered Cache setting `client.Cache.SmartTieredCache.Delete(ctx, body) (*SmartTieredCacheDeleteResponse, error)` **delete** `/zones/{zone_id}/cache/tiered_cache_smart_topology_enable` Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. ### Parameters - `body SmartTieredCacheDeleteParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type SmartTieredCacheDeleteResponse struct{…}` - `ID SmartTieredCacheDeleteResponseID` The identifier of the caching setting. - `const SmartTieredCacheDeleteResponseIDTieredCacheSmartTopologyEnable SmartTieredCacheDeleteResponseID = "tiered_cache_smart_topology_enable"` - `Editable bool` Whether the setting is editable. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) smartTieredCache, err := client.Cache.SmartTieredCache.Delete(context.TODO(), cache.SmartTieredCacheDeleteParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", smartTieredCache.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "tiered_cache_smart_topology_enable", "editable": true, "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` # Variants ## Get variants setting `client.Cache.Variants.Get(ctx, query) (*VariantGetResponse, error)` **get** `/zones/{zone_id}/cache/variants` Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. ### Parameters - `query VariantGetParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type VariantGetResponse struct{…}` - `ID VariantGetResponseID` The identifier of the caching setting. - `const VariantGetResponseIDVariants VariantGetResponseID = "variants"` - `Editable bool` Whether the setting is editable. - `Value VariantGetResponseValue` Value of the zone setting. - `AVIF []string` List of strings with the MIME types of all the variants that should be served for avif. - `BMP []string` List of strings with the MIME types of all the variants that should be served for bmp. - `GIF []string` List of strings with the MIME types of all the variants that should be served for gif. - `JP2 []string` List of strings with the MIME types of all the variants that should be served for jp2. - `JPEG []string` List of strings with the MIME types of all the variants that should be served for jpeg. - `JPG []string` List of strings with the MIME types of all the variants that should be served for jpg. - `JPG2 []string` List of strings with the MIME types of all the variants that should be served for jpg2. - `PNG []string` List of strings with the MIME types of all the variants that should be served for png. - `TIF []string` List of strings with the MIME types of all the variants that should be served for tif. - `TIFF []string` List of strings with the MIME types of all the variants that should be served for tiff. - `WebP []string` List of strings with the MIME types of all the variants that should be served for webp. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) variant, err := client.Cache.Variants.Get(context.TODO(), cache.VariantGetParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", variant.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "variants", "editable": true, "value": { "avif": [ "image/webp", "image/jpeg" ], "bmp": [ "image/webp", "image/jpeg" ], "gif": [ "image/webp", "image/jpeg" ], "jp2": [ "image/webp", "image/avif" ], "jpeg": [ "image/webp", "image/avif" ], "jpg": [ "image/webp", "image/avif" ], "jpg2": [ "image/webp", "image/avif" ], "png": [ "image/webp", "image/avif" ], "tif": [ "image/webp", "image/avif" ], "tiff": [ "image/webp", "image/avif" ], "webp": [ "image/jpeg", "image/avif" ] }, "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Change variants setting `client.Cache.Variants.Edit(ctx, params) (*VariantEditResponse, error)` **patch** `/zones/{zone_id}/cache/variants` Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. ### Parameters - `params VariantEditParams` - `ZoneID param.Field[string]` Path param: Identifier. - `Value param.Field[VariantEditParamsValue]` Body param: Value of the zone setting. - `AVIF []string` List of strings with the MIME types of all the variants that should be served for avif. - `BMP []string` List of strings with the MIME types of all the variants that should be served for bmp. - `GIF []string` List of strings with the MIME types of all the variants that should be served for gif. - `JP2 []string` List of strings with the MIME types of all the variants that should be served for jp2. - `JPEG []string` List of strings with the MIME types of all the variants that should be served for jpeg. - `JPG []string` List of strings with the MIME types of all the variants that should be served for jpg. - `JPG2 []string` List of strings with the MIME types of all the variants that should be served for jpg2. - `PNG []string` List of strings with the MIME types of all the variants that should be served for png. - `TIF []string` List of strings with the MIME types of all the variants that should be served for tif. - `TIFF []string` List of strings with the MIME types of all the variants that should be served for tiff. - `WebP []string` List of strings with the MIME types of all the variants that should be served for webp. ### Returns - `type VariantEditResponse struct{…}` - `ID VariantEditResponseID` The identifier of the caching setting. - `const VariantEditResponseIDVariants VariantEditResponseID = "variants"` - `Editable bool` Whether the setting is editable. - `Value VariantEditResponseValue` Value of the zone setting. - `AVIF []string` List of strings with the MIME types of all the variants that should be served for avif. - `BMP []string` List of strings with the MIME types of all the variants that should be served for bmp. - `GIF []string` List of strings with the MIME types of all the variants that should be served for gif. - `JP2 []string` List of strings with the MIME types of all the variants that should be served for jp2. - `JPEG []string` List of strings with the MIME types of all the variants that should be served for jpeg. - `JPG []string` List of strings with the MIME types of all the variants that should be served for jpg. - `JPG2 []string` List of strings with the MIME types of all the variants that should be served for jpg2. - `PNG []string` List of strings with the MIME types of all the variants that should be served for png. - `TIF []string` List of strings with the MIME types of all the variants that should be served for tif. - `TIFF []string` List of strings with the MIME types of all the variants that should be served for tiff. - `WebP []string` List of strings with the MIME types of all the variants that should be served for webp. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.Variants.Edit(context.TODO(), cache.VariantEditParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Value: cloudflare.F(cache.VariantEditParamsValue{ }), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "variants", "editable": true, "value": { "avif": [ "image/webp", "image/jpeg" ], "bmp": [ "image/webp", "image/jpeg" ], "gif": [ "image/webp", "image/jpeg" ], "jp2": [ "image/webp", "image/avif" ], "jpeg": [ "image/webp", "image/avif" ], "jpg": [ "image/webp", "image/avif" ], "jpg2": [ "image/webp", "image/avif" ], "png": [ "image/webp", "image/avif" ], "tif": [ "image/webp", "image/avif" ], "tiff": [ "image/webp", "image/avif" ], "webp": [ "image/jpeg", "image/avif" ] }, "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Delete variants setting `client.Cache.Variants.Delete(ctx, body) (*VariantDeleteResponse, error)` **delete** `/zones/{zone_id}/cache/variants` Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. ### Parameters - `body VariantDeleteParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type VariantDeleteResponse struct{…}` - `ID VariantDeleteResponseID` The identifier of the caching setting. - `const VariantDeleteResponseIDVariants VariantDeleteResponseID = "variants"` - `Editable bool` Whether the setting is editable. - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) variant, err := client.Cache.Variants.Delete(context.TODO(), cache.VariantDeleteParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", variant.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "variants", "editable": true, "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Domain Types ### Cache Variant - `type CacheVariant struct{…}` Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. - `ID CacheVariantID` ID of the zone setting. - `const CacheVariantIDVariants CacheVariantID = "variants"` - `ModifiedOn Time` Last time this setting was modified. # Regional Tiered Cache ## Get Regional Tiered Cache setting `client.Cache.RegionalTieredCache.Get(ctx, query) (*RegionalTieredCacheGetResponse, error)` **get** `/zones/{zone_id}/cache/regional_tiered_cache` Instructs Cloudflare to check a regional hub data center on the way to your upper tier. This can help improve performance for smart and custom tiered cache topologies. ### Parameters - `query RegionalTieredCacheGetParams` - `ZoneID param.Field[string]` Identifier. ### Returns - `type RegionalTieredCacheGetResponse struct{…}` - `ID RegionalTieredCache` The identifier of the caching setting. - `const RegionalTieredCacheTcRegional RegionalTieredCache = "tc_regional"` - `Editable bool` Whether the setting is editable. - `Value RegionalTieredCacheGetResponseValue` Value of the Regional Tiered Cache zone setting. - `const RegionalTieredCacheGetResponseValueOn RegionalTieredCacheGetResponseValue = "on"` - `const RegionalTieredCacheGetResponseValueOff RegionalTieredCacheGetResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) regionalTieredCache, err := client.Cache.RegionalTieredCache.Get(context.TODO(), cache.RegionalTieredCacheGetParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", regionalTieredCache.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "tc_regional", "editable": true, "value": "on", "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Change Regional Tiered Cache setting `client.Cache.RegionalTieredCache.Edit(ctx, params) (*RegionalTieredCacheEditResponse, error)` **patch** `/zones/{zone_id}/cache/regional_tiered_cache` Instructs Cloudflare to check a regional hub data center on the way to your upper tier. This can help improve performance for smart and custom tiered cache topologies. ### Parameters - `params RegionalTieredCacheEditParams` - `ZoneID param.Field[string]` Path param: Identifier. - `Value param.Field[RegionalTieredCacheEditParamsValue]` Body param: Value of the Regional Tiered Cache zone setting. - `const RegionalTieredCacheEditParamsValueOn RegionalTieredCacheEditParamsValue = "on"` - `const RegionalTieredCacheEditParamsValueOff RegionalTieredCacheEditParamsValue = "off"` ### Returns - `type RegionalTieredCacheEditResponse struct{…}` - `ID RegionalTieredCache` The identifier of the caching setting. - `const RegionalTieredCacheTcRegional RegionalTieredCache = "tc_regional"` - `Editable bool` Whether the setting is editable. - `Value RegionalTieredCacheEditResponseValue` Value of the Regional Tiered Cache zone setting. - `const RegionalTieredCacheEditResponseValueOn RegionalTieredCacheEditResponseValue = "on"` - `const RegionalTieredCacheEditResponseValueOff RegionalTieredCacheEditResponseValue = "off"` - `ModifiedOn Time` Last time this setting was modified. ### Example ```go package main import ( "context" "fmt" "github.com/cloudflare/cloudflare-go" "github.com/cloudflare/cloudflare-go/cache" "github.com/cloudflare/cloudflare-go/option" ) func main() { client := cloudflare.NewClient( option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"), ) response, err := client.Cache.RegionalTieredCache.Edit(context.TODO(), cache.RegionalTieredCacheEditParams{ ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"), Value: cloudflare.F(cache.RegionalTieredCacheEditParamsValueOn), }) if err != nil { panic(err.Error()) } fmt.Printf("%+v\n", response.ID) } ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "tc_regional", "editable": true, "value": "on", "modified_on": "2014-01-01T05:20:00.12345Z" } } ``` ## Domain Types ### Regional Tiered Cache - `type RegionalTieredCache string` The identifier of the caching setting. - `const RegionalTieredCacheTcRegional RegionalTieredCache = "tc_regional"`