import {z} from 'zod'

export type EventSubjectHref = string;

export type EventMessage = string;

export type EventSeverity = 'info' | 'severe' | 'warning';

export type Timestamp = string;

export type EventPost = {subject: EventSubjectHref, message: EventMessage, severity: EventSeverity, type: string, details?: (Record<string, never> | null) | undefined, origin?: string | undefined, originated?: Timestamp | undefined};

export type CreateApiEventsArgs = {body: EventPost};

export type CreateApiEventsOptions = {baseUrl?: string | undefined, fetch?: typeof fetch | undefined};

export const timestamp = z.string();

export const botManagement = z.object({user_agent: z.boolean()});

export const servicesHref = z.string();

export const component = z.object({layer_name: z.string().min(1).optional(), element: servicesHref.optional()});

export const cdnControlPath = z.string().min(1).max(255);

export const cdnCacheKey = z.object({headers: z.enum(["none", "include-specified"]), header_names: z.array(z.string()).optional(), cookies: z.enum(["none", "all", "include-specified", "exclude-specified"]), cookie_names: z.array(z.string()).optional(), queries: z.enum(["none", "all", "include-specified", "exclude-specified"]), query_names: z.array(z.string()).optional()});

export const cdnOriginRequest = z.object({headers: z.enum(["none", "all", "include-specified"]), header_names: z.array(z.string()).optional(), cookies: z.enum(["none", "all", "include-specified"]), cookie_names: z.array(z.string()).optional(), queries: z.enum(["none", "all", "include-specified"]), query_names: z.array(z.string()).optional()});

export const handlerHref = z.string();

export const cdnControl = z.object({path_pattern: cdnControlPath, default_ttl: z.number().int().gte(0).lte(31536000).optional(), cache_key: cdnCacheKey, origin_request: cdnOriginRequest.optional(), origin_request_handlers: z.array(handlerHref).optional(), origin_response_handlers: z.array(handlerHref).optional()});

export const cdnConfiguration = z.object({controls: z.array(cdnControl)});

export const alias = z.string();

export const serversHostname = z.string();

export const resourceReference = z.object({href: z.string()});

export const secretHref = z.string();

export const tlsVersion = z.enum(["TlsV1.1", "TlsV1.2"]);

export const coveredAlias = z.object({name: z.string(), not_after: timestamp, trusted: z.boolean()});

export const tlsConfiguration = z.object({private_key: z.union([resourceReference, z.string()]).optional(), private_keys: z.array(z.union([resourceReference, secretHref])).optional(), certificate_chain: z.string().min(1).optional(), enable_auto_tls: z.boolean().optional(), enable_force_tls: z.boolean().optional(), enable_tls_offloading: z.boolean().optional(), enable_server_validation: z.boolean().optional(), tolerate_invalid_chain: z.boolean().optional(), versions: z.array(tlsVersion).optional(), covered_aliases: z.array(coveredAlias).optional()});

export const metricConfiguration = z.object({name: z.string().min(1).max(50).optional(), frequency: z.number().int().optional(), prototype: z.string()});

export const monitoring = z.enum(["none", "passive", "active"]);

export const wafFileReference = z.object({file: resourceReference, name: z.string().min(1).max(50), created: z.string().optional(), active: z.number().int().gte(0).lte(1)});

export const cidr = z.string();

export const addressSetEntry = z.object({created: timestamp.optional(), created_by: z.string().optional(), description: z.string().optional(), address: cidr, expiry: timestamp.optional()});

export const addressSetHref = z.string();

export const concurrentLimit = z.number().int().gte(1).lte(1024);

export const maximumQueueTime = z.number().int().gte(1);

export const mergeSlashes = z.boolean();

export const suspendLimit = z.number().int().gte(1);

export const clusterHref = z.string().nullable();

export const address = z.string();

export const applicationServer = z.object({public_address: address, description: z.string().max(255).optional()});

export const pageControlConditionAuthCookieIsNotSet = z.object({name: z.string().min(1)});

export const pageControlConditionAuthCookieIsSet = z.object({name: z.string().min(1)});

export const pageControlConditionCookieIsNotSet = z.object({name: z.string().min(1)});

export const pageControlConditionCookieIsSet = z.object({name: z.string().min(1)});

export const pageControlConditionCookieValueDoesNotMatch = z.object({name: z.string().min(1), pattern: z.string().min(1).max(255)});

export const pageControlConditionCookieValueMatches = z.object({name: z.string().min(1), pattern: z.string().min(1).max(255)});

export const countryCode = z.string();

export const countryCodes = z.array(countryCode);

export const pageControlConditionCountryIsNotIncluded = z.object({list: countryCodes});

export const pageControlConditionCountryIsIncluded = z.object({list: countryCodes});

export const pageControlConditionHeaderValueMatches = z.object({name: z.string().min(1), pattern: z.string().min(1).max(255)});

export const conditionHeader = z.object({name: z.string().min(1), pattern: z.string().min(1).max(255)});

export const conditionHeaders = z.array(conditionHeader);

export const methodName = z.string().min(3).max(20);

export const methodNames = z.array(methodName);

export const pageControlMethodIsIncluded = z.object({values: methodNames});

export const pageControlMethodIsNotIncluded = z.object({values: methodNames});

export const pageControlConditionAddressInSet = z.object({address_set: addressSetHref});

export const pageControlConditionAddressNotInSet = z.object({address_set: addressSetHref});

export const pageControlConditionRandom = z.object({probability: z.number()});

export const durationDisplayUnit = z.enum(["seconds", "minutes", "hours"]);

export const pageControlConditionRateLimit = z.object({duration: z.number().int().gte(5), display_unit: durationDisplayUnit, threshold: z.number().int().gte(1)});

export const pageControlConditionStatusCodeMatches = z.object({pattern: z.string().min(1).max(255)});

export const conditionUrl = z.object({scheme: z.string().optional(), domain: z.string().max(255).optional(), path: z.string().max(760).optional(), query: z.string().max(760).optional()});

export const conditionUrls = z.array(conditionUrl);

export const pageControlConditionUserAgentMatches = z.object({pattern: z.string().min(1)});

export const pageControlConditionUserAgentDoesNotMatch = z.object({pattern: z.string().min(1)});

export const pageControlConditions = z.object({address_is_whitelisted: z.object({}).optional(), address_is_not_whitelisted: z.object({}).optional(), auth_cookie_is_not_set: pageControlConditionAuthCookieIsNotSet.optional(), auth_cookie_is_set: pageControlConditionAuthCookieIsSet.optional(), cookie_is_not_set: pageControlConditionCookieIsNotSet.optional(), cookie_is_set: pageControlConditionCookieIsSet.optional(), cookie_value_does_not_match: pageControlConditionCookieValueDoesNotMatch.optional(), cookie_value_matches: pageControlConditionCookieValueMatches.optional(), country_is_not: pageControlConditionCountryIsNotIncluded.optional(), country_is: pageControlConditionCountryIsIncluded.optional(), header_value_matches: pageControlConditionHeaderValueMatches.optional(), header_value_does_not_match: pageControlConditionHeaderValueMatches.optional(), headers_match: conditionHeaders.optional(), headers_not_match: conditionHeaders.optional(), method_is: pageControlMethodIsIncluded.optional(), method_is_not: pageControlMethodIsNotIncluded.optional(), address_is_threat: z.object({}).optional(), address_is_not_threat: z.object({}).optional(), is_crawler: z.object({}).optional(), address_in_set: pageControlConditionAddressInSet.optional(), address_not_in_set: pageControlConditionAddressNotInSet.optional(), random: pageControlConditionRandom.optional(), rate_limit: pageControlConditionRateLimit.optional(), referrer_is: z.array(z.string().max(255)).optional(), referrer_is_not: z.array(z.string().max(255)).optional(), referrer_is_defined: z.object({}).optional(), referrer_is_not_defined: z.object({}).optional(), status_code_matches: pageControlConditionStatusCodeMatches.optional(), urls: conditionUrls.optional(), url_is_not: conditionUrls.optional(), user_agent_matches: pageControlConditionUserAgentMatches.optional(), user_agent_does_not_match: pageControlConditionUserAgentDoesNotMatch.optional()});

export const pageControlActionAddIPToList = z.object({type: z.literal("add-address-to-set"), address_set: addressSetHref, ttl: z.number().gte(300).optional()});

export const label = z.string();

export const pageControlActionAddLabels = z.object({type: z.literal("add-labels"), labels: z.array(label)});

export const pageControlActionCacheOverrides = z.object({type: z.literal("cache-overrides"), setting: z.string()});

export const pageControlActionContinue = z.object({type: z.literal("continue")});

export const pageControlActionDeny = z.object({type: z.literal("deny"), status_code: z.string(), body: z.string()});

export const pageControlActionDisableRum = z.object({type: z.literal("disable-rum")});

export const pageControlActionDisableSessionTracking = z.object({type: z.literal("disable-session-tracking")});

export const pageControlActionDiscontinue = z.object({type: z.literal("discontinue")});

export const pageControlActionDrop = z.object({type: z.literal("drop")});

export const pageControlActionRedirect = z.object({type: z.literal("redirect"), status_code: z.string(), location: z.string()});

export const pageControlActionRedirectUsingMap = z.object({type: z.literal("redirect-using-map"), preserve_query: z.boolean(), status_code: z.string(), url_map: z.string()});

export const pageControlActionRewriteUrl = z.object({type: z.literal("rewrite-url"), url: z.string()});

export const positiveInteger = z.number().int().gte(1);

export const pageControlActionSetRequestTimeout = z.object({type: z.literal("set-request-timeout"), timeout: positiveInteger});

export const script = z.string().max(760);

export const pageControlActionScriptAddAsync = z.object({type: z.literal("script-add-async"), scripts: z.array(script)});

export const pageControlActionScriptAddDefer = z.object({type: z.literal("script-add-defer"), scripts: z.array(script)});

export const pageControlActionSetContentSecurityPolicy = z.object({type: z.literal("set-content-security-policy"), value: z.object({})});

export const pageControlActionSetAuthCookie = z.object({type: z.literal("set-auth-cookie"), name: z.string(), domain: z.string().max(255).optional(), duration: z.number().int(), path: z.string().optional()});

export const nonNegativeInteger = z.number().int().gte(0);

export const pageControlActionSetCookie = z.object({type: z.literal("set-cookie"), name: z.string(), value: z.string(), max_age: nonNegativeInteger.optional(), path: z.string().optional()});

export const pagespeedFilterName = z.enum(["add_base_tag", "add_head", "add_ids", "add_instrumentation", "cache_partial_html", "canonicalize_javascript_libraries", "collapse_whitespace", "combine_css", "combine_javascript", "combine_heads", "compute_statistics", "compute_critical_css", "convert_gif_to_png", "convert_jpeg_to_progressive", "convert_jpeg_to_webp", "convert_meta_tags", "convert_png_to_jpeg", "convert_to_webp_animated", "convert_to_webp_lossless", "debug", "decode_rewritten_urls", "dedup_inlined_images", "defer_iframe", "defer_javascript", "deterministic_js", "disable_javascript", "div_structure", "elide_attributes", "experiment_collect_mob_image_info", "explicit_close_tags", "extend_cache_css", "extend_cache_images", "extend_cache_pdfs", "extend_cache_scripts", "fallback_rewrite_css_urls", "fix_reflows", "flatten_css_imports", "flush_subresources", "in_place_optimize_for_browser", "include_js_source_maps", "inline_css", "inline_google_font_css", "inline_images", "inline_import_to_link", "inline_javascript", "inline_preview_images", "insert_dns_prefetch", "insert_ga", "insert_img_dimensions", "insert_image_dimensions", "jpeg_subsampling", "lazyload_images", "local_storage_cache", "left_trim_urls", "make_google_analytics_async", "make_show_ads_async", "mobilize", "mobilize_precompute", "move_css_above_scripts", "move_css_to_head", "outline_css", "outline_javascript", "pedantic", "prioritize_critical_css", "recompress_jpeg", "recompress_png", "recompress_webp", "remove_comments", "remove_quotes", "resize_images", "resize_mobile_images", "resize_rendered_image_dimensions", "responsive_images", "responsive_images_zoom", "rewrite_css", "rewrite_domains", "rewrite_javascript_external", "rewrite_javascript_inline", "rewrite_style_attributes", "rewrite_style_attributes_with_url", "split_html", "split_html_helper", "sprite_images", "strip_image_color_profile", "strip_image_meta_data", "strip_scripts", "trim_urls"]);

export const pageControlActionSetPagespeedOptions = z.object({type: z.literal("set-pagespeed-options"), disable_filters: z.array(pagespeedFilterName).optional(), enable: z.boolean().optional(), enable_filters: z.array(pagespeedFilterName).optional()});

export const pageControlActionSetRequestHeader = z.object({type: z.literal("set-request-header"), name: z.string(), value: z.string()});

export const pageControlActionSetResponseHeader = z.object({type: z.literal("set-response-header"), name: z.string(), value: z.string()});

export const fileHref = z.string();

export const pageControlActionServe = z.object({type: z.literal("serve"), code: z.string(), file: fileHref.optional(), path: z.string()});

export const pageControlActionServeCaptchaChallenge = z.object({type: z.literal("serve-captcha-challenge")});

export const pageControlActionTerminateHttps = z.object({type: z.literal("terminate-https")});

export const pageControlActionUseAlternateBackends = z.object({type: z.literal("use-alternate-backends"), cluster: clusterHref.optional(), servers: z.array(applicationServer).optional(), servers_hostname: serversHostname.optional(), remote_url: z.union([z.unknown(), z.string()]).optional(), relative_to: z.union([z.unknown(), z.string()]).optional()});

export const pageControlActionUserHasRole = z.object({type: z.literal("user-has-role"), roles: z.array(z.string().min(1))});

export const substitute = z.object({contains: z.string().min(1).max(255), replace: z.string().min(1).max(255)});

export const substitutes = z.array(substitute);

export const pageControlActionSubstitute = z.object({type: z.literal("substitute"), substitutes: substitutes});

export const pageControlActionUseServerlessFunction = z.object({type: z.literal("use-serverless-function").optional(), function: handlerHref});

export const pageControlAction = z.union([pageControlActionAddIPToList, pageControlActionAddLabels, pageControlActionCacheOverrides, pageControlActionContinue, pageControlActionDeny, pageControlActionDisableRum, pageControlActionDisableSessionTracking, pageControlActionDiscontinue, pageControlActionDrop, pageControlActionRedirect, pageControlActionRedirectUsingMap, pageControlActionRewriteUrl, pageControlActionSetRequestTimeout, pageControlActionScriptAddAsync, pageControlActionScriptAddDefer, pageControlActionSetContentSecurityPolicy, pageControlActionSetAuthCookie, pageControlActionSetCookie, pageControlActionSetPagespeedOptions, pageControlActionSetRequestHeader, pageControlActionSetResponseHeader, pageControlActionServe, pageControlActionServeCaptchaChallenge, pageControlActionTerminateHttps, pageControlActionUseAlternateBackends, pageControlActionUserHasRole, pageControlActionSubstitute, pageControlActionUseServerlessFunction]);

export const pageControlConfiguration = z.object({name: z.string().min(1).max(50), description: z.string().max(255).optional(), mode: z.enum(["maintenance", "request", "response"]).optional(), enabled: z.boolean().optional(), conditions: pageControlConditions.optional(), actions: z.array(pageControlAction)});

export const firewallHref = z.string();

export const securityGroupHref = z.string();

export const conditionAddressInSet = z.object({type: z.literal("address_in_set"), address_set: addressSetHref});

export const conditionAddressIsNotThreat = z.object({type: z.literal("address_is_not_threat")});

export const conditionAddressIsNotWhitelisted = z.object({type: z.literal("address_is_not_whitelisted")});

export const conditionAddressIsThreat = z.object({type: z.literal("address_is_threat")});

export const conditionAddressIsWhitelisted = z.object({type: z.literal("address_is_whitelisted")});

export const conditionAddressNotInSet = z.object({type: z.literal("address_not_in_set"), address_set: addressSetHref.optional()});

export const conditionAuthCookieIsNotSet = z.object({name: z.string().min(1), type: z.literal("auth_cookie_is_not_set")});

export const conditionAuthCookieIsSet = z.object({name: z.string().min(1), type: z.literal("auth_cookie_is_set")});

export const conditionCookieIsNotSet = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), type: z.literal("cookie_is_not_set")});

export const conditionCookieIsSet = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), type: z.literal("cookie_is_set")});

export const conditionCookieValueDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("cookie_value_does_not_match")});

export const conditionCookieValueMatches = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("cookie_value_matches")});

export const conditionCountryIs = z.object({list: countryCodes, type: z.literal("country_is")});

export const conditionCountryIsNot = z.object({list: countryCodes, type: z.literal("country_is_not")});

export const conditionRandom = z.object({probability: z.number().gte(0).lte(1), type: z.literal("random")});

export const referrerPatterns = z.array(z.string().min(1).max(255));

export const conditionReferrerDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), list: referrerPatterns, type: z.literal("referrer_is_not")});

export const conditionReferrerIsDefined = z.object({type: z.literal("referrer_is_defined")});

export const conditionReferrerIsNotDefined = z.object({type: z.literal("referrer_is_not_defined")});

export const conditionReferrerMatches = z.object({case_sensitive: z.boolean().optional(), list: referrerPatterns, type: z.literal("referrer_is")});

export const conditionUrlDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionUrls, type: z.literal("url_is_not")});

export const conditionUrlMatches = z.object({case_sensitive: z.boolean().optional(), list: conditionUrls, type: z.literal("urls")});

export const conditionUserAgentDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), pattern: z.string().min(1), type: z.literal("user_agent_does_not_match")});

export const conditionUserAgentMatches = z.object({case_sensitive: z.boolean().optional(), pattern: z.string().min(1), type: z.literal("user_agent_matches")});

export const conditionHeaderValueMatches = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("header_value_matches")});

export const conditionHeaderValueDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("header_value_does_not_match")});

export const conditionHeadersMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionHeaders, type: z.enum(["headers_match", "response_headers_match"])});

export const conditionHeadersNotMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionHeaders, type: z.enum(["headers_not_match", "response_headers_not_match"])});

export const conditionMethodIs = z.object({values: methodNames, type: z.literal("method_is")});

export const conditionMethodIsNot = z.object({values: methodNames, type: z.literal("method_is_not")});

export const conditionIsCrawler = z.object({type: z.literal("is_crawler")});

export const siteCacheCondition = z.union([conditionAddressInSet, conditionAddressIsNotThreat, conditionAddressIsNotWhitelisted, conditionAddressIsThreat, conditionAddressIsWhitelisted, conditionAddressNotInSet, conditionAuthCookieIsNotSet, conditionAuthCookieIsSet, conditionCookieIsNotSet, conditionCookieIsSet, conditionCookieValueDoesNotMatch, conditionCookieValueMatches, conditionCountryIs, conditionCountryIsNot, conditionRandom, conditionReferrerDoesNotMatch, conditionReferrerIsDefined, conditionReferrerIsNotDefined, conditionReferrerMatches, conditionUrlDoesNotMatch, conditionUrlMatches, conditionUserAgentDoesNotMatch, conditionUserAgentMatches, conditionHeaderValueMatches, conditionHeaderValueDoesNotMatch, conditionHeadersMatch, conditionHeadersNotMatch, conditionMethodIs, conditionMethodIsNot, conditionIsCrawler]);

export const cacheKeyConfiguration = z.object({browser: z.boolean().optional(), cookie: z.string().min(1).optional(), hostname: z.boolean().optional(), query: z.boolean().optional()});

export const cacheTagConfiguration = z.object({from: z.literal("header"), name: z.string().min(1)});

export const siteCacheRule = z.object({conditions: z.array(siteCacheCondition), enabled: z.boolean(), ttl_sec: z.number().gte(10), key: z.union([z.unknown(), cacheKeyConfiguration]).optional(), tags: cacheTagConfiguration.optional()});

export const siteCache = z.object({enabled: z.boolean(), rules: z.array(siteCacheRule)});

export const translatePath = z.enum(["preserve", "unescape"]);

export const conditionRateLimit = z.object({duration: z.number().int().gte(5), display_unit: durationDisplayUnit, threshold: z.number().int().gte(1), type: z.literal("rate_limit").optional()});

export const conditionStatusCodeMatches = z.object({pattern: z.string().min(1).max(255), type: z.literal("status_code_matches")});

export const webControlCondition = z.union([conditionAddressInSet, conditionAddressIsNotThreat, conditionAddressIsNotWhitelisted, conditionAddressIsThreat, conditionAddressIsWhitelisted, conditionAddressNotInSet, conditionAuthCookieIsNotSet, conditionAuthCookieIsSet, conditionCookieIsNotSet, conditionCookieIsSet, conditionCookieValueDoesNotMatch, conditionCookieValueMatches, conditionCountryIs, conditionCountryIsNot, conditionHeaderValueDoesNotMatch, conditionHeaderValueMatches, conditionHeadersMatch, conditionHeadersNotMatch, conditionMethodIs, conditionMethodIsNot, conditionRandom, conditionRateLimit, conditionReferrerDoesNotMatch, conditionReferrerIsDefined, conditionReferrerIsNotDefined, conditionReferrerMatches, conditionStatusCodeMatches, conditionUrlDoesNotMatch, conditionUrlMatches, conditionUserAgentDoesNotMatch, conditionUserAgentMatches, conditionIsCrawler]);

export const webControlConfiguration = z.object({name: z.string().min(1).max(50), description: z.string().max(255).optional(), mode: z.enum(["maintenance", "request", "response"]).optional(), enabled: z.boolean().optional(), conditions: z.array(webControlCondition).optional(), actions: z.array(pageControlAction)});

export const applicationLogRetention = z.object({type: z.enum(["default", "cdn", "custom", "csp-reports", "pageviews", "proxy-logs"]), online_days: z.number().int().gte(1).optional(), archive_days: z.number().int().gte(1).optional(), online_space_allowance: z.number().int().gte(1).optional(), archive_space_allowance: z.number().int().gte(1).optional()});

export const name = z.string().min(1);

export const instanceFlavor = z.enum(["micro", "small", "medium", "large", "xlarge"]);

export const scalingSeriesName = z.enum(["cpu_percent", "iowait_percent", "kilobytes_per_second", "loadavg_norm", "memory_used_percent", "requests_per_second"]);

export const scalingOperator = z.enum(["has_been_greater_than", "will_be_greater_than", "has_been_less_than", "will_be_less_than"]);

export const duration = z.number().int().gte(0);

export const scalingCondition = z.object({series_name: scalingSeriesName, operator: scalingOperator, value: z.number(), duration: duration, display_unit: durationDisplayUnit});

export const metadataFileEntry = z.object({file: z.string().optional(), path: z.string().optional()});

export const identityConfiguration = z.object({name: z.string(), client_id: z.string(), principal_id: z.string()});

export const providerResourceHref = z.string();

export const instanceTemplate = z.string();

export const metadataEntry = z.object({key: z.string().optional(), value: z.string().optional()});

export const serverGroupHref = z.string();

export const placementHref = z.union([providerResourceHref, serverGroupHref]);

export const providerHref = z.string();

export const providerAttributes = z.object({});

export const provider = z.object({created: timestamp.optional(), href: providerHref.optional(), name: name.optional(), type: z.enum(["aliyun", "aws", "centurylink", "cloudsigma", "google"]).optional(), links: providerAttributes.optional()});

export const blueprint = z.object({files: z.array(metadataFileEntry).optional(), identity: identityConfiguration.optional(), image: providerResourceHref.optional(), instance_template: instanceTemplate.optional(), instance_type: providerResourceHref.optional(), metadata: z.array(metadataEntry).optional(), networks: z.array(providerResourceHref).optional(), network_tags: z.array(z.string()).optional(), placement: placementHref.optional(), provider: provider.optional(), security_groups: z.array(securityGroupHref).optional(), storage_account: providerResourceHref.optional(), zone: providerResourceHref.optional()});

export const bootstrapConfiguration = z.object({file: fileHref, command: z.string().min(1)});

export const httpUrl = z.string();

export const header = z.object({name: z.string(), value: z.string()});

export const check = z.object({url: z.string(), allowed_status_code: z.string().optional(), body: z.string().optional(), headers: z.array(header).optional(), permitted_redirect_hosts: z.array(alias).optional(), prohibit_content: z.string().optional(), request_method: z.string().optional(), require_content: z.string().optional(), timeout: z.number().int().optional(), verify_certificates: z.boolean().optional()});

export const eventConfigurationModel = z.union([z.object({name: z.string().min(1).max(255).optional(), aliases: z.array(z.string()).optional(), bot_management: botManagement.optional(), cdn_aliases: z.array(z.string()).optional(), components: z.array(component).optional(), cdn_configuration: cdnConfiguration.optional(), cdn_ready: z.boolean().optional(), cdn_service: z.string().optional(), default_hostname: alias.optional(), dns_service: z.string().nullable().optional(), servers_hostname: z.union([z.unknown(), serversHostname]).optional(), delivery: z.enum(["cdn", "rewrite-to-cdn", "without-cdn"]).optional(), enable_cdn: z.boolean().optional(), enable_http2: z.boolean().optional(), enable_rum: z.boolean().optional(), enable_tls: z.boolean().optional(), tls_configuration: tlsConfiguration.optional(), metrics: z.array(metricConfiguration).optional(), monitoring: monitoring.optional(), waf_rules: z.array(wafFileReference).optional(), whitelist: z.array(addressSetEntry).optional(), whitelist_href: addressSetHref.optional(), blacklist: z.array(addressSetEntry).optional(), blacklist_href: addressSetHref.optional(), blacklist_user_agents: z.string().max(255).nullable().optional(), concurrent_limit: concurrentLimit.optional(), maximum_queue_time: maximumQueueTime.optional(), merge_slashes: mergeSlashes.optional(), suspend_limit: suspendLimit.optional(), probes: z.array(z.string()).optional(), protection: z.enum(["normal", "maximum"]).optional(), protection_captcha_retry_limit: z.number().int().gte(0).optional(), protection_blacklist_timeout: z.number().int().gte(0).optional(), protection_microsite_file: z.string().optional(), cluster: clusterHref.optional(), servers: z.union([z.unknown(), z.array(applicationServer)]).optional(), page_controls: z.array(pageControlConfiguration).optional(), request_timeout: z.number().int().gte(1).lte(60).optional(), shields: z.array(z.union([firewallHref, securityGroupHref])).optional(), shields_include_whitelist: z.boolean().optional(), site_cache: z.union([z.unknown(), siteCache]).optional(), trusted_proxies: z.union([z.unknown(), z.array(addressSetHref)]).optional(), data_planes: z.array(z.string()).optional(), trusted_proxies_only: z.boolean().optional(), trusted_proxies_header: z.string().min(1).optional(), labels: z.array(label).optional(), translate_path: translatePath.optional(), pagespeed_disallow: z.array(z.string()).optional(), pagespeed_exclude_agents: z.string().optional(), pagespeed_map_proxy_domains: z.array(z.string()).optional(), microsite: fileHref.optional(), web_controls: z.array(webControlConfiguration).optional(), stratus_id: z.union([z.unknown(), z.string()]).optional(), log_retention: z.array(applicationLogRetention).optional()}), z.object({name: name.optional(), minimum_size: nonNegativeInteger.optional(), maximum_size: nonNegativeInteger.optional(), manual_size: z.union([z.unknown(), nonNegativeInteger]).optional(), instance_type: instanceFlavor.optional(), scale_in_conditions: z.array(scalingCondition).optional(), scale_out_conditions: z.array(scalingCondition).optional(), server_blueprints: z.array(blueprint).optional(), bootstrap: bootstrapConfiguration.optional(), minimum_increment: positiveInteger.optional(), server_failure_timeout: duration.optional(), servers_update_webhook: httpUrl.optional(), verify_timeout: z.number().int().gte(60).optional(), failed_server_disposition: z.enum(["destroy", "detach"]).optional(), allocate_public_address: z.boolean().optional(), measurement_type: z.enum(["none", "lg-status", "self-reporting"]).optional(), checks: z.array(check).optional(), metadata: z.array(metadataEntry).optional(), files: z.array(metadataFileEntry).optional()}), z.object({})]);

export const eventActionDetails = z.object({name: z.string(), snapshot: eventConfigurationModel.optional()});

export const eventCreateDetails = z.object({snapshot: eventConfigurationModel});

export const eventDeleteDetails = z.object({snapshot: eventConfigurationModel});

export const jsonPatchOperation = z.object({op: z.enum(["add", "remove", "replace", "move", "copy", "test"]), path: z.string(), value: z.union([z.boolean(), z.string(), z.array(z.unknown()), z.object({}), z.number()]).optional(), from: z.string().optional()});

export const jsonPatch = z.array(jsonPatchOperation);

export const eventUpdateDetails = z.object({snapshot: eventConfigurationModel, change: jsonPatch});

export const anyObject = z.object({});

export const incidentHref = z.string();

export const eventMessage = z.string().min(1);

export const eventSeverity = z.enum(["info", "severe", "warning"]);

export const eventSubjectHref = z.string();

export const eventTypeHref = z.string();

export const event = z.object({created: timestamp, details: z.union([eventActionDetails, eventActionDetails, eventCreateDetails, eventDeleteDetails, eventUpdateDetails, anyObject]).optional(), incident: incidentHref, message: eventMessage, severity: eventSeverity, subject: eventSubjectHref.optional(), type: eventTypeHref, origin: z.string().max(200).optional(), originated: timestamp.optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Submit an external event
 * 
 * POST /events
 */
export const createApiEvents = async (args: CreateApiEventsArgs, options?: CreateApiEventsOptions) => {
const {baseUrl = "https://api.webscale.com/v2", fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

const url = `${baseUrl.replace(/\/+$/, '')}/events${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(event, await res.json())
};