@distilled.cloud/cloudflare 0.22.3 → 0.22.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/cloudflare",
-  "version": "0.22.3",
+  "version": "0.22.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -63,7 +63,7 @@
     "specs:update": "git -C specs/cloudflare-typescript fetch && git -C specs/cloudflare-typescript checkout main && git -C specs/cloudflare-typescript pull"
   },
   "dependencies": {
-    "@distilled.cloud/core": "0.22.3"
+    "@distilled.cloud/core": "0.22.4"
   },
   "devDependencies": {
     "@effect/platform-node": ">=4.0.0-beta.66 || >=4.0.0",

package/src/services/abuse-reports.ts

@@ -465,33 +465,42 @@ export interface CreateAbuseReportRequest {
   /** Path param: Cloudflare Account ID */
   accountId: string;
   /** Body param: The report type for submitted reports. */
-  act: "abuse_dmca";
+  act:
+    | "abuse_dmca"
+    | "abuse_trademark"
+    | "abuse_general"
+    | "abuse_phishing"
+    | "abuse_children"
+    | "abuse_threat"
+    | "abuse_registrar_whois"
+    | "abuse_ncsei"
+    | (string & {});
   /** Body param: Text not exceeding 100 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  address1: string;
+  address1?: string;
   /** Body param: The name of the copyright holder. Text not exceeding 60 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  agentName: string;
+  agentName?: string;
   /** Body param: Can be `0` for false or `1` for true. Must be value: 1 for DMCA reports */
-  agree: "1";
+  agree?: "1";
   /** Body param: Text not exceeding 255 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  city: string;
+  city?: string;
   /** Body param: Text not exceeding 255 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  country: string;
+  country?: string;
   /** Body param: A valid email of the abuse reporter. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
   email: string;
   /** Body param: Should match the value provided in `email` */
   email2: string;
   /** Body param: Notification type based on the abuse type. NOTE: Copyright (DMCA) and Trademark reports cannot be anonymous. */
-  hostNotification: "send";
+  hostNotification?: "send" | "send-anon" | (string & {});
   /** Body param: Text not exceeding 255 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
   name: string;
   /** Body param: Text not exceeding 255 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  originalWork: string;
+  originalWork?: string;
   /** Body param: Notification type based on the abuse type. NOTE: Copyright (DMCA) and Trademark reports cannot be anonymous. */
-  ownerNotification: "send";
+  ownerNotification: "send" | "send-anon" | "none" | (string & {});
   /** Body param: Required for DMCA reports, should be same as Name. An affirmation that all information in the report is true and accurate while agreeing to the policies of Cloudflare's abuse reports */
-  signature: string;
+  signature?: string;
   /** Body param: Text not exceeding 255 characters. This field may be released by Cloudflare to third parties such as the Lumen Database (https://lumendatabase.org/). */
-  state: string;
+  state?: string;
   /** Body param: A list of valid URLs separated by ‘\n’ (new line character). The list of the URLs should not exceed 250 URLs. All URLs should have the same hostname. Each URL should be unique. This field  */
   urls: string;
   /** Body param: Any additional comments about the infringement not exceeding 2000 characters */
@@ -506,26 +515,94 @@ export interface CreateAbuseReportRequest {
   tele?: string;
   /** Body param: Text not exceeding 255 characters */
   title?: string;
+  /** Body param: A detailed description of the infringement, including any necessary access details and the exact steps needed to view the content, not exceeding 5000 characters. */
+  justification?: string;
+  /** Body param: Text not exceeding 1000 characters */
+  trademarkNumber?: string;
+  /** Body param: Text not exceeding 1000 characters */
+  trademarkOffice?: string;
+  /** Body param: Text not exceeding 1000 characters */
+  trademarkSymbol?: string;
+  /** Body param: A list of IP addresses separated by ‘\n’ (new line character). The list of destination IPs should not exceed 30 IP addresses. Each one of the IP addresses ought to be unique. */
+  destinationIps?: string;
+  /** Body param: A comma separated list of ports and protocols e.g. 80/TCP, 22/UDP. The total size of the field should not exceed 2000 characters. Each individual port/protocol should not exceed 100 charac */
+  portsProtocols?: string;
+  /** Body param: A list of IP addresses separated by ‘\n’ (new line character). The list of source IPs should not exceed 30 IP addresses. Each one of the IP addresses ought to be unique. */
+  sourceIps?: string;
+  /** Body param: Notification type based on the abuse type. NOTE: Copyright (DMCA) and Trademark reports cannot be anonymous. */
+  ncmecNotification?: "send" | "send-anon" | (string & {});
+  /** Body param: RDP-mandated fields for registrar WHOIS data disclosure requests. */
+  regWhoRequest?: {
+    regWhoGoodFaithAffirmation: boolean;
+    regWhoLawfulProcessingAgreement: boolean;
+    regWhoLegalBasis: string;
+    regWhoRequestType: "disclosure" | "invalid_whois" | (string & {});
+    regWhoRequestedDataElements: (
+      | "registrant_name"
+      | "registrant_organization"
+      | "registrant_email"
+      | "registrant_phone"
+      | "registrant_address"
+      | "registrant_address_country"
+      | "registrant_address_postal_code"
+      | "admin_name"
+      | "admin_organization"
+      | "admin_email"
+      | "admin_phone"
+      | "admin_address"
+      | "tech_name"
+      | "tech_organization"
+      | "tech_email"
+      | "tech_phone"
+      | "tech_address"
+      | (string & {})
+    )[];
+    regWhoAuthorizationStatement?: string;
+    regWhoRequestorType?:
+      | "government"
+      | "corporation"
+      | "individual"
+      | (string & {});
+  };
+  /** Body param: If the submitter is the target of NCSEI in the URLs of the abuse report. */
+  ncseiSubjectRepresentation?: boolean;
 }
 
 export const CreateAbuseReportRequest =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     reportParam: Schema.String.pipe(T.HttpPath("reportParam")),
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    act: Schema.Literal("abuse_dmca"),
-    address1: Schema.String,
-    agentName: Schema.String,
-    agree: Schema.Literal("1"),
-    city: Schema.String,
-    country: Schema.String,
+    act: Schema.Union([
+      Schema.Literals([
+        "abuse_dmca",
+        "abuse_trademark",
+        "abuse_general",
+        "abuse_phishing",
+        "abuse_children",
+        "abuse_threat",
+        "abuse_registrar_whois",
+        "abuse_ncsei",
+      ]),
+      Schema.String,
+    ]),
+    address1: Schema.optional(Schema.String),
+    agentName: Schema.optional(Schema.String),
+    agree: Schema.optional(Schema.Literal("1")),
+    city: Schema.optional(Schema.String),
+    country: Schema.optional(Schema.String),
     email: Schema.String,
     email2: Schema.String,
-    hostNotification: Schema.Literal("send"),
+    hostNotification: Schema.optional(
+      Schema.Union([Schema.Literals(["send", "send-anon"]), Schema.String]),
+    ),
     name: Schema.String,
-    originalWork: Schema.String,
-    ownerNotification: Schema.Literal("send"),
-    signature: Schema.String,
-    state: Schema.String,
+    originalWork: Schema.optional(Schema.String),
+    ownerNotification: Schema.Union([
+      Schema.Literals(["send", "send-anon", "none"]),
+      Schema.String,
+    ]),
+    signature: Schema.optional(Schema.String),
+    state: Schema.optional(Schema.String),
     urls: Schema.String,
     comments: Schema.optional(Schema.String),
     company: Schema.optional(Schema.String),
@@ -533,6 +610,70 @@ export const CreateAbuseReportRequest =
     reportedUserAgent: Schema.optional(Schema.String),
     tele: Schema.optional(Schema.String),
     title: Schema.optional(Schema.String),
+    justification: Schema.optional(Schema.String),
+    trademarkNumber: Schema.optional(Schema.String),
+    trademarkOffice: Schema.optional(Schema.String),
+    trademarkSymbol: Schema.optional(Schema.String),
+    destinationIps: Schema.optional(Schema.String),
+    portsProtocols: Schema.optional(Schema.String),
+    sourceIps: Schema.optional(Schema.String),
+    ncmecNotification: Schema.optional(
+      Schema.Union([Schema.Literals(["send", "send-anon"]), Schema.String]),
+    ),
+    regWhoRequest: Schema.optional(
+      Schema.Struct({
+        regWhoGoodFaithAffirmation: Schema.Boolean,
+        regWhoLawfulProcessingAgreement: Schema.Boolean,
+        regWhoLegalBasis: Schema.String,
+        regWhoRequestType: Schema.Union([
+          Schema.Literals(["disclosure", "invalid_whois"]),
+          Schema.String,
+        ]),
+        regWhoRequestedDataElements: Schema.Array(
+          Schema.Union([
+            Schema.Literals([
+              "registrant_name",
+              "registrant_organization",
+              "registrant_email",
+              "registrant_phone",
+              "registrant_address",
+              "registrant_address_country",
+              "registrant_address_postal_code",
+              "admin_name",
+              "admin_organization",
+              "admin_email",
+              "admin_phone",
+              "admin_address",
+              "tech_name",
+              "tech_organization",
+              "tech_email",
+              "tech_phone",
+              "tech_address",
+            ]),
+            Schema.String,
+          ]),
+        ),
+        regWhoAuthorizationStatement: Schema.optional(Schema.String),
+        regWhoRequestorType: Schema.optional(
+          Schema.Union([
+            Schema.Literals(["government", "corporation", "individual"]),
+            Schema.String,
+          ]),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          regWhoGoodFaithAffirmation: "reg_who_good_faith_affirmation",
+          regWhoLawfulProcessingAgreement:
+            "reg_who_lawful_processing_agreement",
+          regWhoLegalBasis: "reg_who_legal_basis",
+          regWhoRequestType: "reg_who_request_type",
+          regWhoRequestedDataElements: "reg_who_requested_data_elements",
+          regWhoAuthorizationStatement: "reg_who_authorization_statement",
+          regWhoRequestorType: "reg_who_requestor_type",
+        }),
+      ),
+    ),
+    ncseiSubjectRepresentation: Schema.optional(Schema.Boolean),
   }).pipe(
     Schema.encodeKeys({
       act: "act",
@@ -556,6 +697,16 @@ export const CreateAbuseReportRequest =
       reportedUserAgent: "reported_user_agent",
       tele: "tele",
       title: "title",
+      justification: "justification",
+      trademarkNumber: "trademark_number",
+      trademarkOffice: "trademark_office",
+      trademarkSymbol: "trademark_symbol",
+      destinationIps: "destination_ips",
+      portsProtocols: "ports_protocols",
+      sourceIps: "source_ips",
+      ncmecNotification: "ncmec_notification",
+      regWhoRequest: "reg_who_request",
+      ncseiSubjectRepresentation: "ncsei_subject_representation",
     }),
     T.Http({
       method: "POST",

package/src/services/accounts.ts

@@ -1925,18 +1925,50 @@ export interface CreateMemberRequest {
   /** Body param: The contact email address of the user. */
   email: string;
   /** Body param: Array of roles associated with this member. */
-  roles: string[];
+  roles?: string[];
   /** Body param: Status of the member invitation. If not provided during creation, defaults to 'pending'. Changing from 'accepted' back to 'pending' will trigger a replacement of the member resource in Ter */
   status?: "accepted" | "pending" | (string & {});
+  /** Body param: Array of policies associated with this member. */
+  policies?: {
+    access: "allow" | "deny" | (string & {});
+    permissionGroups: { id: string }[];
+    resourceGroups: { id: string }[];
+  }[];
 }
 
 export const CreateMemberRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
   email: Schema.String,
-  roles: Schema.Array(Schema.String),
+  roles: Schema.optional(Schema.Array(Schema.String)),
   status: Schema.optional(
     Schema.Union([Schema.Literals(["accepted", "pending"]), Schema.String]),
   ),
+  policies: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        access: Schema.Union([
+          Schema.Literals(["allow", "deny"]),
+          Schema.String,
+        ]),
+        permissionGroups: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+          }),
+        ),
+        resourceGroups: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+          }),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          access: "access",
+          permissionGroups: "permission_groups",
+          resourceGroups: "resource_groups",
+        }),
+      ),
+    ),
+  ),
 }).pipe(
   T.Http({ method: "POST", path: "/accounts/{account_id}/members" }),
 ) as unknown as Schema.Schema<CreateMemberRequest>;
@@ -2277,6 +2309,12 @@ export interface UpdateMemberRequest {
   accountId: string;
   /** Body param: Roles assigned to this member. */
   roles?: { id: string }[];
+  /** Body param: Array of policies associated with this member. */
+  policies?: {
+    access: "allow" | "deny" | (string & {});
+    permissionGroups: { id: string }[];
+    resourceGroups: { id: string }[];
+  }[];
 }
 
 export const UpdateMemberRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
@@ -2289,6 +2327,32 @@ export const UpdateMemberRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ),
+  policies: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        access: Schema.Union([
+          Schema.Literals(["allow", "deny"]),
+          Schema.String,
+        ]),
+        permissionGroups: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+          }),
+        ),
+        resourceGroups: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+          }),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          access: "access",
+          permissionGroups: "permission_groups",
+          resourceGroups: "resource_groups",
+        }),
+      ),
+    ),
+  ),
 }).pipe(
   T.Http({ method: "PUT", path: "/accounts/{account_id}/members/{memberId}" }),
 ) as unknown as Schema.Schema<UpdateMemberRequest>;

package/src/services/ai.ts

@@ -50,14 +50,247 @@ export interface RunAiRequest {
   /** Path param */
   accountId: string;
   /** Body param: The text that you want to classify */
-  text: string;
+  text?: string | string[];
+  /** Body param: A text description of the image you want to generate */
+  prompt?: string;
+  /** Body param: Controls how closely the generated image should adhere to the prompt; higher values make the image more aligned with the prompt */
+  guidance?: number;
+  /** Body param: The height of the generated image in pixels */
+  height?: number;
+  /** Body param: For use with img2img tasks. An array of integers that represent the image data constrained to 8-bit unsigned integer values */
+  image?: number[] | string;
+  /** Body param: For use with img2img tasks. A base64-encoded string of the input image */
+  imageB64?: string;
+  /** Body param: An array representing An array of integers that represent mask image data for inpainting constrained to 8-bit unsigned integer values */
+  mask?: number[];
+  /** Body param: Text describing elements to avoid in the generated image */
+  negativePrompt?: string;
+  /** Body param: The number of diffusion steps; higher values can improve quality but take longer */
+  numSteps?: number;
+  /** Body param: Random seed for reproducibility of the image generation */
+  seed?: number;
+  /** Body param: A value between 0 and 1 indicating how strongly to apply the transformation during img2img tasks; lower values make the output closer to the input image */
+  strength?: number;
+  /** Body param: The width of the generated image in pixels */
+  width?: number;
+  /** Body param: The speech language (e.g., 'en' for English, 'fr' for French). Defaults to 'en' if not specified */
+  lang?: string;
+  /** Body param: An array of integers that represent the audio data constrained to 8-bit unsigned integer values */
+  audio?: number[];
+  /** Body param: The language of the recorded audio */
+  sourceLang?: string;
+  /** Body param: The language to translate the transcription into. Currently only English is supported. */
+  targetLang?: string;
+  /** Body param: Decreases the likelihood of the model repeating the same lines verbatim. */
+  frequencyPenalty?: number;
+  /** Body param: Name of the LoRA (Low-Rank Adaptation) model to fine-tune the base model. */
+  lora?: string;
+  /** Body param: The maximum number of tokens to generate in the response. */
+  maxTokens?: number;
+  /** Body param: Increases the likelihood of the model introducing new topics. */
+  presencePenalty?: number;
+  /** Body param: If true, a chat template is not applied and you must adhere to the specific model's expected formatting. */
+  raw?: boolean;
+  /** Body param: Penalty for repeated tokens; higher values discourage repetition. */
+  repetitionPenalty?: number;
+  /** Body param */
+  responseFormat?: {
+    jsonSchema?: unknown;
+    type?: "json_object" | "json_schema" | (string & {});
+  };
+  /** Body param: If true, the response will be streamed back incrementally using SSE, Server Sent Events. */
+  stream?: boolean;
+  /** Body param: Controls the randomness of the output; higher values produce more random results. */
+  temperature?: number;
+  /** Body param: Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. */
+  topK?: number;
+  /** Body param: Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creati */
+  topP?: number;
+  /** Body param: An array of message objects representing the conversation history. */
+  messages?:
+    | { content: string | { text?: string; type?: string }[]; role: string }[]
+    | {
+        content:
+          | string
+          | { type: string; imageUrl?: { url: string }; text?: string }[];
+        role: string;
+      }[];
+  /** Body param */
+  functions?: { code: string; name: string }[];
+  /** Body param: A list of tools available for the assistant to use. */
+  tools?: (
+    | {
+        description: string;
+        name: string;
+        parameters: {
+          properties: Record<string, unknown>;
+          type: string;
+          required?: string[];
+        };
+      }
+    | { code: string; name: string }
+  )[];
+  /** Body param: The text that you want the model to summarize */
+  inputText?: string;
+  /** Body param: The maximum length of the generated summary in tokens */
+  maxLength?: number;
+  /** Body param: Whether to ignore the EOS token and continue generating tokens after the EOS token is generated. */
+  ignoreEos?: boolean;
 }
 
 export const RunAiRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   modelName: Schema.String.pipe(T.HttpPath("modelName")),
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
-  text: Schema.String,
+  text: Schema.optional(
+    Schema.Union([Schema.String, Schema.Array(Schema.String)]),
+  ),
+  prompt: Schema.optional(Schema.String),
+  guidance: Schema.optional(Schema.Number),
+  height: Schema.optional(Schema.Number),
+  image: Schema.optional(
+    Schema.Union([Schema.Array(Schema.Number), Schema.String]),
+  ),
+  imageB64: Schema.optional(Schema.String),
+  mask: Schema.optional(Schema.Array(Schema.Number)),
+  negativePrompt: Schema.optional(Schema.String),
+  numSteps: Schema.optional(Schema.Number),
+  seed: Schema.optional(Schema.Number),
+  strength: Schema.optional(Schema.Number),
+  width: Schema.optional(Schema.Number),
+  lang: Schema.optional(Schema.String),
+  audio: Schema.optional(Schema.Array(Schema.Number)),
+  sourceLang: Schema.optional(Schema.String),
+  targetLang: Schema.optional(Schema.String),
+  frequencyPenalty: Schema.optional(Schema.Number),
+  lora: Schema.optional(Schema.String),
+  maxTokens: Schema.optional(Schema.Number),
+  presencePenalty: Schema.optional(Schema.Number),
+  raw: Schema.optional(Schema.Boolean),
+  repetitionPenalty: Schema.optional(Schema.Number),
+  responseFormat: Schema.optional(
+    Schema.Struct({
+      jsonSchema: Schema.optional(Schema.Unknown),
+      type: Schema.optional(
+        Schema.Union([
+          Schema.Literals(["json_object", "json_schema"]),
+          Schema.String,
+        ]),
+      ),
+    }).pipe(Schema.encodeKeys({ jsonSchema: "json_schema", type: "type" })),
+  ),
+  stream: Schema.optional(Schema.Boolean),
+  temperature: Schema.optional(Schema.Number),
+  topK: Schema.optional(Schema.Number),
+  topP: Schema.optional(Schema.Number),
+  messages: Schema.optional(
+    Schema.Union([
+      Schema.Array(
+        Schema.Struct({
+          content: Schema.Union([
+            Schema.String,
+            Schema.Array(
+              Schema.Struct({
+                text: Schema.optional(Schema.String),
+                type: Schema.optional(Schema.String),
+              }),
+            ),
+          ]),
+          role: Schema.String,
+        }),
+      ),
+      Schema.Array(
+        Schema.Struct({
+          content: Schema.Union([
+            Schema.String,
+            Schema.Array(
+              Schema.Struct({
+                type: Schema.String,
+                imageUrl: Schema.optional(
+                  Schema.Struct({
+                    url: Schema.String,
+                  }),
+                ),
+                text: Schema.optional(Schema.String),
+              }).pipe(
+                Schema.encodeKeys({
+                  type: "type",
+                  imageUrl: "image_url",
+                  text: "text",
+                }),
+              ),
+            ),
+          ]),
+          role: Schema.String,
+        }),
+      ),
+    ]),
+  ),
+  functions: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        code: Schema.String,
+        name: Schema.String,
+      }),
+    ),
+  ),
+  tools: Schema.optional(
+    Schema.Array(
+      Schema.Union([
+        Schema.Struct({
+          description: Schema.String,
+          name: Schema.String,
+          parameters: Schema.Struct({
+            properties: Schema.Record(Schema.String, Schema.Unknown),
+            type: Schema.String,
+            required: Schema.optional(Schema.Array(Schema.String)),
+          }),
+        }),
+        Schema.Struct({
+          code: Schema.String,
+          name: Schema.String,
+        }),
+      ]),
+    ),
+  ),
+  inputText: Schema.optional(Schema.String),
+  maxLength: Schema.optional(Schema.Number),
+  ignoreEos: Schema.optional(Schema.Boolean),
 }).pipe(
+  Schema.encodeKeys({
+    text: "text",
+    prompt: "prompt",
+    guidance: "guidance",
+    height: "height",
+    image: "image",
+    imageB64: "image_b64",
+    mask: "mask",
+    negativePrompt: "negative_prompt",
+    numSteps: "num_steps",
+    seed: "seed",
+    strength: "strength",
+    width: "width",
+    lang: "lang",
+    audio: "audio",
+    sourceLang: "source_lang",
+    targetLang: "target_lang",
+    frequencyPenalty: "frequency_penalty",
+    lora: "lora",
+    maxTokens: "max_tokens",
+    presencePenalty: "presence_penalty",
+    raw: "raw",
+    repetitionPenalty: "repetition_penalty",
+    responseFormat: "response_format",
+    stream: "stream",
+    temperature: "temperature",
+    topK: "top_k",
+    topP: "top_p",
+    messages: "messages",
+    functions: "functions",
+    tools: "tools",
+    inputText: "input_text",
+    maxLength: "max_length",
+    ignoreEos: "ignore_eos",
+  }),
   T.Http({ method: "POST", path: "/accounts/{account_id}/ai/run/{modelName}" }),
 ) as unknown as Schema.Schema<RunAiRequest>;
 

package/src/services/bot-management.ts

@@ -553,6 +553,26 @@ export interface PutBotManagementRequest {
   fightMode?: boolean;
   /** Body param: Enable cloudflare managed robots.txt. If an existing robots.txt is detected, then managed robots.txt will be prepended to the existing robots.txt. */
   isRobotsTxtManaged?: boolean;
+  /** Body param: Whether to optimize Super Bot Fight Mode protections for Wordpress. */
+  optimizeWordpress?: boolean;
+  /** Body param: Super Bot Fight Mode (SBFM) action to take on definitely automated requests. */
+  sbfmDefinitelyAutomated?:
+    | "allow"
+    | "block"
+    | "managed_challenge"
+    | (string & {});
+  /** Body param: Super Bot Fight Mode (SBFM) to enable static resource protection. Enable if static resources on your application need bot protection. Note: Static resource protection can also result in le */
+  sbfmStaticResourceProtection?: boolean;
+  /** Body param: Super Bot Fight Mode (SBFM) action to take on verified bots requests. */
+  sbfmVerifiedBots?: "allow" | "block" | (string & {});
+  /** Body param: Super Bot Fight Mode (SBFM) action to take on likely automated requests. */
+  sbfmLikelyAutomated?: "allow" | "block" | "managed_challenge" | (string & {});
+  /** Body param: Automatically update to the newest bot detection models created by Cloudflare as they are released. [Learn more.](https://developers.cloudflare.com/bots/reference/machine-learning-models#m */
+  autoUpdateModel?: boolean;
+  /** Body param: Indicates that the bot management cookie can be placed on end user devices accessing the site. Defaults to true */
+  bmCookieEnabled?: boolean;
+  /** Body param: Whether to disable tracking the highest bot score for a session in the Bot Management cookie. */
+  suppressSessionScore?: boolean;
 }
 
 export const PutBotManagementRequest =
@@ -576,6 +596,26 @@ export const PutBotManagementRequest =
     enableJs: Schema.optional(Schema.Boolean),
     fightMode: Schema.optional(Schema.Boolean),
     isRobotsTxtManaged: Schema.optional(Schema.Boolean),
+    optimizeWordpress: Schema.optional(Schema.Boolean),
+    sbfmDefinitelyAutomated: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["allow", "block", "managed_challenge"]),
+        Schema.String,
+      ]),
+    ),
+    sbfmStaticResourceProtection: Schema.optional(Schema.Boolean),
+    sbfmVerifiedBots: Schema.optional(
+      Schema.Union([Schema.Literals(["allow", "block"]), Schema.String]),
+    ),
+    sbfmLikelyAutomated: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["allow", "block", "managed_challenge"]),
+        Schema.String,
+      ]),
+    ),
+    autoUpdateModel: Schema.optional(Schema.Boolean),
+    bmCookieEnabled: Schema.optional(Schema.Boolean),
+    suppressSessionScore: Schema.optional(Schema.Boolean),
   }).pipe(
     Schema.encodeKeys({
       aiBotsProtection: "ai_bots_protection",
@@ -585,6 +625,14 @@ export const PutBotManagementRequest =
       enableJs: "enable_js",
       fightMode: "fight_mode",
       isRobotsTxtManaged: "is_robots_txt_managed",
+      optimizeWordpress: "optimize_wordpress",
+      sbfmDefinitelyAutomated: "sbfm_definitely_automated",
+      sbfmStaticResourceProtection: "sbfm_static_resource_protection",
+      sbfmVerifiedBots: "sbfm_verified_bots",
+      sbfmLikelyAutomated: "sbfm_likely_automated",
+      autoUpdateModel: "auto_update_model",
+      bmCookieEnabled: "bm_cookie_enabled",
+      suppressSessionScore: "suppress_session_score",
     }),
     T.Http({ method: "PUT", path: "/zones/{zone_id}/bot_management" }),
   ) as unknown as Schema.Schema<PutBotManagementRequest>;