cloudflare 6.3.0 → 6.4.0

package/resources/flagship/apps/evaluate.d.ts

@@ -0,0 +1,38 @@
+import { APIResource } from "../../../resource.js";
+import * as Core from "../../../core.js";
+export declare class Evaluate extends APIResource {
+    /**
+     * Evaluates a flag against the provided context. Pass context attributes as query
+     * parameters; boolean and numeric strings are coerced automatically. For
+     * low-latency in-Worker evaluation, prefer the Flagship binding over this
+     * endpoint.
+     */
+    get(appId: string, params: EvaluateGetParams, options?: Core.RequestOptions): Core.APIPromise<EvaluateGetResponse>;
+}
+export interface EvaluateGetResponse {
+    flagKey: string;
+    reason: 'TARGETING_MATCH' | 'DEFAULT' | 'DISABLED' | 'SPLIT';
+    variant: string;
+    value?: string | null | number | boolean | {
+        [key: string]: unknown;
+    } | Array<unknown>;
+}
+export interface EvaluateGetParams {
+    /**
+     * Path param: Cloudflare account ID.
+     */
+    account_id: string;
+    /**
+     * Query param: The flag key to evaluate.
+     */
+    flagKey: string;
+    /**
+     * Query param: Context targeting key (per OpenFeature spec); used for percentage
+     * rollout bucketing.
+     */
+    targetingKey?: string;
+}
+export declare namespace Evaluate {
+    export { type EvaluateGetResponse as EvaluateGetResponse, type EvaluateGetParams as EvaluateGetParams };
+}
+//# sourceMappingURL=evaluate.d.ts.map

package/resources/flagship/apps/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../../src/resources/flagship/apps/evaluate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,IAAI,MAAM,eAAe,CAAC;AAEtC,qBAAa,QAAS,SAAQ,WAAW;IACvC;;;;;OAKG;IACH,GAAG,CACD,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,cAAc,GAC5B,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC;CAIxC;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAEhB,MAAM,EAAE,iBAAiB,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IAE7D,OAAO,EAAE,MAAM,CAAC;IAEhB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;CACxF;AAED,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,CAAC,OAAO,WAAW,QAAQ,CAAC;IAChC,OAAO,EAAE,KAAK,mBAAmB,IAAI,mBAAmB,EAAE,KAAK,iBAAiB,IAAI,iBAAiB,EAAE,CAAC;CACzG"}

package/resources/flagship/apps/evaluate.js

@@ -0,0 +1,19 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluate = void 0;
+const resource_1 = require("../../../resource.js");
+class Evaluate extends resource_1.APIResource {
+    /**
+     * Evaluates a flag against the provided context. Pass context attributes as query
+     * parameters; boolean and numeric strings are coerced automatically. For
+     * low-latency in-Worker evaluation, prefer the Flagship binding over this
+     * endpoint.
+     */
+    get(appId, params, options) {
+        const { account_id, ...query } = params;
+        return this._client.get(`/accounts/${account_id}/flagship/apps/${appId}/evaluate`, { query, ...options });
+    }
+}
+exports.Evaluate = Evaluate;
+//# sourceMappingURL=evaluate.js.map

package/resources/flagship/apps/evaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.js","sourceRoot":"","sources":["../../../src/resources/flagship/apps/evaluate.ts"],"names":[],"mappings":";AAAA,sFAAsF;;;AAEtF,mDAAgD;AAGhD,MAAa,QAAS,SAAQ,sBAAW;IACvC;;;;;OAKG;IACH,GAAG,CACD,KAAa,EACb,MAAyB,EACzB,OAA6B;QAE7B,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,UAAU,kBAAkB,KAAK,WAAW,EAAE,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC5G,CAAC;CACF;AAfD,4BAeC"}

package/resources/flagship/apps/evaluate.mjs

@@ -0,0 +1,15 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { APIResource } from "../../../resource.mjs";
+export class Evaluate extends APIResource {
+    /**
+     * Evaluates a flag against the provided context. Pass context attributes as query
+     * parameters; boolean and numeric strings are coerced automatically. For
+     * low-latency in-Worker evaluation, prefer the Flagship binding over this
+     * endpoint.
+     */
+    get(appId, params, options) {
+        const { account_id, ...query } = params;
+        return this._client.get(`/accounts/${account_id}/flagship/apps/${appId}/evaluate`, { query, ...options });
+    }
+}
+//# sourceMappingURL=evaluate.mjs.map

package/resources/flagship/apps/evaluate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.mjs","sourceRoot":"","sources":["../../../src/resources/flagship/apps/evaluate.ts"],"names":[],"mappings":"AAAA,sFAAsF;OAE/E,EAAE,WAAW,EAAE;AAGtB,MAAM,OAAO,QAAS,SAAQ,WAAW;IACvC;;;;;OAKG;IACH,GAAG,CACD,KAAa,EACb,MAAyB,EACzB,OAA6B;QAE7B,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,UAAU,kBAAkB,KAAK,WAAW,EAAE,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC5G,CAAC;CACF"}

package/resources/flagship/apps/flags/changelog.d.ts

@@ -0,0 +1,566 @@
+import { APIResource } from "../../../../resource.js";
+import * as Core from "../../../../core.js";
+import { CursorPaginationAfter, type CursorPaginationAfterParams } from "../../../../pagination.js";
+export declare class Changelog extends APIResource {
+    /**
+     * Returns the audit history for a flag, newest first. Each entry includes the
+     * event type and full flag state after the change; `update` entries include a
+     * field-level diff. Capped at 200 entries per flag.
+     */
+    list(appId: string, flagKey: string, params: ChangelogListParams, options?: Core.RequestOptions): Core.PagePromise<ChangelogListResponsesCursorPaginationAfter, ChangelogListResponse>;
+}
+export declare class ChangelogListResponsesCursorPaginationAfter extends CursorPaginationAfter<ChangelogListResponse> {
+}
+export type ChangelogListResponse = ChangelogListResponse.UnionMember0 | ChangelogListResponse.UnionMember1 | ChangelogListResponse.UnionMember2;
+export declare namespace ChangelogListResponse {
+    interface UnionMember0 {
+        after: UnionMember0.After;
+        event: 'create';
+        flag_key: string;
+    }
+    namespace UnionMember0 {
+        interface After {
+            /**
+             * Variation served when no rule matches or the flag is disabled. Must be a key in
+             * `variations`.
+             */
+            default_variation: string;
+            /**
+             * When false, the flag bypasses all rules and always serves `default_variation`.
+             */
+            enabled: boolean;
+            /**
+             * Unique identifier for the flag within an app. Used in all evaluation and SDK
+             * calls.
+             */
+            key: string;
+            /**
+             * Targeting rules evaluated in ascending `priority`; the first matching rule wins.
+             * An empty array means the flag always serves `default_variation`.
+             */
+            rules: Array<After.Rule>;
+            /**
+             * Map of variation name to value. All values must be the same type (boolean,
+             * string, number, or JSON object/array). Each serialized value must be 10KB or
+             * smaller.
+             */
+            variations: {
+                [key: string]: string | null | number | boolean | {
+                    [key: string]: unknown;
+                } | Array<unknown>;
+            };
+            description?: string | null;
+            /**
+             * Value type of the flag's variations. Inferred from the variation values on
+             * write, so it may be omitted in requests.
+             */
+            type?: 'boolean' | 'string' | 'number' | 'json';
+            updated_at?: string;
+            updated_by?: string;
+        }
+        namespace After {
+            interface Rule {
+                /**
+                 * Conditions the context must satisfy for this rule to match. An empty array
+                 * matches all contexts.
+                 */
+                conditions: Array<Rule.UnionMember0 | Rule.UnionMember1>;
+                /**
+                 * Evaluation order; lower numbers are evaluated first. Must be unique across the
+                 * flag's rules.
+                 */
+                priority: number;
+                /**
+                 * Variation served when this rule matches. Must be a key in `variations`.
+                 */
+                serve_variation: string;
+                rollout?: Rule.Rollout;
+            }
+            namespace Rule {
+                interface UnionMember0 {
+                    attribute: string;
+                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                    /**
+                     * Value to compare against the context attribute. Must be an array for `in` and
+                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                     * operators.
+                     */
+                    value: unknown;
+                }
+                interface UnionMember1 {
+                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                    logical_operator: 'AND' | 'OR';
+                }
+                namespace UnionMember1 {
+                    interface UnionMember0 {
+                        attribute: string;
+                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                        /**
+                         * Value to compare against the context attribute. Must be an array for `in` and
+                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                         * operators.
+                         */
+                        value: unknown;
+                    }
+                    interface UnionMember1 {
+                        clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                        logical_operator: 'AND' | 'OR';
+                    }
+                    namespace UnionMember1 {
+                        interface UnionMember0 {
+                            attribute: string;
+                            operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                            /**
+                             * Value to compare against the context attribute. Must be an array for `in` and
+                             * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                             * operators.
+                             */
+                            value: unknown;
+                        }
+                        interface UnionMember1 {
+                            clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                            logical_operator: 'AND' | 'OR';
+                        }
+                        namespace UnionMember1 {
+                            interface UnionMember0 {
+                                attribute: string;
+                                operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                /**
+                                 * Value to compare against the context attribute. Must be an array for `in` and
+                                 * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                 * operators.
+                                 */
+                                value: unknown;
+                            }
+                            interface UnionMember1 {
+                                clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                logical_operator: 'AND' | 'OR';
+                            }
+                            namespace UnionMember1 {
+                                interface UnionMember0 {
+                                    attribute: string;
+                                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                    /**
+                                     * Value to compare against the context attribute. Must be an array for `in` and
+                                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                     * operators.
+                                     */
+                                    value: unknown;
+                                }
+                                interface UnionMember1 {
+                                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                    logical_operator: 'AND' | 'OR';
+                                }
+                                namespace UnionMember1 {
+                                    interface UnionMember0 {
+                                        attribute: string;
+                                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                        /**
+                                         * Value to compare against the context attribute. Must be an array for `in` and
+                                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                         * operators.
+                                         */
+                                        value: unknown;
+                                    }
+                                    interface UnionMember1 {
+                                        clauses: Array<string | null | number | boolean | {
+                                            [key: string]: unknown;
+                                        } | Array<unknown>>;
+                                        logical_operator: 'AND' | 'OR';
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                interface Rollout {
+                    /**
+                     * Percentage of matching traffic (0–100) served this variation. For multi-way
+                     * splits, use cumulative upper bounds across rules (e.g. 30, 70, 100).
+                     */
+                    percentage: number;
+                    /**
+                     * Context attribute used for sticky bucketing. Defaults to `targetingKey`. If
+                     * absent at evaluation time, bucketing is random per request.
+                     */
+                    attribute?: string;
+                }
+            }
+        }
+    }
+    interface UnionMember1 {
+        after: UnionMember1.After;
+        event: 'delete';
+        flag_key: string;
+    }
+    namespace UnionMember1 {
+        interface After {
+            /**
+             * Variation served when no rule matches or the flag is disabled. Must be a key in
+             * `variations`.
+             */
+            default_variation: string;
+            /**
+             * When false, the flag bypasses all rules and always serves `default_variation`.
+             */
+            enabled: boolean;
+            /**
+             * Unique identifier for the flag within an app. Used in all evaluation and SDK
+             * calls.
+             */
+            key: string;
+            /**
+             * Targeting rules evaluated in ascending `priority`; the first matching rule wins.
+             * An empty array means the flag always serves `default_variation`.
+             */
+            rules: Array<After.Rule>;
+            /**
+             * Map of variation name to value. All values must be the same type (boolean,
+             * string, number, or JSON object/array). Each serialized value must be 10KB or
+             * smaller.
+             */
+            variations: {
+                [key: string]: string | null | number | boolean | {
+                    [key: string]: unknown;
+                } | Array<unknown>;
+            };
+            description?: string | null;
+            /**
+             * Value type of the flag's variations. Inferred from the variation values on
+             * write, so it may be omitted in requests.
+             */
+            type?: 'boolean' | 'string' | 'number' | 'json';
+            updated_at?: string;
+            updated_by?: string;
+        }
+        namespace After {
+            interface Rule {
+                /**
+                 * Conditions the context must satisfy for this rule to match. An empty array
+                 * matches all contexts.
+                 */
+                conditions: Array<Rule.UnionMember0 | Rule.UnionMember1>;
+                /**
+                 * Evaluation order; lower numbers are evaluated first. Must be unique across the
+                 * flag's rules.
+                 */
+                priority: number;
+                /**
+                 * Variation served when this rule matches. Must be a key in `variations`.
+                 */
+                serve_variation: string;
+                rollout?: Rule.Rollout;
+            }
+            namespace Rule {
+                interface UnionMember0 {
+                    attribute: string;
+                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                    /**
+                     * Value to compare against the context attribute. Must be an array for `in` and
+                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                     * operators.
+                     */
+                    value: unknown;
+                }
+                interface UnionMember1 {
+                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                    logical_operator: 'AND' | 'OR';
+                }
+                namespace UnionMember1 {
+                    interface UnionMember0 {
+                        attribute: string;
+                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                        /**
+                         * Value to compare against the context attribute. Must be an array for `in` and
+                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                         * operators.
+                         */
+                        value: unknown;
+                    }
+                    interface UnionMember1 {
+                        clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                        logical_operator: 'AND' | 'OR';
+                    }
+                    namespace UnionMember1 {
+                        interface UnionMember0 {
+                            attribute: string;
+                            operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                            /**
+                             * Value to compare against the context attribute. Must be an array for `in` and
+                             * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                             * operators.
+                             */
+                            value: unknown;
+                        }
+                        interface UnionMember1 {
+                            clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                            logical_operator: 'AND' | 'OR';
+                        }
+                        namespace UnionMember1 {
+                            interface UnionMember0 {
+                                attribute: string;
+                                operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                /**
+                                 * Value to compare against the context attribute. Must be an array for `in` and
+                                 * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                 * operators.
+                                 */
+                                value: unknown;
+                            }
+                            interface UnionMember1 {
+                                clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                logical_operator: 'AND' | 'OR';
+                            }
+                            namespace UnionMember1 {
+                                interface UnionMember0 {
+                                    attribute: string;
+                                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                    /**
+                                     * Value to compare against the context attribute. Must be an array for `in` and
+                                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                     * operators.
+                                     */
+                                    value: unknown;
+                                }
+                                interface UnionMember1 {
+                                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                    logical_operator: 'AND' | 'OR';
+                                }
+                                namespace UnionMember1 {
+                                    interface UnionMember0 {
+                                        attribute: string;
+                                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                        /**
+                                         * Value to compare against the context attribute. Must be an array for `in` and
+                                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                         * operators.
+                                         */
+                                        value: unknown;
+                                    }
+                                    interface UnionMember1 {
+                                        clauses: Array<string | null | number | boolean | {
+                                            [key: string]: unknown;
+                                        } | Array<unknown>>;
+                                        logical_operator: 'AND' | 'OR';
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                interface Rollout {
+                    /**
+                     * Percentage of matching traffic (0–100) served this variation. For multi-way
+                     * splits, use cumulative upper bounds across rules (e.g. 30, 70, 100).
+                     */
+                    percentage: number;
+                    /**
+                     * Context attribute used for sticky bucketing. Defaults to `targetingKey`. If
+                     * absent at evaluation time, bucketing is random per request.
+                     */
+                    attribute?: string;
+                }
+            }
+        }
+    }
+    interface UnionMember2 {
+        after: UnionMember2.After;
+        diff: {
+            [key: string]: UnionMember2.Diff;
+        };
+        event: 'update';
+        flag_key: string;
+    }
+    namespace UnionMember2 {
+        interface After {
+            /**
+             * Variation served when no rule matches or the flag is disabled. Must be a key in
+             * `variations`.
+             */
+            default_variation: string;
+            /**
+             * When false, the flag bypasses all rules and always serves `default_variation`.
+             */
+            enabled: boolean;
+            /**
+             * Unique identifier for the flag within an app. Used in all evaluation and SDK
+             * calls.
+             */
+            key: string;
+            /**
+             * Targeting rules evaluated in ascending `priority`; the first matching rule wins.
+             * An empty array means the flag always serves `default_variation`.
+             */
+            rules: Array<After.Rule>;
+            /**
+             * Map of variation name to value. All values must be the same type (boolean,
+             * string, number, or JSON object/array). Each serialized value must be 10KB or
+             * smaller.
+             */
+            variations: {
+                [key: string]: string | null | number | boolean | {
+                    [key: string]: unknown;
+                } | Array<unknown>;
+            };
+            description?: string | null;
+            /**
+             * Value type of the flag's variations. Inferred from the variation values on
+             * write, so it may be omitted in requests.
+             */
+            type?: 'boolean' | 'string' | 'number' | 'json';
+            updated_at?: string;
+            updated_by?: string;
+        }
+        namespace After {
+            interface Rule {
+                /**
+                 * Conditions the context must satisfy for this rule to match. An empty array
+                 * matches all contexts.
+                 */
+                conditions: Array<Rule.UnionMember0 | Rule.UnionMember1>;
+                /**
+                 * Evaluation order; lower numbers are evaluated first. Must be unique across the
+                 * flag's rules.
+                 */
+                priority: number;
+                /**
+                 * Variation served when this rule matches. Must be a key in `variations`.
+                 */
+                serve_variation: string;
+                rollout?: Rule.Rollout;
+            }
+            namespace Rule {
+                interface UnionMember0 {
+                    attribute: string;
+                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                    /**
+                     * Value to compare against the context attribute. Must be an array for `in` and
+                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                     * operators.
+                     */
+                    value: unknown;
+                }
+                interface UnionMember1 {
+                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                    logical_operator: 'AND' | 'OR';
+                }
+                namespace UnionMember1 {
+                    interface UnionMember0 {
+                        attribute: string;
+                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                        /**
+                         * Value to compare against the context attribute. Must be an array for `in` and
+                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                         * operators.
+                         */
+                        value: unknown;
+                    }
+                    interface UnionMember1 {
+                        clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                        logical_operator: 'AND' | 'OR';
+                    }
+                    namespace UnionMember1 {
+                        interface UnionMember0 {
+                            attribute: string;
+                            operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                            /**
+                             * Value to compare against the context attribute. Must be an array for `in` and
+                             * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                             * operators.
+                             */
+                            value: unknown;
+                        }
+                        interface UnionMember1 {
+                            clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                            logical_operator: 'AND' | 'OR';
+                        }
+                        namespace UnionMember1 {
+                            interface UnionMember0 {
+                                attribute: string;
+                                operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                /**
+                                 * Value to compare against the context attribute. Must be an array for `in` and
+                                 * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                 * operators.
+                                 */
+                                value: unknown;
+                            }
+                            interface UnionMember1 {
+                                clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                logical_operator: 'AND' | 'OR';
+                            }
+                            namespace UnionMember1 {
+                                interface UnionMember0 {
+                                    attribute: string;
+                                    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                    /**
+                                     * Value to compare against the context attribute. Must be an array for `in` and
+                                     * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                     * operators.
+                                     */
+                                    value: unknown;
+                                }
+                                interface UnionMember1 {
+                                    clauses: Array<UnionMember1.UnionMember0 | UnionMember1.UnionMember1>;
+                                    logical_operator: 'AND' | 'OR';
+                                }
+                                namespace UnionMember1 {
+                                    interface UnionMember0 {
+                                        attribute: string;
+                                        operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_than_or_equals' | 'less_than_or_equals' | 'contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in';
+                                        /**
+                                         * Value to compare against the context attribute. Must be an array for `in` and
+                                         * `not_in`; numeric and ISO-8601 datetime strings are accepted by the ordering
+                                         * operators.
+                                         */
+                                        value: unknown;
+                                    }
+                                    interface UnionMember1 {
+                                        clauses: Array<string | null | number | boolean | {
+                                            [key: string]: unknown;
+                                        } | Array<unknown>>;
+                                        logical_operator: 'AND' | 'OR';
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                interface Rollout {
+                    /**
+                     * Percentage of matching traffic (0–100) served this variation. For multi-way
+                     * splits, use cumulative upper bounds across rules (e.g. 30, 70, 100).
+                     */
+                    percentage: number;
+                    /**
+                     * Context attribute used for sticky bucketing. Defaults to `targetingKey`. If
+                     * absent at evaluation time, bucketing is random per request.
+                     */
+                    attribute?: string;
+                }
+            }
+        }
+        interface Diff {
+            from?: string | null | number | boolean | {
+                [key: string]: unknown;
+            } | Array<unknown>;
+            to?: string | null | number | boolean | {
+                [key: string]: unknown;
+            } | Array<unknown>;
+        }
+    }
+}
+export interface ChangelogListParams extends CursorPaginationAfterParams {
+    /**
+     * Path param: Cloudflare account ID.
+     */
+    account_id: string;
+    /**
+     * Query param: Max items to return (1–200).
+     */
+    limit?: string;
+}
+export declare namespace Changelog {
+    export { type ChangelogListResponse as ChangelogListResponse, ChangelogListResponsesCursorPaginationAfter as ChangelogListResponsesCursorPaginationAfter, type ChangelogListParams as ChangelogListParams, };
+}
+//# sourceMappingURL=changelog.d.ts.map