import {z} from 'zod'

export type PlanReadWrite = {href: string};

export type SubscriptionReadWrite = {plan: PlanReadWrite};

export type BotManagement = {user_agent: boolean};

export type ServicesHref = string;

export type Component = {layer_name?: string | undefined, element?: ServicesHref | undefined};

export type CdnControlPath = string;

export type CdnCacheKey = {headers: 'none' | 'include-specified', header_names?: Array<string> | undefined, cookies: 'none' | 'all' | 'include-specified' | 'exclude-specified', cookie_names?: Array<string> | undefined, queries: 'none' | 'all' | 'include-specified' | 'exclude-specified', query_names?: Array<string> | undefined};

export type CdnOriginRequest = {headers: 'none' | 'all' | 'include-specified', header_names?: Array<string> | undefined, cookies: 'none' | 'all' | 'include-specified', cookie_names?: Array<string> | undefined, queries: 'none' | 'all' | 'include-specified', query_names?: Array<string> | undefined};

export type HandlerHref = string;

export type CdnControl = {path_pattern: CdnControlPath, default_ttl?: number | undefined, cache_key: CdnCacheKey, origin_request?: CdnOriginRequest | undefined, origin_request_handlers?: Array<HandlerHref> | undefined, origin_response_handlers?: Array<HandlerHref> | undefined};

export type CdnConfiguration = {controls: Array<CdnControl>};

export type Alias = string;

export type ServersHostname = string;

export type ResourceReference = {href: string};

export type SecretHref = string;

export type TlsVersion = 'TlsV1.1' | 'TlsV1.2';

export type Timestamp = string;

export type CoveredAlias = {name: string, not_after: Timestamp, trusted: boolean};

export type TlsConfiguration = {private_key?: (ResourceReference | string) | undefined, private_keys?: (Array<ResourceReference | SecretHref>) | undefined, certificate_chain?: string | undefined, enable_auto_tls?: boolean | undefined, enable_force_tls?: boolean | undefined, enable_tls_offloading?: boolean | undefined, enable_server_validation?: boolean | undefined, tolerate_invalid_chain?: boolean | undefined, versions?: Array<TlsVersion> | undefined, covered_aliases?: Array<CoveredAlias> | undefined};

export type MetricConfiguration = {name?: string | undefined, frequency?: number | undefined, prototype: string};

export type Monitoring = 'none' | 'passive' | 'active';

export type WafFileReference = {file: ResourceReference, name: string, created?: string | undefined, active: number};

export type Cidr = string;

export type AddressSetEntry = {created?: Timestamp | undefined, created_by?: string | undefined, description?: string | undefined, address: Cidr, expiry?: Timestamp | undefined};

export type AddressSetHref = string;

export type ConcurrentLimit = number;

export type MaximumQueueTime = number;

export type MergeSlashes = boolean;

export type SuspendLimit = number;

export type ClusterHref = string | null;

export type Address = string;

export type ApplicationServer = {public_address: Address, description?: string | undefined};

export type PageControlConditionAuthCookieIsNotSet = {name: string};

export type PageControlConditionAuthCookieIsSet = {name: string};

export type PageControlConditionCookieIsNotSet = {name: string};

export type PageControlConditionCookieIsSet = {name: string};

export type PageControlConditionCookieValueDoesNotMatch = {name: string, pattern: unknown};

export type PageControlConditionCookieValueMatches = {name: string, pattern: unknown};

export type CountryCode = string;

export type CountryCodes = Array<CountryCode>;

export type PageControlConditionCountryIsNotIncluded = {list: CountryCodes};

export type PageControlConditionCountryIsIncluded = {list: CountryCodes};

export type PageControlConditionHeaderValueMatches = {name: string, pattern: unknown};

export type ConditionHeader = {name: string, pattern: unknown};

export type ConditionHeaders = Array<ConditionHeader>;

export type MethodName = string;

export type MethodNames = Array<MethodName>;

export type PageControlMethodIsIncluded = {values: MethodNames};

export type PageControlMethodIsNotIncluded = {values: MethodNames};

export type PageControlConditionAddressInSet = {address_set: AddressSetHref};

export type PageControlConditionAddressNotInSet = {address_set: AddressSetHref};

export type PageControlConditionRandom = {probability: number};

export type DurationDisplayUnit = 'seconds' | 'minutes' | 'hours';

export type PageControlConditionRateLimit = {duration: number, display_unit: DurationDisplayUnit, threshold: number};

export type PageControlConditionStatusCodeMatches = {pattern: unknown};

export type ConditionUrl = {scheme?: string | undefined, domain?: string | undefined, path?: string | undefined, query?: string | undefined};

export type ConditionUrls = Array<ConditionUrl>;

export type PageControlConditionUserAgentMatches = {pattern: string};

export type PageControlConditionUserAgentDoesNotMatch = {pattern: string};

export type PageControlConditions = {address_is_whitelisted?: Record<string, never> | undefined, address_is_not_whitelisted?: Record<string, never> | undefined, auth_cookie_is_not_set?: PageControlConditionAuthCookieIsNotSet | undefined, auth_cookie_is_set?: PageControlConditionAuthCookieIsSet | undefined, cookie_is_not_set?: PageControlConditionCookieIsNotSet | undefined, cookie_is_set?: PageControlConditionCookieIsSet | undefined, cookie_value_does_not_match?: PageControlConditionCookieValueDoesNotMatch | undefined, cookie_value_matches?: PageControlConditionCookieValueMatches | undefined, country_is_not?: PageControlConditionCountryIsNotIncluded | undefined, country_is?: PageControlConditionCountryIsIncluded | undefined, header_value_matches?: PageControlConditionHeaderValueMatches | undefined, header_value_does_not_match?: PageControlConditionHeaderValueMatches | undefined, headers_match?: ConditionHeaders | undefined, headers_not_match?: ConditionHeaders | undefined, method_is?: PageControlMethodIsIncluded | undefined, method_is_not?: PageControlMethodIsNotIncluded | undefined, address_is_threat?: Record<string, never> | undefined, address_is_not_threat?: Record<string, never> | undefined, is_crawler?: Record<string, never> | undefined, address_in_set?: PageControlConditionAddressInSet | undefined, address_not_in_set?: PageControlConditionAddressNotInSet | undefined, random?: PageControlConditionRandom | undefined, rate_limit?: PageControlConditionRateLimit | undefined, referrer_is?: Array<string> | undefined, referrer_is_not?: Array<string> | undefined, referrer_is_defined?: Record<string, never> | undefined, referrer_is_not_defined?: Record<string, never> | undefined, status_code_matches?: PageControlConditionStatusCodeMatches | undefined, urls?: ConditionUrls | undefined, url_is_not?: ConditionUrls | undefined, user_agent_matches?: PageControlConditionUserAgentMatches | undefined, user_agent_does_not_match?: PageControlConditionUserAgentDoesNotMatch | undefined};

export type PageControlActionAddIPToList = {type: 'add-address-to-set', address_set: AddressSetHref, ttl?: number | undefined};

export type Label = string;

export type PageControlActionAddLabels = {type: 'add-labels', labels: Array<Label>};

export type PageControlActionCacheOverrides = {type: 'cache-overrides', setting: string};

export type PageControlActionContinue = {type: 'continue'};

export type PageControlActionDeny = {type: 'deny', status_code: string, body: string};

export type PageControlActionDisableRum = {type: 'disable-rum'};

export type PageControlActionDisableSessionTracking = {type: 'disable-session-tracking'};

export type PageControlActionDiscontinue = {type: 'discontinue'};

export type PageControlActionDrop = {type: 'drop'};

export type PageControlActionRedirect = {type: 'redirect', status_code: string, location: string};

export type PageControlActionRedirectUsingMap = {type: 'redirect-using-map', preserve_query: boolean, status_code: string, url_map: string};

export type PageControlActionRewriteUrl = {type: 'rewrite-url', url: string};

export type PositiveInteger = number;

export type PageControlActionSetRequestTimeout = {type: 'set-request-timeout', timeout: PositiveInteger};

export type Script = string;

export type PageControlActionScriptAddAsync = {type: 'script-add-async', scripts: Array<Script>};

export type PageControlActionScriptAddDefer = {type: 'script-add-defer', scripts: Array<Script>};

export type PageControlActionSetContentSecurityPolicy = {type: 'set-content-security-policy', value: Record<string, never>};

export type PageControlActionSetAuthCookie = {type: 'set-auth-cookie', name: string, domain?: string | undefined, duration: number, path?: string | undefined};

export type NonNegativeInteger = number;

export type PageControlActionSetCookie = {type: 'set-cookie', name: string, value: string, max_age?: NonNegativeInteger | undefined, path?: string | undefined};

export type PagespeedFilterName = '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 type PageControlActionSetPagespeedOptions = {type: 'set-pagespeed-options', disable_filters?: Array<PagespeedFilterName> | undefined, enable?: boolean | undefined, enable_filters?: Array<PagespeedFilterName> | undefined};

export type PageControlActionSetRequestHeader = {type: 'set-request-header', name: string, value: string};

export type PageControlActionSetResponseHeader = {type: 'set-response-header', name: string, value: string};

export type FileHref = string;

export type PageControlActionServe = {type: 'serve', code: string, file?: FileHref | undefined, path: string};

export type PageControlActionServeCaptchaChallenge = {type: 'serve-captcha-challenge'};

export type PageControlActionTerminateHttps = {type: 'terminate-https'};

export type PageControlActionUseAlternateBackends = {type: 'use-alternate-backends', cluster?: ClusterHref | undefined, servers?: Array<ApplicationServer> | undefined, servers_hostname?: ServersHostname | undefined, remote_url?: (unknown | string) | undefined, relative_to?: (unknown | string) | undefined};

export type PageControlActionUserHasRole = {type: 'user-has-role', roles: Array<string>};

export type Substitute = {contains: string, replace: string};

export type Substitutes = Array<Substitute>;

export type PageControlActionSubstitute = {type: 'substitute', substitutes: Substitutes};

export type PageControlActionUseServerlessFunction = {type?: 'use-serverless-function' | undefined, function: HandlerHref};

export type PageControlAction = 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 type PageControlConfiguration = {name: string, description?: string | undefined, mode?: ('maintenance' | 'request' | 'response') | undefined, enabled?: boolean | undefined, conditions?: PageControlConditions | undefined, actions: Array<PageControlAction>};

export type FirewallHref = string;

export type SecurityGroupHref = string;

export type ConditionAddressInSet = {type: 'address_in_set', address_set: AddressSetHref};

export type ConditionAddressIsNotThreat = {type: 'address_is_not_threat'};

export type ConditionAddressIsNotWhitelisted = {type: 'address_is_not_whitelisted'};

export type ConditionAddressIsThreat = {type: 'address_is_threat'};

export type ConditionAddressIsWhitelisted = {type: 'address_is_whitelisted'};

export type ConditionAddressNotInSet = {type: 'address_not_in_set', address_set?: AddressSetHref | undefined};

export type ConditionAuthCookieIsNotSet = {name: string, type: 'auth_cookie_is_not_set'};

export type ConditionAuthCookieIsSet = {name: string, type: 'auth_cookie_is_set'};

export type ConditionCookieIsNotSet = {case_sensitive?: boolean | undefined, name: string, type: 'cookie_is_not_set'};

export type ConditionCookieIsSet = {case_sensitive?: boolean | undefined, name: string, type: 'cookie_is_set'};

export type ConditionCookieValueDoesNotMatch = {case_sensitive?: boolean | undefined, name: string, pattern: unknown, type: 'cookie_value_does_not_match'};

export type ConditionCookieValueMatches = {case_sensitive?: boolean | undefined, name: string, pattern: unknown, type: 'cookie_value_matches'};

export type ConditionCountryIs = {list: CountryCodes, type: 'country_is'};

export type ConditionCountryIsNot = {list: CountryCodes, type: 'country_is_not'};

export type ConditionRandom = {probability: number, type: 'random'};

export type ReferrerPatterns = Array<string>;

export type ConditionReferrerDoesNotMatch = {case_sensitive?: boolean | undefined, list: ReferrerPatterns, type: 'referrer_is_not'};

export type ConditionReferrerIsDefined = {type: 'referrer_is_defined'};

export type ConditionReferrerIsNotDefined = {type: 'referrer_is_not_defined'};

export type ConditionReferrerMatches = {case_sensitive?: boolean | undefined, list: ReferrerPatterns, type: 'referrer_is'};

export type ConditionUrlDoesNotMatch = {case_sensitive?: boolean | undefined, list: ConditionUrls, type: 'url_is_not'};

export type ConditionUrlMatches = {case_sensitive?: boolean | undefined, list: ConditionUrls, type: 'urls'};

export type ConditionUserAgentDoesNotMatch = {case_sensitive?: boolean | undefined, pattern: string, type: 'user_agent_does_not_match'};

export type ConditionUserAgentMatches = {case_sensitive?: boolean | undefined, pattern: string, type: 'user_agent_matches'};

export type ConditionHeaderValueMatches = {case_sensitive?: boolean | undefined, name: string, pattern: unknown, type: 'header_value_matches'};

export type ConditionHeaderValueDoesNotMatch = {case_sensitive?: boolean | undefined, name: string, pattern: unknown, type: 'header_value_does_not_match'};

export type ConditionHeadersMatch = {case_sensitive?: boolean | undefined, list: ConditionHeaders, type: 'headers_match' | 'response_headers_match'};

export type ConditionHeadersNotMatch = {case_sensitive?: boolean | undefined, list: ConditionHeaders, type: 'headers_not_match' | 'response_headers_not_match'};

export type ConditionMethodIs = {values: MethodNames, type: 'method_is'};

export type ConditionMethodIsNot = {values: MethodNames, type: 'method_is_not'};

export type ConditionIsCrawler = {type: 'is_crawler'};

export type SiteCacheCondition = 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 type CacheKeyConfiguration = {browser?: boolean | undefined, cookie?: string | undefined, hostname?: boolean | undefined, query?: boolean | undefined};

export type CacheTagConfiguration = {from: 'header', name: string};

export type SiteCacheRule = {conditions: Array<SiteCacheCondition>, enabled: boolean, ttl_sec: number, key?: (unknown | CacheKeyConfiguration) | undefined, tags?: CacheTagConfiguration | undefined};

export type SiteCache = {enabled: boolean, rules: Array<SiteCacheRule>};

export type TranslatePath = 'preserve' | 'unescape';

export type ConditionRateLimit = {duration: number, display_unit: DurationDisplayUnit, threshold: number, type?: 'rate_limit' | undefined};

export type ConditionStatusCodeMatches = {pattern: unknown, type: 'status_code_matches'};

export type WebControlCondition = 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 type WebControlConfiguration = {name: string, description?: string | undefined, mode?: ('maintenance' | 'request' | 'response') | undefined, enabled?: boolean | undefined, conditions?: Array<WebControlCondition> | undefined, actions: Array<PageControlAction>};

export type ApplicationLogRetention = {type: 'default' | 'cdn' | 'custom' | 'csp-reports' | 'pageviews' | 'proxy-logs', online_days?: number | undefined, archive_days?: number | undefined, online_space_allowance?: number | undefined, archive_space_allowance?: number | undefined};

export type ApplicationPost = {endpoint?: string | undefined, subscriptions?: (Array<SubscriptionReadWrite | string>) | undefined, name: string, aliases: Array<string>, bot_management?: BotManagement | undefined, cdn_aliases?: Array<string> | undefined, components?: Array<Component> | undefined, cdn_configuration?: CdnConfiguration | undefined, cdn_ready?: boolean | undefined, cdn_service?: string | undefined, default_hostname?: Alias | undefined, dns_service?: (string | null) | undefined, servers_hostname?: (unknown | ServersHostname) | undefined, delivery?: ('cdn' | 'rewrite-to-cdn' | 'without-cdn') | undefined, enable_cdn?: boolean | undefined, enable_http2?: boolean | undefined, enable_rum?: boolean | undefined, enable_tls?: boolean | undefined, tls_configuration?: TlsConfiguration | undefined, metrics?: Array<MetricConfiguration> | undefined, monitoring?: Monitoring | undefined, waf_rules?: Array<WafFileReference> | undefined, whitelist?: Array<AddressSetEntry> | undefined, whitelist_href?: AddressSetHref | undefined, blacklist?: Array<AddressSetEntry> | undefined, blacklist_href?: AddressSetHref | undefined, blacklist_user_agents?: (string | null) | undefined, concurrent_limit?: ConcurrentLimit | undefined, maximum_queue_time?: MaximumQueueTime | undefined, merge_slashes?: MergeSlashes | undefined, suspend_limit?: SuspendLimit | undefined, probes?: Array<string> | undefined, protection?: ('normal' | 'maximum') | undefined, protection_captcha_retry_limit?: number | undefined, protection_blacklist_timeout?: number | undefined, protection_microsite_file?: string | undefined, cluster?: ClusterHref | undefined, servers?: (unknown | Array<ApplicationServer>) | undefined, page_controls?: Array<PageControlConfiguration> | undefined, request_timeout?: number | undefined, shields?: (Array<FirewallHref | SecurityGroupHref>) | undefined, shields_include_whitelist?: boolean | undefined, site_cache?: (unknown | SiteCache) | undefined, trusted_proxies?: (unknown | Array<AddressSetHref>) | undefined, data_planes?: Array<string> | undefined, trusted_proxies_only?: boolean | undefined, trusted_proxies_header?: string | undefined, labels?: Array<Label> | undefined, translate_path?: TranslatePath | undefined, pagespeed_disallow?: Array<string> | undefined, pagespeed_exclude_agents?: string | undefined, pagespeed_map_proxy_domains?: Array<string> | undefined, microsite?: FileHref | undefined, web_controls?: Array<WebControlConfiguration> | undefined, stratus_id?: (unknown | string) | undefined, log_retention?: Array<ApplicationLogRetention> | undefined};

export type CreateApiApplicationsArgs = {body: ApplicationPost};

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

export const planReadWrite = z.object({href: z.string().min(1).max(50)});

export const subscriptionReadWrite = z.object({plan: planReadWrite});

export const challenge = z.object({alias: z.string(), verified: z.boolean(), url: z.string().optional(), content: z.string().optional()});

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 application = z.object({href: z.string(), id: z.string(), endpoint: z.string().optional(), subscriptions: z.array(z.union([subscriptionReadWrite, z.string().min(1)])).optional(), cdn_state: z.string().optional(), challenges: z.array(challenge).optional(), created: timestamp, current_outage: z.boolean(), last_outage: timestamp.optional(), stage: z.enum(["initial", "configured"]).optional(), state: z.enum(["running", "maintenance", "entering_maintenance", "exiting_maintenance", "starting", "stopped", "stopping"]), 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()});

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
};

/**
 * Create an application
 * 
 * POST /applications
 */
export const createApiApplications = async (args: CreateApiApplicationsArgs, options?: CreateApiApplicationsOptions) => {
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(/\/+$/, '')}/applications${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(application, await res.json())
};