import {z} from 'zod'

export type GetApiApplicationsAppIdPagecontrolsArgs = {app_id: string, filter?: string | undefined, attributes?: string | undefined};

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

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 addressSetHref = z.string();

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 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 serversHostname = z.string();

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 handlerHref = z.string();

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 timestamp = z.string();

export const pageControl: z.ZodType<PageControl> = 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), href: z.string().optional(), version: z.number().int().optional(), created: timestamp.optional(), deleted: timestamp.optional(), history: z.array(z.lazy(() => pageControl)).optional()});

export const getApiApplicationsAppIdPagecontrolsResponse = z.array(pageControl);

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

/**
 * Page controls for an application
 * 
 * GET /applications/{app_id}/pagecontrols
 */
export const getApiApplicationsAppIdPagecontrols = async (args: GetApiApplicationsAppIdPagecontrolsArgs, options?: GetApiApplicationsAppIdPagecontrolsOptions) => {
const {baseUrl = "https://api.webscale.com/v2", fetch: fetchFn = fetch} = options ?? {}

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

if (args.filter != null) query.append("filter", String(args.filter))
if (args.attributes != null) query.append("attributes", String(args.attributes))

const url = `${baseUrl.replace(/\/+$/, '')}/applications/${encodeURIComponent(String(args.app_id))}/pagecontrols${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

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

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