// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  createdAt: "created_at",
  defaultVariation: "default_variation",
  flagKey: "flag_key",
  logicalOperator: "logical_operator",
  resultInfo: "result_info",
  serveVariation: "serve_variation",
  updatedAt: "updated_at",
  updatedBy: "updated_by",
};

export class FlagshipAppNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<FlagshipAppNotFound>()("FlagshipAppNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 404, message: { includes: "App not found" } }],
  ) {}

export class FlagshipFlagAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<FlagshipFlagAlreadyExists>()(
      "FlagshipFlagAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 409, message: { includes: "Flag already exists" } }],
  ) {}

export class FlagshipFlagNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<FlagshipFlagNotFound>()(
      "FlagshipFlagNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404, message: { includes: "Flag not found" } }],
  ) {}

export interface CreateAppRequest {
  /** Cloudflare account ID. */
  accountId: string;
  name: string;
}
export const CreateAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/flagship/apps",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAppRequest",
}) as any as S.Schema<CreateAppRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateAppResponse {
  id: string;
  createdAt: string;
  name: string;
  updatedAt: string;
  /** Email of the actor who last modified the app, or `edge-gateway` for gateway-authenticated changes. */
  updatedBy: string;
}
export const CreateAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    updatedBy: S.String.pipe(T.Body("updated_by")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAppResponse",
}) as any as S.Schema<CreateAppResponse>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsCreateRequestRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsCreateRequestRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsCreateRequestRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateRequestRulesItemConditionsItemCase1 {
  clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsCreateRequestRulesItemConditionsItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsCreateRequestRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsCreateRequestRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateRequestRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsCreateRequestRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsItemCase1>;

export type AppsFlagsCreateRequestRulesItemConditionsItem =
  | AppsFlagsCreateRequestRulesItemConditionsItemCase0
  | AppsFlagsCreateRequestRulesItemConditionsItemCase1;
export const AppsFlagsCreateRequestRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateRequestRulesItemConditionsList =
  Array<AppsFlagsCreateRequestRulesItemConditionsItem>;
export const AppsFlagsCreateRequestRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateRequestRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsCreateRequestRulesItemConditionsList>;

export interface AppsFlagsCreateRequestRulesItemRollout {
  /** 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;
}
export const AppsFlagsCreateRequestRulesItemRollout = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      percentage: S.Number,
      attribute: S.optional(S.String),
    }),
).annotate({
  identifier: "AppsFlagsCreateRequestRulesItemRollout",
}) as any as S.Schema<AppsFlagsCreateRequestRulesItemRollout>;

export interface AppsFlagsCreateRequestRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsCreateRequestRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateRequestRulesItemRollout;
}
export const AppsFlagsCreateRequestRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsCreateRequestRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(AppsFlagsCreateRequestRulesItemRollout),
  }),
).annotate({
  identifier: "AppsFlagsCreateRequestRulesItem",
}) as any as S.Schema<AppsFlagsCreateRequestRulesItem>;

export type AppsFlagsCreateRequestRulesList =
  Array<AppsFlagsCreateRequestRulesItem>;
export const AppsFlagsCreateRequestRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsCreateRequestRulesItem,
) as any as S.Schema<AppsFlagsCreateRequestRulesList>;

export type UntypedVariationsMap = { [key: string]: unknown | undefined };
export const UntypedVariationsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<UntypedVariationsMap>;

export type AppsFlagsCreateRequestType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsCreateRequestType = /*@__PURE__*/ S.String;

export interface CreateAppFlagRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsCreateRequestRulesList;
  /** 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: UntypedVariationsMap;
  description?: string;
  /** Value type of the flag's variations. Inferred from the variation values on write, so it may be omitted in requests. */
  type?: AppsFlagsCreateRequestType | (string & {});
}
export const CreateAppFlagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsCreateRequestRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.String),
    type: S.optional(AppsFlagsCreateRequestType),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAppFlagRequest",
}) as any as S.Schema<CreateAppFlagRequest>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsCreateResponseRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsCreateResponseRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsCreateResponseRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsCreateResponseRulesItemConditionsItemCase1 {
  clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsCreateResponseRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsCreateResponseRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsCreateResponseRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsCreateResponseRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsCreateResponseRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsItemCase1>;

export type AppsFlagsCreateResponseRulesItemConditionsItem =
  | AppsFlagsCreateResponseRulesItemConditionsItemCase0
  | AppsFlagsCreateResponseRulesItemConditionsItemCase1;
export const AppsFlagsCreateResponseRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsCreateResponseRulesItemConditionsList =
  Array<AppsFlagsCreateResponseRulesItemConditionsItem>;
export const AppsFlagsCreateResponseRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsCreateResponseRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsCreateResponseRulesItemConditionsList>;

export interface AppsFlagsCreateResponseRulesItemRollout {
  /** 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 | null;
}
export const AppsFlagsCreateResponseRulesItemRollout = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      percentage: S.Number,
      attribute: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "AppsFlagsCreateResponseRulesItemRollout",
}) as any as S.Schema<AppsFlagsCreateResponseRulesItemRollout>;

export interface AppsFlagsCreateResponseRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsCreateResponseRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsCreateResponseRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsCreateResponseRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
  }),
).annotate({
  identifier: "AppsFlagsCreateResponseRulesItem",
}) as any as S.Schema<AppsFlagsCreateResponseRulesItem>;

export type AppsFlagsCreateResponseRulesList =
  Array<AppsFlagsCreateResponseRulesItem>;
export const AppsFlagsCreateResponseRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsCreateResponseRulesItem,
) as any as S.Schema<AppsFlagsCreateResponseRulesList>;

export type AppsFlagsCreateResponseType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsCreateResponseType = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateAppFlagResponse {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsCreateResponseRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsCreateResponseType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const CreateAppFlagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsCreateResponseRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(AppsFlagsCreateResponseType)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAppFlagResponse",
}) as any as S.Schema<CreateAppFlagResponse>;

export interface DeleteAppRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
}
export const DeleteAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAppRequest",
}) as any as S.Schema<DeleteAppRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteAppResponse {
  id: string;
}
export const DeleteAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAppResponse",
}) as any as S.Schema<DeleteAppResponse>;

export interface DeleteAppFlagRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Flag key (slug). */
  flagKey: string;
}
export const DeleteAppFlagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    flagKey: S.String.pipe(T.Label("flag_key")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags/{flag_key}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAppFlagRequest",
}) as any as S.Schema<DeleteAppFlagRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteAppFlagResponse {
  key: string;
}
export const DeleteAppFlagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAppFlagResponse",
}) as any as S.Schema<DeleteAppFlagResponse>;

export interface GetAppRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
}
export const GetAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetAppRequest" }) as any as S.Schema<GetAppRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetAppResponse {
  id: string;
  createdAt: string;
  name: string;
  updatedAt: string;
  /** Email of the actor who last modified the app, or `edge-gateway` for gateway-authenticated changes. */
  updatedBy: string;
}
export const GetAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    updatedBy: S.String.pipe(T.Body("updated_by")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetAppResponse" }) as any as S.Schema<GetAppResponse>;

export interface GetAppEvaluateRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** The flag key to evaluate. */
  flagKey: string;
  /** Context targeting key (per OpenFeature spec); used for percentage rollout bucketing. */
  targetingKey?: string;
}
export const GetAppEvaluateRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    flagKey: S.String.pipe(T.Query()),
    targetingKey: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/evaluate",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAppEvaluateRequest",
}) as any as S.Schema<GetAppEvaluateRequest>;

export type AppsEvaluateGetResponseReason =
  | "TARGETING_MATCH"
  | "DEFAULT"
  | "DISABLED"
  | "SPLIT";
export const AppsEvaluateGetResponseReason = /*@__PURE__*/ S.String;

export type AppsEvaluateGetResponseValueCase3Map = {
  [key: string]: unknown | undefined;
};
export const AppsEvaluateGetResponseValueCase3Map = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<AppsEvaluateGetResponseValueCase3Map>;

export type AppsEvaluateGetResponseValueCase4List = Array<unknown>;
export const AppsEvaluateGetResponseValueCase4List = /*@__PURE__*/ S.Array(
  S.Unknown,
) as any as S.Schema<AppsEvaluateGetResponseValueCase4List>;

export type AppsEvaluateGetResponseValue =
  | string
  | number
  | boolean
  | AppsEvaluateGetResponseValueCase3Map
  | AppsEvaluateGetResponseValueCase4List;
export const AppsEvaluateGetResponseValue = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], [], [], [], []]),
);

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetAppEvaluateResponse {
  flagKey: string;
  reason: AppsEvaluateGetResponseReason;
  variant: string;
  value?: AppsEvaluateGetResponseValue | null;
}
export const GetAppEvaluateResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    flagKey: S.String,
    reason: AppsEvaluateGetResponseReason,
    variant: S.String,
    value: S.optional(S.NullOr(AppsEvaluateGetResponseValue)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAppEvaluateResponse",
}) as any as S.Schema<GetAppEvaluateResponse>;

export interface GetAppFlagRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Flag key (slug). */
  flagKey: string;
}
export const GetAppFlagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    flagKey: S.String.pipe(T.Label("flag_key")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags/{flag_key}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAppFlagRequest",
}) as any as S.Schema<GetAppFlagRequest>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsGetResponseRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsGetResponseRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsGetResponseRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsGetResponseRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsGetResponseRulesItemConditionsItemCase1 {
  clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsGetResponseRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsGetResponseRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsGetResponseRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsGetResponseRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsGetResponseRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsItemCase1>;

export type AppsFlagsGetResponseRulesItemConditionsItem =
  | AppsFlagsGetResponseRulesItemConditionsItemCase0
  | AppsFlagsGetResponseRulesItemConditionsItemCase1;
export const AppsFlagsGetResponseRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsGetResponseRulesItemConditionsList =
  Array<AppsFlagsGetResponseRulesItemConditionsItem>;
export const AppsFlagsGetResponseRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsGetResponseRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsGetResponseRulesItemConditionsList>;

export type AppsFlagsGetResponseRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsGetResponseRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsGetResponseRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsGetResponseRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsGetResponseRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsGetResponseRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
  }),
).annotate({
  identifier: "AppsFlagsGetResponseRulesItem",
}) as any as S.Schema<AppsFlagsGetResponseRulesItem>;

export type AppsFlagsGetResponseRulesList =
  Array<AppsFlagsGetResponseRulesItem>;
export const AppsFlagsGetResponseRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsGetResponseRulesItem,
) as any as S.Schema<AppsFlagsGetResponseRulesList>;

export type AppsFlagsGetResponseType = "boolean" | "string" | "number" | "json";
export const AppsFlagsGetResponseType = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetAppFlagResponse {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsGetResponseRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsGetResponseType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const GetAppFlagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsGetResponseRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(AppsFlagsGetResponseType)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAppFlagResponse",
}) as any as S.Schema<GetAppFlagResponse>;

export interface ListAppFlagChangelogsRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Flag key (slug). */
  flagKey: string;
  /** Pagination cursor from a previous response. */
  cursor?: string;
  /** Max items to return (1–200). */
  limit?: string;
}
export const ListAppFlagChangelogsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    flagKey: S.String.pipe(T.Label("flag_key")),
    cursor: S.optional(S.String.pipe(T.Query())),
    limit: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags/{flag_key}/changelog",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppFlagChangelogsRequest",
}) as any as S.Schema<ListAppFlagChangelogsRequest>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItem =
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase0
  | AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItemCase1;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsList>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsChangelogListResultItemCase0AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsChangelogListResultItemCase0AfterRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsChangelogListResultItemCase0AfterRulesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      conditions:
        AppsFlagsChangelogListResultItemCase0AfterRulesItemConditionsList,
      priority: S.Number,
      serveVariation: S.String.pipe(T.Body("serve_variation")),
      rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase0AfterRulesItem",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesItem>;

export type AppsFlagsChangelogListResultItemCase0AfterRulesList =
  Array<AppsFlagsChangelogListResultItemCase0AfterRulesItem>;
export const AppsFlagsChangelogListResultItemCase0AfterRulesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase0AfterRulesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase0AfterRulesList>;

export type AppsFlagsChangelogListResultItemCase0AfterType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsChangelogListResultItemCase0AfterType =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0After {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsChangelogListResultItemCase0AfterRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsChangelogListResultItemCase0AfterType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const AppsFlagsChangelogListResultItemCase0After =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      defaultVariation: S.String.pipe(T.Body("default_variation")),
      enabled: S.Boolean,
      key: S.String,
      rules: AppsFlagsChangelogListResultItemCase0AfterRulesList,
      variations: UntypedVariationsMap,
      description: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(AppsFlagsChangelogListResultItemCase0AfterType),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase0After",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase0After>;

export type AppsFlagsChangelogListResultItemCase0Event = "create";
export const AppsFlagsChangelogListResultItemCase0Event =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase0 {
  after: AppsFlagsChangelogListResultItemCase0After;
  event: AppsFlagsChangelogListResultItemCase0Event;
  flagKey: string;
}
export const AppsFlagsChangelogListResultItemCase0 = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      after: AppsFlagsChangelogListResultItemCase0After,
      event: AppsFlagsChangelogListResultItemCase0Event,
      flagKey: S.String.pipe(T.Body("flag_key")),
    }),
).annotate({
  identifier: "AppsFlagsChangelogListResultItemCase0",
}) as any as S.Schema<AppsFlagsChangelogListResultItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItem =
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase0
  | AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItemCase1;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsList>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsChangelogListResultItemCase1AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsChangelogListResultItemCase1AfterRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsChangelogListResultItemCase1AfterRulesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      conditions:
        AppsFlagsChangelogListResultItemCase1AfterRulesItemConditionsList,
      priority: S.Number,
      serveVariation: S.String.pipe(T.Body("serve_variation")),
      rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase1AfterRulesItem",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesItem>;

export type AppsFlagsChangelogListResultItemCase1AfterRulesList =
  Array<AppsFlagsChangelogListResultItemCase1AfterRulesItem>;
export const AppsFlagsChangelogListResultItemCase1AfterRulesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase1AfterRulesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase1AfterRulesList>;

export type AppsFlagsChangelogListResultItemCase1AfterType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsChangelogListResultItemCase1AfterType =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1After {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsChangelogListResultItemCase1AfterRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsChangelogListResultItemCase1AfterType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const AppsFlagsChangelogListResultItemCase1After =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      defaultVariation: S.String.pipe(T.Body("default_variation")),
      enabled: S.Boolean,
      key: S.String,
      rules: AppsFlagsChangelogListResultItemCase1AfterRulesList,
      variations: UntypedVariationsMap,
      description: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(AppsFlagsChangelogListResultItemCase1AfterType),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase1After",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase1After>;

export type AppsFlagsChangelogListResultItemCase1Event = "delete";
export const AppsFlagsChangelogListResultItemCase1Event =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase1 {
  after: AppsFlagsChangelogListResultItemCase1After;
  event: AppsFlagsChangelogListResultItemCase1Event;
  flagKey: string;
}
export const AppsFlagsChangelogListResultItemCase1 = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      after: AppsFlagsChangelogListResultItemCase1After,
      event: AppsFlagsChangelogListResultItemCase1Event,
      flagKey: S.String.pipe(T.Body("flag_key")),
    }),
).annotate({
  identifier: "AppsFlagsChangelogListResultItemCase1",
}) as any as S.Schema<AppsFlagsChangelogListResultItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1 {
  clauses: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItem =
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase0
  | AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItemCase1;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsList>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsChangelogListResultItemCase2AfterRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsChangelogListResultItemCase2AfterRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsChangelogListResultItemCase2AfterRulesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      conditions:
        AppsFlagsChangelogListResultItemCase2AfterRulesItemConditionsList,
      priority: S.Number,
      serveVariation: S.String.pipe(T.Body("serve_variation")),
      rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase2AfterRulesItem",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesItem>;

export type AppsFlagsChangelogListResultItemCase2AfterRulesList =
  Array<AppsFlagsChangelogListResultItemCase2AfterRulesItem>;
export const AppsFlagsChangelogListResultItemCase2AfterRulesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsChangelogListResultItemCase2AfterRulesItem,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2AfterRulesList>;

export type AppsFlagsChangelogListResultItemCase2AfterType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsChangelogListResultItemCase2AfterType =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2After {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsChangelogListResultItemCase2AfterRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsChangelogListResultItemCase2AfterType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const AppsFlagsChangelogListResultItemCase2After =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      defaultVariation: S.String.pipe(T.Body("default_variation")),
      enabled: S.Boolean,
      key: S.String,
      rules: AppsFlagsChangelogListResultItemCase2AfterRulesList,
      variations: UntypedVariationsMap,
      description: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(AppsFlagsChangelogListResultItemCase2AfterType),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase2After",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2After>;

export type AppsFlagsChangelogListResultItemCase2DiffValueFromCase3Map = {
  [key: string]: unknown | undefined;
};
export const AppsFlagsChangelogListResultItemCase2DiffValueFromCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffValueFromCase3Map>;

export type AppsFlagsChangelogListResultItemCase2DiffValueFromCase4List =
  Array<unknown>;
export const AppsFlagsChangelogListResultItemCase2DiffValueFromCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffValueFromCase4List>;

export type AppsFlagsChangelogListResultItemCase2DiffValueFrom =
  | string
  | number
  | boolean
  | AppsFlagsChangelogListResultItemCase2DiffValueFromCase3Map
  | AppsFlagsChangelogListResultItemCase2DiffValueFromCase4List;
export const AppsFlagsChangelogListResultItemCase2DiffValueFrom =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsChangelogListResultItemCase2DiffValueToCase3Map = {
  [key: string]: unknown | undefined;
};
export const AppsFlagsChangelogListResultItemCase2DiffValueToCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffValueToCase3Map>;

export type AppsFlagsChangelogListResultItemCase2DiffValueToCase4List =
  Array<unknown>;
export const AppsFlagsChangelogListResultItemCase2DiffValueToCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffValueToCase4List>;

export type AppsFlagsChangelogListResultItemCase2DiffValueTo =
  | string
  | number
  | boolean
  | AppsFlagsChangelogListResultItemCase2DiffValueToCase3Map
  | AppsFlagsChangelogListResultItemCase2DiffValueToCase4List;
export const AppsFlagsChangelogListResultItemCase2DiffValueTo =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export interface AppsFlagsChangelogListResultItemCase2DiffValue {
  from?: AppsFlagsChangelogListResultItemCase2DiffValueFrom | null;
  to?: AppsFlagsChangelogListResultItemCase2DiffValueTo | null;
}
export const AppsFlagsChangelogListResultItemCase2DiffValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      from: S.optional(
        S.NullOr(AppsFlagsChangelogListResultItemCase2DiffValueFrom),
      ),
      to: S.optional(
        S.NullOr(AppsFlagsChangelogListResultItemCase2DiffValueTo),
      ),
    }),
  ).annotate({
    identifier: "AppsFlagsChangelogListResultItemCase2DiffValue",
  }) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffValue>;

export type AppsFlagsChangelogListResultItemCase2DiffMap = {
  [key: string]: AppsFlagsChangelogListResultItemCase2DiffValue | undefined;
};
export const AppsFlagsChangelogListResultItemCase2DiffMap =
  /*@__PURE__*/ S.Record(
    S.String,
    AppsFlagsChangelogListResultItemCase2DiffValue,
  ) as any as S.Schema<AppsFlagsChangelogListResultItemCase2DiffMap>;

export type AppsFlagsChangelogListResultItemCase2Event = "update";
export const AppsFlagsChangelogListResultItemCase2Event =
  /*@__PURE__*/ S.String;

export interface AppsFlagsChangelogListResultItemCase2 {
  after: AppsFlagsChangelogListResultItemCase2After;
  diff: AppsFlagsChangelogListResultItemCase2DiffMap;
  event: AppsFlagsChangelogListResultItemCase2Event;
  flagKey: string;
}
export const AppsFlagsChangelogListResultItemCase2 = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      after: AppsFlagsChangelogListResultItemCase2After,
      diff: AppsFlagsChangelogListResultItemCase2DiffMap,
      event: AppsFlagsChangelogListResultItemCase2Event,
      flagKey: S.String.pipe(T.Body("flag_key")),
    }),
).annotate({
  identifier: "AppsFlagsChangelogListResultItemCase2",
}) as any as S.Schema<AppsFlagsChangelogListResultItemCase2>;

export type AppsFlagsChangelogListResultItem =
  | AppsFlagsChangelogListResultItemCase0
  | AppsFlagsChangelogListResultItemCase1
  | AppsFlagsChangelogListResultItemCase2;
export const AppsFlagsChangelogListResultItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["after", "event", "flagKey"],
    ["after", "event", "flagKey"],
    ["after", "diff", "event", "flagKey"],
  ]),
);

export type AppsFlagsChangelogListResultList =
  Array<AppsFlagsChangelogListResultItem>;
export const AppsFlagsChangelogListResultList = /*@__PURE__*/ S.Array(
  AppsFlagsChangelogListResultItem,
) as any as S.Schema<AppsFlagsChangelogListResultList>;

export interface ListAppFlagChangelogsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: AppsFlagsChangelogListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListAppFlagChangelogsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: AppsFlagsChangelogListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppFlagChangelogsResponse",
}) as any as S.Schema<ListAppFlagChangelogsResponse>;

export interface ListAppFlagsRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Pagination cursor from a previous response. */
  cursor?: string;
  /** Max items to return (1–200). */
  limit?: string;
}
export const ListAppFlagsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    cursor: S.optional(S.String.pipe(T.Query())),
    limit: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppFlagsRequest",
}) as any as S.Schema<ListAppFlagsRequest>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsListResultItemRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsListResultItemRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsListResultItemRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsListResultItemRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItemRulesItemConditionsItemCase1 {
  clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsListResultItemRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsListResultItemRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsListResultItemRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsListResultItemRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsListResultItemRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsItemCase1>;

export type AppsFlagsListResultItemRulesItemConditionsItem =
  | AppsFlagsListResultItemRulesItemConditionsItemCase0
  | AppsFlagsListResultItemRulesItemConditionsItemCase1;
export const AppsFlagsListResultItemRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsListResultItemRulesItemConditionsList =
  Array<AppsFlagsListResultItemRulesItemConditionsItem>;
export const AppsFlagsListResultItemRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsListResultItemRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsListResultItemRulesItemConditionsList>;

export type AppsFlagsListResultItemRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsListResultItemRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsListResultItemRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsListResultItemRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsListResultItemRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsListResultItemRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
  }),
).annotate({
  identifier: "AppsFlagsListResultItemRulesItem",
}) as any as S.Schema<AppsFlagsListResultItemRulesItem>;

export type AppsFlagsListResultItemRulesList =
  Array<AppsFlagsListResultItemRulesItem>;
export const AppsFlagsListResultItemRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsListResultItemRulesItem,
) as any as S.Schema<AppsFlagsListResultItemRulesList>;

export type AppsFlagsListResultItemType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsListResultItemType = /*@__PURE__*/ S.String;

export interface AppsFlagsListResultItem {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsListResultItemRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsListResultItemType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const AppsFlagsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsListResultItemRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(AppsFlagsListResultItemType)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
  }),
).annotate({
  identifier: "AppsFlagsListResultItem",
}) as any as S.Schema<AppsFlagsListResultItem>;

export type AppsFlagsListResultList = Array<AppsFlagsListResultItem>;
export const AppsFlagsListResultList = /*@__PURE__*/ S.Array(
  AppsFlagsListResultItem,
) as any as S.Schema<AppsFlagsListResultList>;

export interface ListAppFlagsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: AppsFlagsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListAppFlagsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: AppsFlagsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppFlagsResponse",
}) as any as S.Schema<ListAppFlagsResponse>;

export interface ListAppsRequest {
  /** Cloudflare account ID. */
  accountId: string;
}
export const ListAppsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/flagship/apps",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppsRequest",
}) as any as S.Schema<ListAppsRequest>;

export interface AppsListResultItem {
  id: string;
  createdAt: string;
  name: string;
  updatedAt: string;
  /** Email of the actor who last modified the app, or `edge-gateway` for gateway-authenticated changes. */
  updatedBy: string;
}
export const AppsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    updatedBy: S.String.pipe(T.Body("updated_by")),
  }),
).annotate({
  identifier: "AppsListResultItem",
}) as any as S.Schema<AppsListResultItem>;

export type AppsListResultList = Array<AppsListResultItem>;
export const AppsListResultList = /*@__PURE__*/ S.Array(
  AppsListResultItem,
) as any as S.Schema<AppsListResultList>;

export interface ListAppsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: AppsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListAppsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: AppsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAppsResponse",
}) as any as S.Schema<ListAppsResponse>;

export interface UpdateAppRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  name?: string;
}
export const UpdateAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    name: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAppRequest",
}) as any as S.Schema<UpdateAppRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateAppResponse {
  id: string;
  createdAt: string;
  name: string;
  updatedAt: string;
  /** Email of the actor who last modified the app, or `edge-gateway` for gateway-authenticated changes. */
  updatedBy: string;
}
export const UpdateAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    updatedBy: S.String.pipe(T.Body("updated_by")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAppResponse",
}) as any as S.Schema<UpdateAppResponse>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsUpdateRequestRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsUpdateRequestRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator
    | (string & {});
  /** 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;
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsUpdateRequestRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateRequestRulesItemConditionsItemCase1 {
  clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesList;
  logicalOperator:
    | AppsFlagsUpdateRequestRulesItemConditionsItemCase1LogicalOperator
    | (string & {});
}
export const AppsFlagsUpdateRequestRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsUpdateRequestRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateRequestRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsUpdateRequestRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsItemCase1>;

export type AppsFlagsUpdateRequestRulesItemConditionsItem =
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase0
  | AppsFlagsUpdateRequestRulesItemConditionsItemCase1;
export const AppsFlagsUpdateRequestRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateRequestRulesItemConditionsList =
  Array<AppsFlagsUpdateRequestRulesItemConditionsItem>;
export const AppsFlagsUpdateRequestRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateRequestRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsUpdateRequestRulesItemConditionsList>;

export type AppsFlagsUpdateRequestRulesItemRollout =
  AppsFlagsCreateRequestRulesItemRollout;
export const AppsFlagsUpdateRequestRulesItemRollout =
  AppsFlagsCreateRequestRulesItemRollout;

export interface AppsFlagsUpdateRequestRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsUpdateRequestRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateRequestRulesItemRollout;
}
export const AppsFlagsUpdateRequestRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsUpdateRequestRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(AppsFlagsCreateRequestRulesItemRollout),
  }),
).annotate({
  identifier: "AppsFlagsUpdateRequestRulesItem",
}) as any as S.Schema<AppsFlagsUpdateRequestRulesItem>;

export type AppsFlagsUpdateRequestRulesList =
  Array<AppsFlagsUpdateRequestRulesItem>;
export const AppsFlagsUpdateRequestRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsUpdateRequestRulesItem,
) as any as S.Schema<AppsFlagsUpdateRequestRulesList>;

export type AppsFlagsUpdateRequestType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsUpdateRequestType = /*@__PURE__*/ S.String;

export interface UpdateAppFlagRequest {
  /** Cloudflare account ID. */
  accountId: string;
  /** App identifier. */
  appId: string;
  /** Flag key (slug). */
  flagKey: string;
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsUpdateRequestRulesList;
  /** 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: UntypedVariationsMap;
  description?: string;
  /** Value type of the flag's variations. Inferred from the variation values on write, so it may be omitted in requests. */
  type?: AppsFlagsUpdateRequestType | (string & {});
}
export const UpdateAppFlagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    flagKey: S.String.pipe(T.Label("flag_key")),
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsUpdateRequestRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.String),
    type: S.optional(AppsFlagsUpdateRequestType),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/flagship/apps/{app_id}/flags/{flag_key}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAppFlagRequest",
}) as any as S.Schema<UpdateAppFlagRequest>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier: "AppsFlagsUpdateResponseRulesItemConditionsItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  | "equals"
  | "not_equals"
  | "greater_than"
  | "less_than"
  | "greater_than_or_equals"
  | "less_than_or_equals"
  | "contains"
  | "starts_with"
  | "ends_with"
  | "in"
  | "not_in";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 {
  attribute: string;
  operator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator;
  /** 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;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      attribute: S.String,
      operator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0Operator,
      value: S.Unknown,
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  { [key: string]: unknown | undefined };
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  Array<unknown>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  | string
  | number
  | boolean
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase3Map
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesCase4List;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], [], [], []]));

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1Clauses,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier:
      "AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesList>;

export type AppsFlagsUpdateResponseRulesItemConditionsItemCase1LogicalOperator =
  | "AND"
  | "OR";
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1LogicalOperator =
  /*@__PURE__*/ S.String;

export interface AppsFlagsUpdateResponseRulesItemConditionsItemCase1 {
  clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesList;
  logicalOperator: AppsFlagsUpdateResponseRulesItemConditionsItemCase1LogicalOperator;
}
export const AppsFlagsUpdateResponseRulesItemConditionsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      clauses: AppsFlagsUpdateResponseRulesItemConditionsItemCase1ClausesList,
      logicalOperator:
        AppsFlagsUpdateResponseRulesItemConditionsItemCase1LogicalOperator.pipe(
          T.Body("logical_operator"),
        ),
    }),
  ).annotate({
    identifier: "AppsFlagsUpdateResponseRulesItemConditionsItemCase1",
  }) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsItemCase1>;

export type AppsFlagsUpdateResponseRulesItemConditionsItem =
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase0
  | AppsFlagsUpdateResponseRulesItemConditionsItemCase1;
export const AppsFlagsUpdateResponseRulesItemConditionsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["attribute", "operator", "value"],
      ["clauses", "logicalOperator"],
    ]),
  );

export type AppsFlagsUpdateResponseRulesItemConditionsList =
  Array<AppsFlagsUpdateResponseRulesItemConditionsItem>;
export const AppsFlagsUpdateResponseRulesItemConditionsList =
  /*@__PURE__*/ S.Array(
    AppsFlagsUpdateResponseRulesItemConditionsItem,
  ) as any as S.Schema<AppsFlagsUpdateResponseRulesItemConditionsList>;

export type AppsFlagsUpdateResponseRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;
export const AppsFlagsUpdateResponseRulesItemRollout =
  AppsFlagsCreateResponseRulesItemRollout;

export interface AppsFlagsUpdateResponseRulesItem {
  /** Conditions the context must satisfy for this rule to match. An empty array matches all contexts. */
  conditions: AppsFlagsUpdateResponseRulesItemConditionsList;
  /** 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`. */
  serveVariation: string;
  rollout?: AppsFlagsCreateResponseRulesItemRollout | null;
}
export const AppsFlagsUpdateResponseRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conditions: AppsFlagsUpdateResponseRulesItemConditionsList,
    priority: S.Number,
    serveVariation: S.String.pipe(T.Body("serve_variation")),
    rollout: S.optional(S.NullOr(AppsFlagsCreateResponseRulesItemRollout)),
  }),
).annotate({
  identifier: "AppsFlagsUpdateResponseRulesItem",
}) as any as S.Schema<AppsFlagsUpdateResponseRulesItem>;

export type AppsFlagsUpdateResponseRulesList =
  Array<AppsFlagsUpdateResponseRulesItem>;
export const AppsFlagsUpdateResponseRulesList = /*@__PURE__*/ S.Array(
  AppsFlagsUpdateResponseRulesItem,
) as any as S.Schema<AppsFlagsUpdateResponseRulesList>;

export type AppsFlagsUpdateResponseType =
  | "boolean"
  | "string"
  | "number"
  | "json";
export const AppsFlagsUpdateResponseType = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateAppFlagResponse {
  /** Variation served when no rule matches or the flag is disabled. Must be a key in `variations`. */
  defaultVariation: 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: AppsFlagsUpdateResponseRulesList;
  /** 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: UntypedVariationsMap;
  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?: AppsFlagsUpdateResponseType | null;
  updatedAt?: string | null;
  updatedBy?: string | null;
}
export const UpdateAppFlagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultVariation: S.String.pipe(T.Body("default_variation")),
    enabled: S.Boolean,
    key: S.String,
    rules: AppsFlagsUpdateResponseRulesList,
    variations: UntypedVariationsMap,
    description: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(AppsFlagsUpdateResponseType)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    updatedBy: S.optional(S.NullOr(S.String).pipe(T.Body("updated_by"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAppFlagResponse",
}) as any as S.Schema<UpdateAppFlagResponse>;

export type CreateAppError = CloudflareOpError;
/** Creates an app. The returned `id` is used in all subsequent flag, changelog, and evaluation requests. */
export const createApp: API.OperationMethod<
  CreateAppRequest,
  CreateAppResponse,
  CreateAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateAppRequest,
  output: CreateAppResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateAppFlagError =
  | FlagshipFlagAlreadyExists
  | FlagshipAppNotFound
  | CloudflareOpError;
/** Creates a flag. Returns 409 if the key already exists. `type` is inferred from variation values and may be omitted. */
export const createAppFlag: API.OperationMethod<
  CreateAppFlagRequest,
  CreateAppFlagResponse,
  CreateAppFlagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateAppFlagRequest,
  output: CreateAppFlagResponse,
  errors: [
    FlagshipFlagAlreadyExists,
    FlagshipAppNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteAppError = FlagshipAppNotFound | CloudflareOpError;
/** Deletes an app and all its flags and changelog history. Returns 409 if any Worker still references this app via a Flagship binding. */
export const deleteApp: API.OperationMethod<
  DeleteAppRequest,
  DeleteAppResponse,
  DeleteAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteAppRequest,
  output: DeleteAppResponse,
  errors: [FlagshipAppNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteAppFlagError =
  | FlagshipFlagNotFound
  | FlagshipAppNotFound
  | CloudflareOpError;
/** Permanently deletes a flag. Subsequent evaluations fall back to the caller-supplied default. Cannot be undone. */
export const deleteAppFlag: API.OperationMethod<
  DeleteAppFlagRequest,
  DeleteAppFlagResponse,
  DeleteAppFlagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteAppFlagRequest,
  output: DeleteAppFlagResponse,
  errors: [
    FlagshipFlagNotFound,
    FlagshipAppNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAppError = FlagshipAppNotFound | CloudflareOpError;
/** Returns an app's name and audit fields. Flag definitions are not included. */
export const getApp: API.OperationMethod<
  GetAppRequest,
  GetAppResponse,
  GetAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAppRequest,
  output: GetAppResponse,
  errors: [FlagshipAppNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAppEvaluateError = CloudflareOpError;
/** 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. */
export const getAppEvaluate: API.OperationMethod<
  GetAppEvaluateRequest,
  GetAppEvaluateResponse,
  GetAppEvaluateError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAppEvaluateRequest,
  output: GetAppEvaluateResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAppFlagError =
  | FlagshipFlagNotFound
  | FlagshipAppNotFound
  | CloudflareOpError;
/** Returns the full flag definition including rules, variations, and audit fields. */
export const getAppFlag: API.OperationMethod<
  GetAppFlagRequest,
  GetAppFlagResponse,
  GetAppFlagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAppFlagRequest,
  output: GetAppFlagResponse,
  errors: [
    FlagshipFlagNotFound,
    FlagshipAppNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAppFlagChangelogsError = CloudflareOpError;
/** 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. */
export const listAppFlagChangelogs: API.PaginatedOperationMethod<
  ListAppFlagChangelogsRequest,
  ListAppFlagChangelogsResponse,
  ListAppFlagChangelogsError,
  CloudflareOpContext,
  AppsFlagsChangelogListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAppFlagChangelogsRequest,
    output: ListAppFlagChangelogsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListAppFlagsError = FlagshipAppNotFound | CloudflareOpError;
/** Lists an app's flags ordered by key. Pass `cursor` from `result_info` to page forward; a null cursor indicates the last page. */
export const listAppFlags: API.PaginatedOperationMethod<
  ListAppFlagsRequest,
  ListAppFlagsResponse,
  ListAppFlagsError,
  CloudflareOpContext,
  AppsFlagsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAppFlagsRequest,
    output: ListAppFlagsResponse,
    errors: [FlagshipAppNotFound, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListAppsError = CloudflareOpError;
/** Lists all apps in the account. Returns identity and audit fields only — flag definitions are not included. */
export const listApps: API.PaginatedOperationMethod<
  ListAppsRequest,
  ListAppsResponse,
  ListAppsError,
  CloudflareOpContext,
  AppsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAppsRequest,
    output: ListAppsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type UpdateAppError = FlagshipAppNotFound | CloudflareOpError;
/** Updates an app. Only `name` is mutable. */
export const updateApp: API.OperationMethod<
  UpdateAppRequest,
  UpdateAppResponse,
  UpdateAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateAppRequest,
  output: UpdateAppResponse,
  errors: [FlagshipAppNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateAppFlagError =
  | FlagshipFlagNotFound
  | FlagshipAppNotFound
  | CloudflareOpError;
/** Replaces the entire flag definition. Omitted fields are dropped, not preserved — read before writing. Each update appends a changelog entry. */
export const updateAppFlag: API.OperationMethod<
  UpdateAppFlagRequest,
  UpdateAppFlagResponse,
  UpdateAppFlagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateAppFlagRequest,
  output: UpdateAppFlagResponse,
  errors: [
    FlagshipFlagNotFound,
    FlagshipAppNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));