@distilled.cloud/vercel 0.0.0 → 1.0.0-rc.4

package/lib/services/feature_flags.d.ts

@@ -0,0 +1,3109 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type VercelOpError, type VercelOpContext } from "../protocol.ts";
+export type { VercelOpError, VercelOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const PaymentRequired_base: S.Class<PaymentRequired, S.TaggedStruct<"PaymentRequired", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
+export declare class PaymentRequired extends /*@__PURE__*/ PaymentRequired_base {
+}
+/** The kind of flag */
+export type CreateFlagRequestKind = "boolean" | "string" | "number" | "json";
+export declare const CreateFlagRequestKind: any;
+export type CreateFlagRequestVariantsItemValueCase4List = Array<unknown>;
+export declare const CreateFlagRequestVariantsItemValueCase4List: S.Schema<CreateFlagRequestVariantsItemValueCase4List>;
+export type CreateFlagRequestVariantsItemValue = string | number | boolean | unknown | CreateFlagRequestVariantsItemValueCase4List;
+export declare const CreateFlagRequestVariantsItemValue: S.Schema<CreateFlagRequestVariantsItemValue>;
+export interface CreateFlagRequestVariantsItem {
+    /** The id of the variant */
+    id: string;
+    /** A label for the variant */
+    label?: string;
+    /** A description of the variant */
+    description?: string;
+    value: CreateFlagRequestVariantsItemValue;
+}
+export declare const CreateFlagRequestVariantsItem: S.Schema<CreateFlagRequestVariantsItem>;
+/** The variants of the flag */
+export type CreateFlagRequestVariantsList = Array<CreateFlagRequestVariantsItem>;
+export declare const CreateFlagRequestVariantsList: S.Schema<CreateFlagRequestVariantsList>;
+/** Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration */
+export interface CreateFlagRequestEnvironmentsValueReuse {
+    /** Whether the reuse is active or not */
+    active: boolean;
+    /** The environment to link to */
+    environment: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueReuse: S.Schema<CreateFlagRequestEnvironmentsValueReuse>;
+export interface CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem {
+    note?: string;
+    value: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagRequestEnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagRequestEnvironmentsValueTargetsValueValueValueList: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueList>;
+export type CreateFlagRequestEnvironmentsValueTargetsValueValueMap = {
+    [key: string]: CreateFlagRequestEnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsValueTargetsValueValueMap: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueMap>;
+export type CreateFlagRequestEnvironmentsValueTargetsValueMap = {
+    [key: string]: CreateFlagRequestEnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsValueTargetsValueMap: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueMap>;
+/** Allows assigning targets to variants while bypassing the flag's rules */
+export type CreateFlagRequestEnvironmentsValueTargetsMap = {
+    [key: string]: CreateFlagRequestEnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsValueTargetsMap: S.Schema<CreateFlagRequestEnvironmentsValueTargetsMap>;
+export interface CreateFlagRequestEnvironmentsValuePausedOutcome {
+    type: unknown;
+    variantId: string;
+}
+export declare const CreateFlagRequestEnvironmentsValuePausedOutcome: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 {
+    type: unknown;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1 {
+    type: unknown;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp = "eq" | "!eq" | "oneOf" | "!oneOf" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "startsWith" | "!startsWith" | "endsWith" | "!endsWith" | "contains" | "!contains" | "ex" | "!ex" | "gt" | "gte" | "lt" | "lte" | "regex" | "!regex" | "before" | "after";
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp: any;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type = "list/inline" | "list";
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type: any;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 {
+    label?: string;
+    note?: string;
+    value: number;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1 {
+    label?: string;
+    note?: string;
+    value: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList = Array<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem>;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0 {
+    type: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type | (string & {});
+    items: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 {
+    type: unknown;
+    pattern: string;
+    flags: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 | string | number | boolean;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions {
+    ignoreCase?: boolean;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemConditionsItem {
+    lhs: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp | (string & {});
+    rhs?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItem>;
+export type CreateFlagRequestEnvironmentsValueRulesItemConditionsList = Array<CreateFlagRequestEnvironmentsValueRulesItemConditionsItem>;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemConditionsList: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsList>;
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase0 = CreateFlagRequestEnvironmentsValuePausedOutcome;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase0: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+/** The distribution for each variant */
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** The distribution for each variant */
+    weights: CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1>;
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem {
+    /** Promille of traffic for rollToVariant (0-100_000, where 1_000 = 1%) */
+    promille: number;
+    /** How long this promille is served in ms before moving to the next slot. */
+    durationMs: number;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+/** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** Epoch ms when the rollout begins */
+    startTimestamp: number;
+    /** The variant to roll away from */
+    rollFromVariantId: string;
+    /** The variant to roll towards */
+    rollToVariantId: string;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+    /** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+    slots: CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2>;
+export type CreateFlagRequestEnvironmentsValueRulesItemOutcome = CreateFlagRequestEnvironmentsValuePausedOutcome | CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase1 | CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2;
+export declare const CreateFlagRequestEnvironmentsValueRulesItemOutcome: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcome>;
+export interface CreateFlagRequestEnvironmentsValueRulesItem {
+    id: string;
+    conditions: CreateFlagRequestEnvironmentsValueRulesItemConditionsList;
+    outcome: CreateFlagRequestEnvironmentsValueRulesItemOutcome;
+}
+export declare const CreateFlagRequestEnvironmentsValueRulesItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItem>;
+export type CreateFlagRequestEnvironmentsValueRulesList = Array<CreateFlagRequestEnvironmentsValueRulesItem>;
+export declare const CreateFlagRequestEnvironmentsValueRulesList: S.Schema<CreateFlagRequestEnvironmentsValueRulesList>;
+export type CreateFlagRequestEnvironmentsValueFallthroughCase0 = CreateFlagRequestEnvironmentsValuePausedOutcome;
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase0: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export type CreateFlagRequestEnvironmentsValueFallthroughCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+/** The distribution for each variant */
+export type CreateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap: S.Schema<CreateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap>;
+export interface CreateFlagRequestEnvironmentsValueFallthroughCase1 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** The distribution for each variant */
+    weights: CreateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+}
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase1: S.Schema<CreateFlagRequestEnvironmentsValueFallthroughCase1>;
+export type CreateFlagRequestEnvironmentsValueFallthroughCase2Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase2Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsItem = CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem;
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+/** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+export type CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsList: S.Schema<CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsList>;
+export interface CreateFlagRequestEnvironmentsValueFallthroughCase2 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** Epoch ms when the rollout begins */
+    startTimestamp: number;
+    /** The variant to roll away from */
+    rollFromVariantId: string;
+    /** The variant to roll towards */
+    rollToVariantId: string;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+    /** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+    slots: CreateFlagRequestEnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const CreateFlagRequestEnvironmentsValueFallthroughCase2: S.Schema<CreateFlagRequestEnvironmentsValueFallthroughCase2>;
+export type CreateFlagRequestEnvironmentsValueFallthrough = CreateFlagRequestEnvironmentsValuePausedOutcome | CreateFlagRequestEnvironmentsValueFallthroughCase1 | CreateFlagRequestEnvironmentsValueFallthroughCase2;
+export declare const CreateFlagRequestEnvironmentsValueFallthrough: S.Schema<CreateFlagRequestEnvironmentsValueFallthrough>;
+export interface CreateFlagRequestEnvironmentsValue {
+    active: boolean;
+    /** Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration */
+    reuse?: CreateFlagRequestEnvironmentsValueReuse;
+    /** Allows assigning targets to variants while bypassing the flag's rules */
+    targets?: CreateFlagRequestEnvironmentsValueTargetsMap;
+    pausedOutcome: CreateFlagRequestEnvironmentsValuePausedOutcome;
+    rules: CreateFlagRequestEnvironmentsValueRulesList;
+    fallthrough: CreateFlagRequestEnvironmentsValueFallthrough;
+    /** The revision of the environment config */
+    revision?: number;
+}
+export declare const CreateFlagRequestEnvironmentsValue: S.Schema<CreateFlagRequestEnvironmentsValue>;
+/** The configuration for the flag in different environments */
+export type CreateFlagRequestEnvironmentsMap = {
+    [key: string]: CreateFlagRequestEnvironmentsValue | undefined;
+};
+export declare const CreateFlagRequestEnvironmentsMap: S.Schema<CreateFlagRequestEnvironmentsMap>;
+export type CreateFlagRequestState = "active" | "archived";
+export declare const CreateFlagRequestState: any;
+/** The user ids of the maintainers of the flag */
+export type CreateFlagRequestMaintainerIdsList = Array<string>;
+export declare const CreateFlagRequestMaintainerIdsList: S.Schema<CreateFlagRequestMaintainerIdsList>;
+/** Tags for categorizing the flag */
+export type CreateFlagRequestTagsList = Array<string>;
+export declare const CreateFlagRequestTagsList: S.Schema<CreateFlagRequestTagsList>;
+export interface CreateFlagRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The kind of flag */
+    kind: CreateFlagRequestKind | (string & {});
+    /** The variants of the flag */
+    variants?: CreateFlagRequestVariantsList;
+    /** The configuration for the flag in different environments */
+    environments: CreateFlagRequestEnvironmentsMap;
+    /** A random seed to prevent split points in different flags from having the same targets */
+    seed?: number;
+    /** A description of the flag */
+    description?: string;
+    state?: CreateFlagRequestState | (string & {});
+    /** The user ids of the maintainers of the flag */
+    maintainerIds?: CreateFlagRequestMaintainerIdsList;
+    /** Whether this flag is marked as permanent, indicating it should not be removed */
+    permanent?: boolean;
+    /** Tags for categorizing the flag */
+    tags?: CreateFlagRequestTagsList;
+}
+export declare const CreateFlagRequest: S.Schema<CreateFlagRequest>;
+export type CreateFlagResponseMaintainerIdsList = Array<string>;
+export declare const CreateFlagResponseMaintainerIdsList: S.Schema<CreateFlagResponseMaintainerIdsList>;
+export type CreateFlagResponseTagsList = Array<string>;
+export declare const CreateFlagResponseTagsList: S.Schema<CreateFlagResponseTagsList>;
+export type CreateFlagResponseExperimentGuardrailMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const CreateFlagResponseExperimentGuardrailMetricsItemMetricType: any;
+export type CreateFlagResponseExperimentGuardrailMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const CreateFlagResponseExperimentGuardrailMetricsItemMetricUnit: any;
+export type CreateFlagResponseExperimentGuardrailMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const CreateFlagResponseExperimentGuardrailMetricsItemDirectionality: any;
+export interface CreateFlagResponseExperimentGuardrailMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: CreateFlagResponseExperimentGuardrailMetricsItemMetricType;
+    metricUnit: CreateFlagResponseExperimentGuardrailMetricsItemMetricUnit;
+    directionality: CreateFlagResponseExperimentGuardrailMetricsItemDirectionality;
+}
+export declare const CreateFlagResponseExperimentGuardrailMetricsItem: S.Schema<CreateFlagResponseExperimentGuardrailMetricsItem>;
+export type CreateFlagResponseExperimentGuardrailMetricsList = Array<CreateFlagResponseExperimentGuardrailMetricsItem>;
+export declare const CreateFlagResponseExperimentGuardrailMetricsList: S.Schema<CreateFlagResponseExperimentGuardrailMetricsList>;
+export type CreateFlagResponseExperimentDevice = "android" | "desktop" | "ios" | "mweb";
+export declare const CreateFlagResponseExperimentDevice: any;
+export type CreateFlagResponseExperimentDurationUnit = "days" | "exposures";
+export declare const CreateFlagResponseExperimentDurationUnit: any;
+export type CreateFlagResponseExperimentAllocationUnit = "cookieId" | "userId" | "visitorId";
+export declare const CreateFlagResponseExperimentAllocationUnit: any;
+export type CreateFlagResponseExperimentPrimaryMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const CreateFlagResponseExperimentPrimaryMetricsItemMetricType: any;
+export type CreateFlagResponseExperimentPrimaryMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const CreateFlagResponseExperimentPrimaryMetricsItemMetricUnit: any;
+export type CreateFlagResponseExperimentPrimaryMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const CreateFlagResponseExperimentPrimaryMetricsItemDirectionality: any;
+export interface CreateFlagResponseExperimentPrimaryMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: CreateFlagResponseExperimentPrimaryMetricsItemMetricType;
+    metricUnit: CreateFlagResponseExperimentPrimaryMetricsItemMetricUnit;
+    directionality: CreateFlagResponseExperimentPrimaryMetricsItemDirectionality;
+}
+export declare const CreateFlagResponseExperimentPrimaryMetricsItem: S.Schema<CreateFlagResponseExperimentPrimaryMetricsItem>;
+export type CreateFlagResponseExperimentPrimaryMetricsList = Array<CreateFlagResponseExperimentPrimaryMetricsItem>;
+export declare const CreateFlagResponseExperimentPrimaryMetricsList: S.Schema<CreateFlagResponseExperimentPrimaryMetricsList>;
+export type CreateFlagResponseExperimentStatus = "closed" | "draft" | "paused" | "running";
+export declare const CreateFlagResponseExperimentStatus: any;
+export interface CreateFlagResponseExperiment {
+    id?: string;
+    name?: string;
+    numVariants?: number;
+    surfaceArea?: string;
+    stickyRequirement?: boolean;
+    layer?: string;
+    guardrailMetrics?: CreateFlagResponseExperimentGuardrailMetricsList;
+    hypothesis?: string;
+    device?: CreateFlagResponseExperimentDevice;
+    controlVariantId?: string;
+    startedAt?: number;
+    endedAt?: number;
+    decision?: string;
+    decisionReason?: string;
+    duration?: number;
+    durationUnit?: CreateFlagResponseExperimentDurationUnit;
+    allocationPercent?: number;
+    allocationUnit: CreateFlagResponseExperimentAllocationUnit;
+    primaryMetrics: CreateFlagResponseExperimentPrimaryMetricsList;
+    status: CreateFlagResponseExperimentStatus;
+}
+export declare const CreateFlagResponseExperiment: S.Schema<CreateFlagResponseExperiment>;
+export type CreateFlagResponseVariantsList = Array<unknown>;
+export declare const CreateFlagResponseVariantsList: S.Schema<CreateFlagResponseVariantsList>;
+export interface CreateFlagResponseEnvironmentsValueReuse {
+    active: boolean;
+    environment: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueReuse: S.Schema<CreateFlagResponseEnvironmentsValueReuse>;
+export type CreateFlagResponseEnvironmentsValueTargetsValueValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const CreateFlagResponseEnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagResponseEnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagResponseEnvironmentsValueTargetsValueValueValueList: S.Schema<CreateFlagResponseEnvironmentsValueTargetsValueValueValueList>;
+export type CreateFlagResponseEnvironmentsValueTargetsValueValueMap = {
+    [key: string]: CreateFlagResponseEnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsValueTargetsValueValueMap: S.Schema<CreateFlagResponseEnvironmentsValueTargetsValueValueMap>;
+export type CreateFlagResponseEnvironmentsValueTargetsValueMap = {
+    [key: string]: CreateFlagResponseEnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsValueTargetsValueMap: S.Schema<CreateFlagResponseEnvironmentsValueTargetsValueMap>;
+export type CreateFlagResponseEnvironmentsValueTargetsMap = {
+    [key: string]: CreateFlagResponseEnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsValueTargetsMap: S.Schema<CreateFlagResponseEnvironmentsValueTargetsMap>;
+export type CreateFlagResponseEnvironmentsValuePausedOutcomeType = "variant";
+export declare const CreateFlagResponseEnvironmentsValuePausedOutcomeType: any;
+export interface CreateFlagResponseEnvironmentsValuePausedOutcome {
+    type: CreateFlagResponseEnvironmentsValuePausedOutcomeType;
+    variantId: string;
+}
+export declare const CreateFlagResponseEnvironmentsValuePausedOutcome: S.Schema<CreateFlagResponseEnvironmentsValuePausedOutcome>;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase0Type = "variant";
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase0Type: any;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase0 {
+    type: CreateFlagResponseEnvironmentsValueFallthroughCase0Type;
+    variantId: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase0: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase0>;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase1Type = "split";
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase1Type: any;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase1BaseType = "entity";
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase1BaseType: any;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase1Base {
+    type: CreateFlagResponseEnvironmentsValueFallthroughCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase1Base: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase1Base>;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase1WeightsMap: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase1WeightsMap>;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase1 {
+    type: CreateFlagResponseEnvironmentsValueFallthroughCase1Type;
+    base: CreateFlagResponseEnvironmentsValueFallthroughCase1Base;
+    weights: CreateFlagResponseEnvironmentsValueFallthroughCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase1: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase1>;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase2Type = "rollout";
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2Type: any;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase2BaseType = "entity";
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2BaseType: any;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase2Base {
+    type: CreateFlagResponseEnvironmentsValueFallthroughCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2Base: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2Base>;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem {
+    promille: number;
+    durationMs: number;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsList: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsList>;
+export interface CreateFlagResponseEnvironmentsValueFallthroughCase2 {
+    type: CreateFlagResponseEnvironmentsValueFallthroughCase2Type;
+    base: CreateFlagResponseEnvironmentsValueFallthroughCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const CreateFlagResponseEnvironmentsValueFallthroughCase2: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2>;
+export type CreateFlagResponseEnvironmentsValueFallthrough = CreateFlagResponseEnvironmentsValueFallthroughCase0 | CreateFlagResponseEnvironmentsValueFallthroughCase1 | CreateFlagResponseEnvironmentsValueFallthroughCase2;
+export declare const CreateFlagResponseEnvironmentsValueFallthrough: S.Schema<CreateFlagResponseEnvironmentsValueFallthrough>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0Type = "variant";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0Type: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0Type;
+    variantId: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Type = "split";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Type: any;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1BaseType = "entity";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1BaseType: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Base {
+    type: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Base>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Type;
+    base: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1Base;
+    weights: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Type = "rollout";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Type: any;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2BaseType = "entity";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2BaseType: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Base {
+    type: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Base>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Type;
+    base: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2>;
+export type CreateFlagResponseEnvironmentsValueRulesItemOutcome = CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase0 | CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase1 | CreateFlagResponseEnvironmentsValueRulesItemOutcomeCase2;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemOutcome: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemOutcome>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2Type: any;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList = Array<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList>;
+export interface CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2Type;
+    items: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3Type: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhs = string | number | CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase2 | CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhsCase3 | boolean;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhs: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhs>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0Type: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0Type;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1Type: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1 {
+    type: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhs = CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhs: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhs>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItemCmp: any;
+export interface CreateFlagResponseEnvironmentsValueRulesItemConditionsItem {
+    rhs?: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: CreateFlagResponseEnvironmentsValueRulesItemConditionsItemCmp;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsItem: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsItem>;
+export type CreateFlagResponseEnvironmentsValueRulesItemConditionsList = Array<CreateFlagResponseEnvironmentsValueRulesItemConditionsItem>;
+export declare const CreateFlagResponseEnvironmentsValueRulesItemConditionsList: S.Schema<CreateFlagResponseEnvironmentsValueRulesItemConditionsList>;
+export interface CreateFlagResponseEnvironmentsValueRulesItem {
+    id: string;
+    outcome: CreateFlagResponseEnvironmentsValueRulesItemOutcome;
+    conditions: CreateFlagResponseEnvironmentsValueRulesItemConditionsList;
+}
+export declare const CreateFlagResponseEnvironmentsValueRulesItem: S.Schema<CreateFlagResponseEnvironmentsValueRulesItem>;
+export type CreateFlagResponseEnvironmentsValueRulesList = Array<CreateFlagResponseEnvironmentsValueRulesItem>;
+export declare const CreateFlagResponseEnvironmentsValueRulesList: S.Schema<CreateFlagResponseEnvironmentsValueRulesList>;
+export interface CreateFlagResponseEnvironmentsValue {
+    reuse?: CreateFlagResponseEnvironmentsValueReuse;
+    targets?: CreateFlagResponseEnvironmentsValueTargetsMap;
+    revision?: number;
+    pausedOutcome: CreateFlagResponseEnvironmentsValuePausedOutcome;
+    fallthrough: CreateFlagResponseEnvironmentsValueFallthrough;
+    active: boolean;
+    rules: CreateFlagResponseEnvironmentsValueRulesList;
+}
+export declare const CreateFlagResponseEnvironmentsValue: S.Schema<CreateFlagResponseEnvironmentsValue>;
+export type CreateFlagResponseEnvironmentsMap = {
+    [key: string]: CreateFlagResponseEnvironmentsValue | undefined;
+};
+export declare const CreateFlagResponseEnvironmentsMap: S.Schema<CreateFlagResponseEnvironmentsMap>;
+export type CreateFlagResponseKind = "boolean" | "json" | "number" | "string";
+export declare const CreateFlagResponseKind: any;
+export type CreateFlagResponseState = "active" | "archived";
+export declare const CreateFlagResponseState: any;
+export type CreateFlagResponseTypeName = "flag";
+export declare const CreateFlagResponseTypeName: any;
+export interface CreateFlagResponse {
+    description?: string;
+    maintainerIds?: CreateFlagResponseMaintainerIdsList;
+    permanent?: boolean;
+    tags?: CreateFlagResponseTagsList;
+    experiment?: CreateFlagResponseExperiment;
+    updatedBy?: string;
+    variants: CreateFlagResponseVariantsList;
+    id: string;
+    environments: CreateFlagResponseEnvironmentsMap;
+    kind: CreateFlagResponseKind;
+    revision: number;
+    seed: number;
+    state: CreateFlagResponseState;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    ownerId: string;
+    projectId: string;
+    typeName: CreateFlagResponseTypeName;
+}
+export declare const CreateFlagResponse: S.Schema<CreateFlagResponse>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemLhsCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemLhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemLhs = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemLhs: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItemLhs>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemCmp = "eq" | "!eq" | "oneOf" | "!oneOf" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "startsWith" | "!startsWith" | "endsWith" | "!endsWith" | "contains" | "!contains" | "ex" | "!ex" | "gt" | "gte" | "lt" | "lte" | "regex" | "!regex" | "before" | "after";
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemCmp: any;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type = "list/inline" | "list";
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type: any;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList = Array<CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem>;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList>;
+export interface CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0 {
+    type: CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type | (string & {});
+    items: CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList;
+}
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemRhs = CreateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 | string | number | boolean;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemRhs: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItemRhs>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export interface CreateFlagSegmentRequestDataRulesItemConditionsItem {
+    lhs: CreateFlagSegmentRequestDataRulesItemConditionsItemLhs;
+    cmp: CreateFlagSegmentRequestDataRulesItemConditionsItemCmp | (string & {});
+    rhs?: CreateFlagSegmentRequestDataRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+}
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsItem: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsItem>;
+export type CreateFlagSegmentRequestDataRulesItemConditionsList = Array<CreateFlagSegmentRequestDataRulesItemConditionsItem>;
+export declare const CreateFlagSegmentRequestDataRulesItemConditionsList: S.Schema<CreateFlagSegmentRequestDataRulesItemConditionsList>;
+export type CreateFlagSegmentRequestDataRulesItemOutcomeCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0;
+export declare const CreateFlagSegmentRequestDataRulesItemOutcomeCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type CreateFlagSegmentRequestDataRulesItemOutcomeCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemOutcomeCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export interface CreateFlagSegmentRequestDataRulesItemOutcomeCase1 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    passPromille: number;
+}
+export declare const CreateFlagSegmentRequestDataRulesItemOutcomeCase1: S.Schema<CreateFlagSegmentRequestDataRulesItemOutcomeCase1>;
+export type CreateFlagSegmentRequestDataRulesItemOutcome = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagSegmentRequestDataRulesItemOutcomeCase1;
+export declare const CreateFlagSegmentRequestDataRulesItemOutcome: S.Schema<CreateFlagSegmentRequestDataRulesItemOutcome>;
+export interface CreateFlagSegmentRequestDataRulesItem {
+    id: string;
+    conditions: CreateFlagSegmentRequestDataRulesItemConditionsList;
+    outcome: CreateFlagSegmentRequestDataRulesItemOutcome;
+}
+export declare const CreateFlagSegmentRequestDataRulesItem: S.Schema<CreateFlagSegmentRequestDataRulesItem>;
+export type CreateFlagSegmentRequestDataRulesList = Array<CreateFlagSegmentRequestDataRulesItem>;
+export declare const CreateFlagSegmentRequestDataRulesList: S.Schema<CreateFlagSegmentRequestDataRulesList>;
+export type CreateFlagSegmentRequestDataIncludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const CreateFlagSegmentRequestDataIncludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagSegmentRequestDataIncludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagSegmentRequestDataIncludeValueValueList: S.Schema<CreateFlagSegmentRequestDataIncludeValueValueList>;
+export type CreateFlagSegmentRequestDataIncludeValueMap = {
+    [key: string]: CreateFlagSegmentRequestDataIncludeValueValueList | undefined;
+};
+export declare const CreateFlagSegmentRequestDataIncludeValueMap: S.Schema<CreateFlagSegmentRequestDataIncludeValueMap>;
+export type CreateFlagSegmentRequestDataIncludeMap = {
+    [key: string]: CreateFlagSegmentRequestDataIncludeValueMap | undefined;
+};
+export declare const CreateFlagSegmentRequestDataIncludeMap: S.Schema<CreateFlagSegmentRequestDataIncludeMap>;
+export type CreateFlagSegmentRequestDataExcludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const CreateFlagSegmentRequestDataExcludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagSegmentRequestDataExcludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagSegmentRequestDataExcludeValueValueList: S.Schema<CreateFlagSegmentRequestDataExcludeValueValueList>;
+export type CreateFlagSegmentRequestDataExcludeValueMap = {
+    [key: string]: CreateFlagSegmentRequestDataExcludeValueValueList | undefined;
+};
+export declare const CreateFlagSegmentRequestDataExcludeValueMap: S.Schema<CreateFlagSegmentRequestDataExcludeValueMap>;
+export type CreateFlagSegmentRequestDataExcludeMap = {
+    [key: string]: CreateFlagSegmentRequestDataExcludeValueMap | undefined;
+};
+export declare const CreateFlagSegmentRequestDataExcludeMap: S.Schema<CreateFlagSegmentRequestDataExcludeMap>;
+/** The data of the segment */
+export interface CreateFlagSegmentRequestData {
+    rules?: CreateFlagSegmentRequestDataRulesList;
+    include?: CreateFlagSegmentRequestDataIncludeMap;
+    exclude?: CreateFlagSegmentRequestDataExcludeMap;
+}
+export declare const CreateFlagSegmentRequestData: S.Schema<CreateFlagSegmentRequestData>;
+export interface CreateFlagSegmentRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The entity who created the segment */
+    createdBy?: string;
+    label: string;
+    description?: string;
+    /** The data of the segment */
+    data: CreateFlagSegmentRequestData;
+    hint: string;
+}
+export declare const CreateFlagSegmentRequest: S.Schema<CreateFlagSegmentRequest>;
+export type CreateFlagSegmentResponseUsedByFlagsList = Array<string>;
+export declare const CreateFlagSegmentResponseUsedByFlagsList: S.Schema<CreateFlagSegmentResponseUsedByFlagsList>;
+export type CreateFlagSegmentResponseUsedBySegmentsList = Array<string>;
+export declare const CreateFlagSegmentResponseUsedBySegmentsList: S.Schema<CreateFlagSegmentResponseUsedBySegmentsList>;
+export type CreateFlagSegmentResponseDataRulesItemOutcomeCase0Type = "all";
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase0Type: any;
+export interface CreateFlagSegmentResponseDataRulesItemOutcomeCase0 {
+    type: CreateFlagSegmentResponseDataRulesItemOutcomeCase0Type;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase0: S.Schema<CreateFlagSegmentResponseDataRulesItemOutcomeCase0>;
+export type CreateFlagSegmentResponseDataRulesItemOutcomeCase1Type = "split";
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase1Type: any;
+export type CreateFlagSegmentResponseDataRulesItemOutcomeCase1BaseType = "entity";
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase1BaseType: any;
+export interface CreateFlagSegmentResponseDataRulesItemOutcomeCase1Base {
+    type: CreateFlagSegmentResponseDataRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase1Base: S.Schema<CreateFlagSegmentResponseDataRulesItemOutcomeCase1Base>;
+export interface CreateFlagSegmentResponseDataRulesItemOutcomeCase1 {
+    type: CreateFlagSegmentResponseDataRulesItemOutcomeCase1Type;
+    base: CreateFlagSegmentResponseDataRulesItemOutcomeCase1Base;
+    passPromille: number;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemOutcomeCase1: S.Schema<CreateFlagSegmentResponseDataRulesItemOutcomeCase1>;
+export type CreateFlagSegmentResponseDataRulesItemOutcome = CreateFlagSegmentResponseDataRulesItemOutcomeCase0 | CreateFlagSegmentResponseDataRulesItemOutcomeCase1;
+export declare const CreateFlagSegmentResponseDataRulesItemOutcome: S.Schema<CreateFlagSegmentResponseDataRulesItemOutcome>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2Type: any;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItem>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsList = Array<CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsList: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsList>;
+export interface CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2 {
+    type: CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2Type;
+    items: CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3Type: any;
+export interface CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3 {
+    type: CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemRhs = string | number | CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase2 | CreateFlagSegmentResponseDataRulesItemConditionsItemRhsCase3 | boolean;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemRhs: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemRhs>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0Type: any;
+export interface CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0 {
+    type: CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0Type;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1Type: any;
+export interface CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1 {
+    type: CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemLhs = CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase0 | CreateFlagSegmentResponseDataRulesItemConditionsItemLhsCase1;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemLhs: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItemLhs>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItemCmp: any;
+export interface CreateFlagSegmentResponseDataRulesItemConditionsItem {
+    rhs?: CreateFlagSegmentResponseDataRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: CreateFlagSegmentResponseDataRulesItemConditionsItemLhs;
+    cmp: CreateFlagSegmentResponseDataRulesItemConditionsItemCmp;
+}
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsItem: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsItem>;
+export type CreateFlagSegmentResponseDataRulesItemConditionsList = Array<CreateFlagSegmentResponseDataRulesItemConditionsItem>;
+export declare const CreateFlagSegmentResponseDataRulesItemConditionsList: S.Schema<CreateFlagSegmentResponseDataRulesItemConditionsList>;
+export interface CreateFlagSegmentResponseDataRulesItem {
+    id: string;
+    outcome: CreateFlagSegmentResponseDataRulesItemOutcome;
+    conditions: CreateFlagSegmentResponseDataRulesItemConditionsList;
+}
+export declare const CreateFlagSegmentResponseDataRulesItem: S.Schema<CreateFlagSegmentResponseDataRulesItem>;
+export type CreateFlagSegmentResponseDataRulesList = Array<CreateFlagSegmentResponseDataRulesItem>;
+export declare const CreateFlagSegmentResponseDataRulesList: S.Schema<CreateFlagSegmentResponseDataRulesList>;
+export type CreateFlagSegmentResponseDataIncludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const CreateFlagSegmentResponseDataIncludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagSegmentResponseDataIncludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagSegmentResponseDataIncludeValueValueList: S.Schema<CreateFlagSegmentResponseDataIncludeValueValueList>;
+export type CreateFlagSegmentResponseDataIncludeValueMap = {
+    [key: string]: CreateFlagSegmentResponseDataIncludeValueValueList | undefined;
+};
+export declare const CreateFlagSegmentResponseDataIncludeValueMap: S.Schema<CreateFlagSegmentResponseDataIncludeValueMap>;
+export type CreateFlagSegmentResponseDataIncludeMap = {
+    [key: string]: CreateFlagSegmentResponseDataIncludeValueMap | undefined;
+};
+export declare const CreateFlagSegmentResponseDataIncludeMap: S.Schema<CreateFlagSegmentResponseDataIncludeMap>;
+export type CreateFlagSegmentResponseDataExcludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const CreateFlagSegmentResponseDataExcludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type CreateFlagSegmentResponseDataExcludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const CreateFlagSegmentResponseDataExcludeValueValueList: S.Schema<CreateFlagSegmentResponseDataExcludeValueValueList>;
+export type CreateFlagSegmentResponseDataExcludeValueMap = {
+    [key: string]: CreateFlagSegmentResponseDataExcludeValueValueList | undefined;
+};
+export declare const CreateFlagSegmentResponseDataExcludeValueMap: S.Schema<CreateFlagSegmentResponseDataExcludeValueMap>;
+export type CreateFlagSegmentResponseDataExcludeMap = {
+    [key: string]: CreateFlagSegmentResponseDataExcludeValueMap | undefined;
+};
+export declare const CreateFlagSegmentResponseDataExcludeMap: S.Schema<CreateFlagSegmentResponseDataExcludeMap>;
+export interface CreateFlagSegmentResponseData {
+    rules?: CreateFlagSegmentResponseDataRulesList;
+    include?: CreateFlagSegmentResponseDataIncludeMap;
+    exclude?: CreateFlagSegmentResponseDataExcludeMap;
+}
+export declare const CreateFlagSegmentResponseData: S.Schema<CreateFlagSegmentResponseData>;
+export type CreateFlagSegmentResponseTypeName = "segment";
+export declare const CreateFlagSegmentResponseTypeName: any;
+export interface CreateFlagSegmentResponse {
+    description?: string;
+    createdBy?: string;
+    usedByFlags?: CreateFlagSegmentResponseUsedByFlagsList;
+    usedBySegments?: CreateFlagSegmentResponseUsedBySegmentsList;
+    data: CreateFlagSegmentResponseData;
+    id: string;
+    label: string;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    projectId: string;
+    typeName: CreateFlagSegmentResponseTypeName;
+    hint: string;
+}
+export declare const CreateFlagSegmentResponse: S.Schema<CreateFlagSegmentResponse>;
+export type CreateSdkKeyRequestSdkKeyType = "server" | "mobile" | "client";
+export declare const CreateSdkKeyRequestSdkKeyType: any;
+export interface CreateSdkKeyRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    sdkKeyType: CreateSdkKeyRequestSdkKeyType | (string & {});
+    environment: string;
+    label?: string;
+}
+export declare const CreateSdkKeyRequest: S.Schema<CreateSdkKeyRequest>;
+export type FlagsSdkKeyWithSecretsType = "client" | "mobile" | "server";
+export declare const FlagsSdkKeyWithSecretsType: any;
+/** Representation of a Flags SDK key returned by CREATE. Includes cleartext secrets (`keyValue`, `tokenValue`, `connectionString`) which are only ever disclosed once, on creation. */
+export interface FlagsSdkKeyWithSecrets {
+    hashKey: string;
+    projectId: string;
+    type: FlagsSdkKeyWithSecretsType;
+    environment: string;
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+    label?: string;
+    deletedAt?: number;
+    /** Partially-masked representation of the SDK key value, safe to display in UIs. The value is the `vf_<type>_` prefix followed by the first 3 characters of the secret portion and a fixed 8-character `*` mask (e.g. `vf_server_abc********`). */
+    partialKeyValue: string;
+    /** Cleartext value of the SDK key. */
+    keyValue: string;
+    /** Cleartext value of the Edge Config token, when the project has an Edge Config connection. */
+    tokenValue?: string;
+}
+export declare const FlagsSdkKeyWithSecrets: S.Schema<FlagsSdkKeyWithSecrets>;
+export interface DeleteFlagRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The flag id or name */
+    flagIdOrSlug: string;
+    /** Etag to match, can be used interchangeably with the `if-match` header */
+    ifMatch?: string;
+    /** Whether to include metadata in the response */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteFlagRequest: S.Schema<DeleteFlagRequest>;
+export interface DeleteFlagResponse {
+}
+export declare const DeleteFlagResponse: S.Schema<DeleteFlagResponse>;
+export interface DeleteFlagSegmentRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The segment slug */
+    segmentIdOrSlug: string;
+    /** Whether to include metadata */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteFlagSegmentRequest: S.Schema<DeleteFlagSegmentRequest>;
+export interface DeleteFlagSegmentResponse {
+}
+export declare const DeleteFlagSegmentResponse: S.Schema<DeleteFlagSegmentResponse>;
+export interface DeleteSdkKeyRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The SDK key hash key to delete */
+    hashKey: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteSdkKeyRequest: S.Schema<DeleteSdkKeyRequest>;
+export interface DeleteSdkKeyResponse {
+}
+export declare const DeleteSdkKeyResponse: S.Schema<DeleteSdkKeyResponse>;
+export interface GetDeploymentFeatureFlagsRequest {
+    deploymentId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetDeploymentFeatureFlagsRequest: S.Schema<GetDeploymentFeatureFlagsRequest>;
+export type GetDeploymentFeatureFlagsResponseFlagsList = Array<unknown>;
+export declare const GetDeploymentFeatureFlagsResponseFlagsList: S.Schema<GetDeploymentFeatureFlagsResponseFlagsList>;
+export interface GetDeploymentFeatureFlagsResponseStatus {
+    deploymentId: string;
+    projectId: string;
+    /** The HTTP status code from the flags discovery endpoint. */
+    responseStatus: number;
+    /** The number of flag definitions returned by the flags discovery endpoint. */
+    flagCount: number;
+    createdAt: number;
+}
+export declare const GetDeploymentFeatureFlagsResponseStatus: S.Schema<GetDeploymentFeatureFlagsResponseStatus>;
+export interface GetDeploymentFeatureFlagsResponse {
+    flags: GetDeploymentFeatureFlagsResponseFlagsList;
+    status: GetDeploymentFeatureFlagsResponseStatus | null;
+}
+export declare const GetDeploymentFeatureFlagsResponse: S.Schema<GetDeploymentFeatureFlagsResponse>;
+export interface GetFlagRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The flag id or name */
+    flagIdOrSlug: string;
+    /** Etag to match, can be used interchangeably with the `if-match` header */
+    ifMatch?: string;
+    /** Whether to include metadata in the response */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetFlagRequest: S.Schema<GetFlagRequest>;
+export type FlagMaintainerIdsList = Array<string>;
+export declare const FlagMaintainerIdsList: S.Schema<FlagMaintainerIdsList>;
+export type FlagTagsList = Array<string>;
+export declare const FlagTagsList: S.Schema<FlagTagsList>;
+export type FlagExperimentGuardrailMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const FlagExperimentGuardrailMetricsItemMetricType: any;
+export type FlagExperimentGuardrailMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const FlagExperimentGuardrailMetricsItemMetricUnit: any;
+export type FlagExperimentGuardrailMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const FlagExperimentGuardrailMetricsItemDirectionality: any;
+export interface FlagExperimentGuardrailMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: FlagExperimentGuardrailMetricsItemMetricType;
+    metricUnit: FlagExperimentGuardrailMetricsItemMetricUnit;
+    directionality: FlagExperimentGuardrailMetricsItemDirectionality;
+}
+export declare const FlagExperimentGuardrailMetricsItem: S.Schema<FlagExperimentGuardrailMetricsItem>;
+export type FlagExperimentGuardrailMetricsList = Array<FlagExperimentGuardrailMetricsItem>;
+export declare const FlagExperimentGuardrailMetricsList: S.Schema<FlagExperimentGuardrailMetricsList>;
+export type FlagExperimentDevice = "android" | "desktop" | "ios" | "mweb";
+export declare const FlagExperimentDevice: any;
+export type FlagExperimentDurationUnit = "days" | "exposures";
+export declare const FlagExperimentDurationUnit: any;
+export type FlagExperimentAllocationUnit = "cookieId" | "userId" | "visitorId";
+export declare const FlagExperimentAllocationUnit: any;
+export type FlagExperimentPrimaryMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const FlagExperimentPrimaryMetricsItemMetricType: any;
+export type FlagExperimentPrimaryMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const FlagExperimentPrimaryMetricsItemMetricUnit: any;
+export type FlagExperimentPrimaryMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const FlagExperimentPrimaryMetricsItemDirectionality: any;
+export interface FlagExperimentPrimaryMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: FlagExperimentPrimaryMetricsItemMetricType;
+    metricUnit: FlagExperimentPrimaryMetricsItemMetricUnit;
+    directionality: FlagExperimentPrimaryMetricsItemDirectionality;
+}
+export declare const FlagExperimentPrimaryMetricsItem: S.Schema<FlagExperimentPrimaryMetricsItem>;
+export type FlagExperimentPrimaryMetricsList = Array<FlagExperimentPrimaryMetricsItem>;
+export declare const FlagExperimentPrimaryMetricsList: S.Schema<FlagExperimentPrimaryMetricsList>;
+export type FlagExperimentStatus = "closed" | "draft" | "paused" | "running";
+export declare const FlagExperimentStatus: any;
+export interface FlagExperiment {
+    id?: string;
+    name?: string;
+    numVariants?: number;
+    surfaceArea?: string;
+    stickyRequirement?: boolean;
+    layer?: string;
+    guardrailMetrics?: FlagExperimentGuardrailMetricsList;
+    hypothesis?: string;
+    device?: FlagExperimentDevice;
+    controlVariantId?: string;
+    startedAt?: number;
+    endedAt?: number;
+    decision?: string;
+    decisionReason?: string;
+    duration?: number;
+    durationUnit?: FlagExperimentDurationUnit;
+    allocationPercent?: number;
+    allocationUnit: FlagExperimentAllocationUnit;
+    primaryMetrics: FlagExperimentPrimaryMetricsList;
+    status: FlagExperimentStatus;
+}
+export declare const FlagExperiment: S.Schema<FlagExperiment>;
+export type FlagVariantsList = Array<unknown>;
+export declare const FlagVariantsList: S.Schema<FlagVariantsList>;
+export type FlagEnvironmentsValueReuse = CreateFlagResponseEnvironmentsValueReuse;
+export declare const FlagEnvironmentsValueReuse: S.Schema<CreateFlagResponseEnvironmentsValueReuse>;
+export type FlagEnvironmentsValueTargetsValueValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const FlagEnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type FlagEnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const FlagEnvironmentsValueTargetsValueValueValueList: S.Schema<FlagEnvironmentsValueTargetsValueValueValueList>;
+export type FlagEnvironmentsValueTargetsValueValueMap = {
+    [key: string]: FlagEnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const FlagEnvironmentsValueTargetsValueValueMap: S.Schema<FlagEnvironmentsValueTargetsValueValueMap>;
+export type FlagEnvironmentsValueTargetsValueMap = {
+    [key: string]: FlagEnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const FlagEnvironmentsValueTargetsValueMap: S.Schema<FlagEnvironmentsValueTargetsValueMap>;
+export type FlagEnvironmentsValueTargetsMap = {
+    [key: string]: FlagEnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const FlagEnvironmentsValueTargetsMap: S.Schema<FlagEnvironmentsValueTargetsMap>;
+export type FlagEnvironmentsValuePausedOutcomeType = "variant";
+export declare const FlagEnvironmentsValuePausedOutcomeType: any;
+export interface FlagEnvironmentsValuePausedOutcome {
+    type: FlagEnvironmentsValuePausedOutcomeType;
+    variantId: string;
+}
+export declare const FlagEnvironmentsValuePausedOutcome: S.Schema<FlagEnvironmentsValuePausedOutcome>;
+export type FlagEnvironmentsValueFallthroughCase0Type = "variant";
+export declare const FlagEnvironmentsValueFallthroughCase0Type: any;
+export interface FlagEnvironmentsValueFallthroughCase0 {
+    type: FlagEnvironmentsValueFallthroughCase0Type;
+    variantId: string;
+}
+export declare const FlagEnvironmentsValueFallthroughCase0: S.Schema<FlagEnvironmentsValueFallthroughCase0>;
+export type FlagEnvironmentsValueFallthroughCase1Type = "split";
+export declare const FlagEnvironmentsValueFallthroughCase1Type: any;
+export type FlagEnvironmentsValueFallthroughCase1BaseType = "entity";
+export declare const FlagEnvironmentsValueFallthroughCase1BaseType: any;
+export interface FlagEnvironmentsValueFallthroughCase1Base {
+    type: FlagEnvironmentsValueFallthroughCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const FlagEnvironmentsValueFallthroughCase1Base: S.Schema<FlagEnvironmentsValueFallthroughCase1Base>;
+export type FlagEnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const FlagEnvironmentsValueFallthroughCase1WeightsMap: S.Schema<FlagEnvironmentsValueFallthroughCase1WeightsMap>;
+export interface FlagEnvironmentsValueFallthroughCase1 {
+    type: FlagEnvironmentsValueFallthroughCase1Type;
+    base: FlagEnvironmentsValueFallthroughCase1Base;
+    weights: FlagEnvironmentsValueFallthroughCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const FlagEnvironmentsValueFallthroughCase1: S.Schema<FlagEnvironmentsValueFallthroughCase1>;
+export type FlagEnvironmentsValueFallthroughCase2Type = "rollout";
+export declare const FlagEnvironmentsValueFallthroughCase2Type: any;
+export type FlagEnvironmentsValueFallthroughCase2BaseType = "entity";
+export declare const FlagEnvironmentsValueFallthroughCase2BaseType: any;
+export interface FlagEnvironmentsValueFallthroughCase2Base {
+    type: FlagEnvironmentsValueFallthroughCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const FlagEnvironmentsValueFallthroughCase2Base: S.Schema<FlagEnvironmentsValueFallthroughCase2Base>;
+export type FlagEnvironmentsValueFallthroughCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const FlagEnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type FlagEnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const FlagEnvironmentsValueFallthroughCase2SlotsList: S.Schema<FlagEnvironmentsValueFallthroughCase2SlotsList>;
+export interface FlagEnvironmentsValueFallthroughCase2 {
+    type: FlagEnvironmentsValueFallthroughCase2Type;
+    base: FlagEnvironmentsValueFallthroughCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: FlagEnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const FlagEnvironmentsValueFallthroughCase2: S.Schema<FlagEnvironmentsValueFallthroughCase2>;
+export type FlagEnvironmentsValueFallthrough = FlagEnvironmentsValueFallthroughCase0 | FlagEnvironmentsValueFallthroughCase1 | FlagEnvironmentsValueFallthroughCase2;
+export declare const FlagEnvironmentsValueFallthrough: S.Schema<FlagEnvironmentsValueFallthrough>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase0Type = "variant";
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase0Type: any;
+export interface FlagEnvironmentsValueRulesItemOutcomeCase0 {
+    type: FlagEnvironmentsValueRulesItemOutcomeCase0Type;
+    variantId: string;
+}
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase0: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase0>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase1Type = "split";
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase1Type: any;
+export type FlagEnvironmentsValueRulesItemOutcomeCase1BaseType = "entity";
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase1BaseType: any;
+export interface FlagEnvironmentsValueRulesItemOutcomeCase1Base {
+    type: FlagEnvironmentsValueRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase1Base>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface FlagEnvironmentsValueRulesItemOutcomeCase1 {
+    type: FlagEnvironmentsValueRulesItemOutcomeCase1Type;
+    base: FlagEnvironmentsValueRulesItemOutcomeCase1Base;
+    weights: FlagEnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase1: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase1>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase2Type = "rollout";
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2Type: any;
+export type FlagEnvironmentsValueRulesItemOutcomeCase2BaseType = "entity";
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2BaseType: any;
+export interface FlagEnvironmentsValueRulesItemOutcomeCase2Base {
+    type: FlagEnvironmentsValueRulesItemOutcomeCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase2Base>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type FlagEnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface FlagEnvironmentsValueRulesItemOutcomeCase2 {
+    type: FlagEnvironmentsValueRulesItemOutcomeCase2Type;
+    base: FlagEnvironmentsValueRulesItemOutcomeCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: FlagEnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const FlagEnvironmentsValueRulesItemOutcomeCase2: S.Schema<FlagEnvironmentsValueRulesItemOutcomeCase2>;
+export type FlagEnvironmentsValueRulesItemOutcome = FlagEnvironmentsValueRulesItemOutcomeCase0 | FlagEnvironmentsValueRulesItemOutcomeCase1 | FlagEnvironmentsValueRulesItemOutcomeCase2;
+export declare const FlagEnvironmentsValueRulesItemOutcome: S.Schema<FlagEnvironmentsValueRulesItemOutcome>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2Type: any;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList = Array<FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList>;
+export interface FlagEnvironmentsValueRulesItemConditionsItemRhsCase2 {
+    type: FlagEnvironmentsValueRulesItemConditionsItemRhsCase2Type;
+    items: FlagEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase2: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemRhsCase2>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase3Type: any;
+export interface FlagEnvironmentsValueRulesItemConditionsItemRhsCase3 {
+    type: FlagEnvironmentsValueRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhsCase3: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemRhsCase3>;
+export type FlagEnvironmentsValueRulesItemConditionsItemRhs = string | number | FlagEnvironmentsValueRulesItemConditionsItemRhsCase2 | FlagEnvironmentsValueRulesItemConditionsItemRhsCase3 | boolean;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemRhs: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemRhs>;
+export type FlagEnvironmentsValueRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type FlagEnvironmentsValueRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const FlagEnvironmentsValueRulesItemConditionsItemLhsCase0Type: any;
+export interface FlagEnvironmentsValueRulesItemConditionsItemLhsCase0 {
+    type: FlagEnvironmentsValueRulesItemConditionsItemLhsCase0Type;
+}
+export declare const FlagEnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type FlagEnvironmentsValueRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const FlagEnvironmentsValueRulesItemConditionsItemLhsCase1Type: any;
+export interface FlagEnvironmentsValueRulesItemConditionsItemLhsCase1 {
+    type: FlagEnvironmentsValueRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const FlagEnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type FlagEnvironmentsValueRulesItemConditionsItemLhs = FlagEnvironmentsValueRulesItemConditionsItemLhsCase0 | FlagEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const FlagEnvironmentsValueRulesItemConditionsItemLhs: S.Schema<FlagEnvironmentsValueRulesItemConditionsItemLhs>;
+export type FlagEnvironmentsValueRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const FlagEnvironmentsValueRulesItemConditionsItemCmp: any;
+export interface FlagEnvironmentsValueRulesItemConditionsItem {
+    rhs?: FlagEnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: FlagEnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: FlagEnvironmentsValueRulesItemConditionsItemCmp;
+}
+export declare const FlagEnvironmentsValueRulesItemConditionsItem: S.Schema<FlagEnvironmentsValueRulesItemConditionsItem>;
+export type FlagEnvironmentsValueRulesItemConditionsList = Array<FlagEnvironmentsValueRulesItemConditionsItem>;
+export declare const FlagEnvironmentsValueRulesItemConditionsList: S.Schema<FlagEnvironmentsValueRulesItemConditionsList>;
+export interface FlagEnvironmentsValueRulesItem {
+    id: string;
+    outcome: FlagEnvironmentsValueRulesItemOutcome;
+    conditions: FlagEnvironmentsValueRulesItemConditionsList;
+}
+export declare const FlagEnvironmentsValueRulesItem: S.Schema<FlagEnvironmentsValueRulesItem>;
+export type FlagEnvironmentsValueRulesList = Array<FlagEnvironmentsValueRulesItem>;
+export declare const FlagEnvironmentsValueRulesList: S.Schema<FlagEnvironmentsValueRulesList>;
+export interface FlagEnvironmentsValue {
+    reuse?: CreateFlagResponseEnvironmentsValueReuse;
+    targets?: FlagEnvironmentsValueTargetsMap;
+    revision?: number;
+    pausedOutcome: FlagEnvironmentsValuePausedOutcome;
+    fallthrough: FlagEnvironmentsValueFallthrough;
+    active: boolean;
+    rules: FlagEnvironmentsValueRulesList;
+}
+export declare const FlagEnvironmentsValue: S.Schema<FlagEnvironmentsValue>;
+export type FlagEnvironmentsMap = {
+    [key: string]: FlagEnvironmentsValue | undefined;
+};
+export declare const FlagEnvironmentsMap: S.Schema<FlagEnvironmentsMap>;
+export type FlagKind = "boolean" | "json" | "number" | "string";
+export declare const FlagKind: any;
+export type FlagState = "active" | "archived";
+export declare const FlagState: any;
+export type FlagTypeName = "flag";
+export declare const FlagTypeName: any;
+export interface FlagMetadataCreator {
+    id: string;
+    name: string;
+}
+export declare const FlagMetadataCreator: S.Schema<FlagMetadataCreator>;
+export interface FlagMetadata {
+    creator?: FlagMetadataCreator;
+}
+export declare const FlagMetadata: S.Schema<FlagMetadata>;
+export interface Flag {
+    description?: string;
+    maintainerIds?: FlagMaintainerIdsList;
+    permanent?: boolean;
+    tags?: FlagTagsList;
+    experiment?: FlagExperiment;
+    updatedBy?: string;
+    variants: FlagVariantsList;
+    id: string;
+    environments: FlagEnvironmentsMap;
+    kind: FlagKind;
+    revision: number;
+    seed: number;
+    state: FlagState;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    ownerId: string;
+    projectId: string;
+    typeName: FlagTypeName;
+    metadata?: FlagMetadata;
+}
+export declare const Flag: S.Schema<Flag>;
+export interface GetFlagSegmentRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The segment slug */
+    segmentIdOrSlug: string;
+    /** Whether to include metadata */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetFlagSegmentRequest: S.Schema<GetFlagSegmentRequest>;
+export type SegmentUsedByFlagsList = Array<string>;
+export declare const SegmentUsedByFlagsList: S.Schema<SegmentUsedByFlagsList>;
+export type SegmentUsedBySegmentsList = Array<string>;
+export declare const SegmentUsedBySegmentsList: S.Schema<SegmentUsedBySegmentsList>;
+export type SegmentDataRulesItemOutcomeCase0Type = "all";
+export declare const SegmentDataRulesItemOutcomeCase0Type: any;
+export interface SegmentDataRulesItemOutcomeCase0 {
+    type: SegmentDataRulesItemOutcomeCase0Type;
+}
+export declare const SegmentDataRulesItemOutcomeCase0: S.Schema<SegmentDataRulesItemOutcomeCase0>;
+export type SegmentDataRulesItemOutcomeCase1Type = "split";
+export declare const SegmentDataRulesItemOutcomeCase1Type: any;
+export type SegmentDataRulesItemOutcomeCase1BaseType = "entity";
+export declare const SegmentDataRulesItemOutcomeCase1BaseType: any;
+export interface SegmentDataRulesItemOutcomeCase1Base {
+    type: SegmentDataRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const SegmentDataRulesItemOutcomeCase1Base: S.Schema<SegmentDataRulesItemOutcomeCase1Base>;
+export interface SegmentDataRulesItemOutcomeCase1 {
+    type: SegmentDataRulesItemOutcomeCase1Type;
+    base: SegmentDataRulesItemOutcomeCase1Base;
+    passPromille: number;
+}
+export declare const SegmentDataRulesItemOutcomeCase1: S.Schema<SegmentDataRulesItemOutcomeCase1>;
+export type SegmentDataRulesItemOutcome = SegmentDataRulesItemOutcomeCase0 | SegmentDataRulesItemOutcomeCase1;
+export declare const SegmentDataRulesItemOutcome: S.Schema<SegmentDataRulesItemOutcome>;
+export type SegmentDataRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const SegmentDataRulesItemConditionsItemRhsCase2Type: any;
+export type SegmentDataRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const SegmentDataRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type SegmentDataRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const SegmentDataRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type SegmentDataRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const SegmentDataRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<SegmentDataRulesItemConditionsItemRhsCase2ItemsItem>;
+export type SegmentDataRulesItemConditionsItemRhsCase2ItemsList = Array<SegmentDataRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const SegmentDataRulesItemConditionsItemRhsCase2ItemsList: S.Schema<SegmentDataRulesItemConditionsItemRhsCase2ItemsList>;
+export interface SegmentDataRulesItemConditionsItemRhsCase2 {
+    type: SegmentDataRulesItemConditionsItemRhsCase2Type;
+    items: SegmentDataRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const SegmentDataRulesItemConditionsItemRhsCase2: S.Schema<SegmentDataRulesItemConditionsItemRhsCase2>;
+export type SegmentDataRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const SegmentDataRulesItemConditionsItemRhsCase3Type: any;
+export interface SegmentDataRulesItemConditionsItemRhsCase3 {
+    type: SegmentDataRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const SegmentDataRulesItemConditionsItemRhsCase3: S.Schema<SegmentDataRulesItemConditionsItemRhsCase3>;
+export type SegmentDataRulesItemConditionsItemRhs = string | number | SegmentDataRulesItemConditionsItemRhsCase2 | SegmentDataRulesItemConditionsItemRhsCase3 | boolean;
+export declare const SegmentDataRulesItemConditionsItemRhs: S.Schema<SegmentDataRulesItemConditionsItemRhs>;
+export type SegmentDataRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const SegmentDataRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type SegmentDataRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const SegmentDataRulesItemConditionsItemLhsCase0Type: any;
+export interface SegmentDataRulesItemConditionsItemLhsCase0 {
+    type: SegmentDataRulesItemConditionsItemLhsCase0Type;
+}
+export declare const SegmentDataRulesItemConditionsItemLhsCase0: S.Schema<SegmentDataRulesItemConditionsItemLhsCase0>;
+export type SegmentDataRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const SegmentDataRulesItemConditionsItemLhsCase1Type: any;
+export interface SegmentDataRulesItemConditionsItemLhsCase1 {
+    type: SegmentDataRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const SegmentDataRulesItemConditionsItemLhsCase1: S.Schema<SegmentDataRulesItemConditionsItemLhsCase1>;
+export type SegmentDataRulesItemConditionsItemLhs = SegmentDataRulesItemConditionsItemLhsCase0 | SegmentDataRulesItemConditionsItemLhsCase1;
+export declare const SegmentDataRulesItemConditionsItemLhs: S.Schema<SegmentDataRulesItemConditionsItemLhs>;
+export type SegmentDataRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const SegmentDataRulesItemConditionsItemCmp: any;
+export interface SegmentDataRulesItemConditionsItem {
+    rhs?: SegmentDataRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: SegmentDataRulesItemConditionsItemLhs;
+    cmp: SegmentDataRulesItemConditionsItemCmp;
+}
+export declare const SegmentDataRulesItemConditionsItem: S.Schema<SegmentDataRulesItemConditionsItem>;
+export type SegmentDataRulesItemConditionsList = Array<SegmentDataRulesItemConditionsItem>;
+export declare const SegmentDataRulesItemConditionsList: S.Schema<SegmentDataRulesItemConditionsList>;
+export interface SegmentDataRulesItem {
+    id: string;
+    outcome: SegmentDataRulesItemOutcome;
+    conditions: SegmentDataRulesItemConditionsList;
+}
+export declare const SegmentDataRulesItem: S.Schema<SegmentDataRulesItem>;
+export type SegmentDataRulesList = Array<SegmentDataRulesItem>;
+export declare const SegmentDataRulesList: S.Schema<SegmentDataRulesList>;
+export type SegmentDataIncludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const SegmentDataIncludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type SegmentDataIncludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const SegmentDataIncludeValueValueList: S.Schema<SegmentDataIncludeValueValueList>;
+export type SegmentDataIncludeValueMap = {
+    [key: string]: SegmentDataIncludeValueValueList | undefined;
+};
+export declare const SegmentDataIncludeValueMap: S.Schema<SegmentDataIncludeValueMap>;
+export type SegmentDataIncludeMap = {
+    [key: string]: SegmentDataIncludeValueMap | undefined;
+};
+export declare const SegmentDataIncludeMap: S.Schema<SegmentDataIncludeMap>;
+export type SegmentDataExcludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const SegmentDataExcludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type SegmentDataExcludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const SegmentDataExcludeValueValueList: S.Schema<SegmentDataExcludeValueValueList>;
+export type SegmentDataExcludeValueMap = {
+    [key: string]: SegmentDataExcludeValueValueList | undefined;
+};
+export declare const SegmentDataExcludeValueMap: S.Schema<SegmentDataExcludeValueMap>;
+export type SegmentDataExcludeMap = {
+    [key: string]: SegmentDataExcludeValueMap | undefined;
+};
+export declare const SegmentDataExcludeMap: S.Schema<SegmentDataExcludeMap>;
+export interface SegmentData {
+    rules?: SegmentDataRulesList;
+    include?: SegmentDataIncludeMap;
+    exclude?: SegmentDataExcludeMap;
+}
+export declare const SegmentData: S.Schema<SegmentData>;
+export type SegmentTypeName = "segment";
+export declare const SegmentTypeName: any;
+export type SegmentMetadataCreator = FlagMetadataCreator;
+export declare const SegmentMetadataCreator: S.Schema<FlagMetadataCreator>;
+export type SegmentMetadata = FlagMetadata;
+export declare const SegmentMetadata: S.Schema<FlagMetadata>;
+export interface Segment {
+    description?: string;
+    createdBy?: string;
+    usedByFlags?: SegmentUsedByFlagsList;
+    usedBySegments?: SegmentUsedBySegmentsList;
+    data: SegmentData;
+    id: string;
+    label: string;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    projectId: string;
+    typeName: SegmentTypeName;
+    hint: string;
+    metadata?: FlagMetadata;
+}
+export declare const Segment: S.Schema<Segment>;
+export interface GetFlagSettingsRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetFlagSettingsRequest: S.Schema<GetFlagSettingsRequest>;
+export type GetFlagSettingsResponseTypeName = "settings";
+export declare const GetFlagSettingsResponseTypeName: any;
+export type GetFlagSettingsResponseEnvironmentsList = Array<string>;
+export declare const GetFlagSettingsResponseEnvironmentsList: S.Schema<GetFlagSettingsResponseEnvironmentsList>;
+export interface GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem {
+    label: string;
+    value: string;
+}
+export declare const GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export type GetFlagSettingsResponseEntitiesItemAttributesItemLabelsList = Array<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export declare const GetFlagSettingsResponseEntitiesItemAttributesItemLabelsList: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsList>;
+export interface GetFlagSettingsResponseEntitiesItemAttributesItem {
+    key: string;
+    type: string;
+    labels?: GetFlagSettingsResponseEntitiesItemAttributesItemLabelsList;
+}
+export declare const GetFlagSettingsResponseEntitiesItemAttributesItem: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItem>;
+export type GetFlagSettingsResponseEntitiesItemAttributesList = Array<GetFlagSettingsResponseEntitiesItemAttributesItem>;
+export declare const GetFlagSettingsResponseEntitiesItemAttributesList: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesList>;
+export interface GetFlagSettingsResponseEntitiesItem {
+    kind: string;
+    label: string;
+    attributes: GetFlagSettingsResponseEntitiesItemAttributesList;
+}
+export declare const GetFlagSettingsResponseEntitiesItem: S.Schema<GetFlagSettingsResponseEntitiesItem>;
+export type GetFlagSettingsResponseEntitiesList = Array<GetFlagSettingsResponseEntitiesItem>;
+export declare const GetFlagSettingsResponseEntitiesList: S.Schema<GetFlagSettingsResponseEntitiesList>;
+export interface GetFlagSettingsResponseMetadata {
+    activeFlagCount: number;
+    archivedFlagCount: number;
+    segmentCount: number;
+    packSizeInBytes: number;
+    packRevision?: number;
+    configUpdatedAt?: number;
+}
+export declare const GetFlagSettingsResponseMetadata: S.Schema<GetFlagSettingsResponseMetadata>;
+export interface GetFlagSettingsResponse {
+    typeName: GetFlagSettingsResponseTypeName;
+    projectId: string;
+    ownerId?: string;
+    enabled: boolean;
+    environments: GetFlagSettingsResponseEnvironmentsList;
+    entities: GetFlagSettingsResponseEntitiesList;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata: GetFlagSettingsResponseMetadata;
+}
+export declare const GetFlagSettingsResponse: S.Schema<GetFlagSettingsResponse>;
+export interface GetSdkKeysRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetSdkKeysRequest: S.Schema<GetSdkKeysRequest>;
+export type GetSdkKeysResponseDataItemType = "client" | "mobile" | "server";
+export declare const GetSdkKeysResponseDataItemType: any;
+/** Shared metadata for a Flags SDK key, safe to return on both LIST and CREATE. Never contains cleartext secrets. */
+export interface GetSdkKeysResponseDataItem {
+    hashKey: string;
+    projectId: string;
+    type: GetSdkKeysResponseDataItemType;
+    environment: string;
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+    label?: string;
+    deletedAt?: number;
+    /** Partially-masked representation of the SDK key value, safe to display in UIs. The value is the `vf_<type>_` prefix followed by the first 3 characters of the secret portion and a fixed 8-character `*` mask (e.g. `vf_server_abc********`). */
+    partialKeyValue: string;
+}
+export declare const GetSdkKeysResponseDataItem: S.Schema<GetSdkKeysResponseDataItem>;
+export type GetSdkKeysResponseDataList = Array<GetSdkKeysResponseDataItem>;
+export declare const GetSdkKeysResponseDataList: S.Schema<GetSdkKeysResponseDataList>;
+export interface GetSdkKeysResponse {
+    data: GetSdkKeysResponseDataList;
+}
+export declare const GetSdkKeysResponse: S.Schema<GetSdkKeysResponse>;
+/** The state of the flags to retrieve. Defaults to `active`. */
+export type ListFlagsRequestState = "active" | "archived";
+export declare const ListFlagsRequestState: any;
+/** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+export type ListFlagsRequestTagsList = Array<string>;
+export declare const ListFlagsRequestTagsList: S.Schema<ListFlagsRequestTagsList>;
+export interface ListFlagsRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The state of the flags to retrieve. Defaults to `active`. */
+    state?: ListFlagsRequestState | (string & {});
+    /** Deprecated. Whether to include creator metadata in each flag in the response. Resolve creator identity client-side (e.g. via the team members endpoint) instead; this parameter will be removed in a future release. Use `GET /v1/projects/:id/feature-flags/flags/:flagIdOrSlug?withMetadata=true` for single-flag lookups that need creator metadata. */
+    withMetadata?: boolean;
+    /** Maximum number of flags to return. When not set, all flags are returned. */
+    limit?: number;
+    /** Pagination cursor to continue from. */
+    cursor?: string;
+    /** Search flags by their slug or description. Case-insensitive. */
+    search?: string;
+    /** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+    tags?: ListFlagsRequestTagsList;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListFlagsRequest: S.Schema<ListFlagsRequest>;
+export type ListFlagsResponseDataList = Array<Flag>;
+export declare const ListFlagsResponseDataList: S.Schema<ListFlagsResponseDataList>;
+export interface ListFlagsResponsePagination {
+    next: string | null;
+}
+export declare const ListFlagsResponsePagination: S.Schema<ListFlagsResponsePagination>;
+export interface ListFlagsResponse {
+    data: ListFlagsResponseDataList;
+    pagination: ListFlagsResponsePagination;
+}
+export declare const ListFlagsResponse: S.Schema<ListFlagsResponse>;
+export interface ListFlagSegmentsRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** Whether to include metadata */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListFlagSegmentsRequest: S.Schema<ListFlagSegmentsRequest>;
+export type ListFlagSegmentsResponseDataList = Array<Segment>;
+export declare const ListFlagSegmentsResponseDataList: S.Schema<ListFlagSegmentsResponseDataList>;
+export interface ListFlagSegmentsResponse {
+    data: ListFlagSegmentsResponseDataList;
+}
+export declare const ListFlagSegmentsResponse: S.Schema<ListFlagSegmentsResponse>;
+/** The state of the flags to retrieve. Defaults to `active`. */
+export type ListFlagsV2RequestState = "active" | "archived";
+export declare const ListFlagsV2RequestState: any;
+/** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+export type ListFlagsV2RequestTagsList = Array<string>;
+export declare const ListFlagsV2RequestTagsList: S.Schema<ListFlagsV2RequestTagsList>;
+/** Filter flags by maintainer user id. Repeat the parameter for multiple maintainers (any may match). */
+export type ListFlagsV2RequestMaintainerIdsList = Array<string>;
+export declare const ListFlagsV2RequestMaintainerIdsList: S.Schema<ListFlagsV2RequestMaintainerIdsList>;
+export interface ListFlagsV2Request {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The state of the flags to retrieve. Defaults to `active`. */
+    state?: ListFlagsV2RequestState | (string & {});
+    /** Maximum number of flags to return. */
+    limit?: number;
+    /** Pagination cursor to continue from. */
+    cursor?: string;
+    /** Search flags by their slug or description. Case-insensitive. */
+    search?: string;
+    /** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+    tags?: ListFlagsV2RequestTagsList;
+    /** Filter flags by the id of the entity that created them (a user or team id). */
+    createdBy?: string;
+    /** Filter flags by maintainer user id. Repeat the parameter for multiple maintainers (any may match). */
+    maintainerIds?: ListFlagsV2RequestMaintainerIdsList;
+    /** Whether to include Marketplace experimentation items in the paginated response. Defaults to false. */
+    includeMarketplaceFlags?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListFlagsV2Request: S.Schema<ListFlagsV2Request>;
+export type ListFlagsV2ResponsePagination = ListFlagsResponsePagination;
+export declare const ListFlagsV2ResponsePagination: S.Schema<ListFlagsResponsePagination>;
+export type MarketplaceFlagTypeName = "marketplaceFlag";
+export declare const MarketplaceFlagTypeName: any;
+export type MarketplaceFlagState = "active" | "archived";
+export declare const MarketplaceFlagState: any;
+export type MarketplaceFlagCategory = "experiment" | "flag";
+export declare const MarketplaceFlagCategory: any;
+export interface MarketplaceFlag {
+    typeName: MarketplaceFlagTypeName;
+    id: string;
+    externalId: string;
+    slug: string;
+    origin: string;
+    ownerId: string;
+    projectId: string;
+    resourceId: string;
+    integrationConfigurationId: string;
+    state: MarketplaceFlagState;
+    name?: string;
+    description?: string;
+    category?: MarketplaceFlagCategory;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export declare const MarketplaceFlag: S.Schema<MarketplaceFlag>;
+export type ListFlagsV2ResponseDataItem = Flag | MarketplaceFlag;
+export declare const ListFlagsV2ResponseDataItem: S.Schema<ListFlagsV2ResponseDataItem>;
+export type ListFlagsV2ResponseDataList = Array<ListFlagsV2ResponseDataItem>;
+export declare const ListFlagsV2ResponseDataList: S.Schema<ListFlagsV2ResponseDataList>;
+export interface ListFlagsV2Response {
+    pagination: ListFlagsResponsePagination;
+    data: ListFlagsV2ResponseDataList;
+}
+export declare const ListFlagsV2Response: S.Schema<ListFlagsV2Response>;
+export interface ListFlagVersionsRequest {
+    projectIdOrName: string;
+    flagIdOrSlug: string;
+    limit?: number;
+    /** Pagination cursor */
+    cursor?: string;
+    /** Environment to filter by */
+    environment?: string;
+    /** Whether to include metadata */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListFlagVersionsRequest: S.Schema<ListFlagVersionsRequest>;
+export type ListFlagVersionsResponseVersionsItemDataMaintainerIdsList = Array<string>;
+export declare const ListFlagVersionsResponseVersionsItemDataMaintainerIdsList: S.Schema<ListFlagVersionsResponseVersionsItemDataMaintainerIdsList>;
+export type ListFlagVersionsResponseVersionsItemDataTagsList = Array<string>;
+export declare const ListFlagVersionsResponseVersionsItemDataTagsList: S.Schema<ListFlagVersionsResponseVersionsItemDataTagsList>;
+export type ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricType: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricUnit: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemDirectionality: any;
+export interface ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricType;
+    metricUnit: ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemMetricUnit;
+    directionality: ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItemDirectionality;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItem: S.Schema<ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItem>;
+export type ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsList = Array<ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsList: S.Schema<ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsList>;
+export type ListFlagVersionsResponseVersionsItemDataExperimentDevice = "android" | "desktop" | "ios" | "mweb";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentDevice: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentDurationUnit = "days" | "exposures";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentDurationUnit: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentAllocationUnit = "cookieId" | "userId" | "visitorId";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentAllocationUnit: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricType: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricUnit: any;
+export type ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemDirectionality: any;
+export interface ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricType;
+    metricUnit: ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemMetricUnit;
+    directionality: ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItemDirectionality;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItem: S.Schema<ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItem>;
+export type ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsList = Array<ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsList: S.Schema<ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsList>;
+export type ListFlagVersionsResponseVersionsItemDataExperimentStatus = "closed" | "draft" | "paused" | "running";
+export declare const ListFlagVersionsResponseVersionsItemDataExperimentStatus: any;
+export interface ListFlagVersionsResponseVersionsItemDataExperiment {
+    id?: string;
+    name?: string;
+    numVariants?: number;
+    surfaceArea?: string;
+    stickyRequirement?: boolean;
+    layer?: string;
+    guardrailMetrics?: ListFlagVersionsResponseVersionsItemDataExperimentGuardrailMetricsList;
+    hypothesis?: string;
+    device?: ListFlagVersionsResponseVersionsItemDataExperimentDevice;
+    controlVariantId?: string;
+    startedAt?: number;
+    endedAt?: number;
+    decision?: string;
+    decisionReason?: string;
+    duration?: number;
+    durationUnit?: ListFlagVersionsResponseVersionsItemDataExperimentDurationUnit;
+    allocationPercent?: number;
+    allocationUnit: ListFlagVersionsResponseVersionsItemDataExperimentAllocationUnit;
+    primaryMetrics: ListFlagVersionsResponseVersionsItemDataExperimentPrimaryMetricsList;
+    status: ListFlagVersionsResponseVersionsItemDataExperimentStatus;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataExperiment: S.Schema<ListFlagVersionsResponseVersionsItemDataExperiment>;
+export type ListFlagVersionsResponseVersionsItemDataVariantsList = Array<unknown>;
+export declare const ListFlagVersionsResponseVersionsItemDataVariantsList: S.Schema<ListFlagVersionsResponseVersionsItemDataVariantsList>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueReuse = CreateFlagResponseEnvironmentsValueReuse;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueReuse: S.Schema<CreateFlagResponseEnvironmentsValueReuse>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueList>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueMap = {
+    [key: string]: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueMap>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueMap = {
+    [key: string]: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueMap>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsMap = {
+    [key: string]: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsMap>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcomeType = "variant";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcomeType: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcome {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcomeType;
+    variantId: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcome: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcome>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0Type = "variant";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0Type: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0Type;
+    variantId: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Type = "split";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Type: any;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1BaseType = "entity";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1BaseType: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Base {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Base: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Base>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1WeightsMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1WeightsMap>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Type;
+    base: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1Base;
+    weights: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Type = "rollout";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Type: any;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2BaseType = "entity";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2BaseType: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Base {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Base: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Base>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsList>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Type;
+    base: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthrough = ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase0 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase1 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthroughCase2;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthrough: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthrough>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0Type = "variant";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0Type: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0Type;
+    variantId: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Type = "split";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Type: any;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1BaseType = "entity";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1BaseType: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Base {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Base>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Type;
+    base: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1Base;
+    weights: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Type = "rollout";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Type: any;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2BaseType = "entity";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2BaseType: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Base {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Base>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Type;
+    base: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcome = ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase0 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase1 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcomeCase2;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcome: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcome>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2Type: any;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList = Array<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2Type;
+    items: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3Type: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhs = string | number | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase2 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhsCase3 | boolean;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhs: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhs>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0Type: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0Type;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1Type: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1 {
+    type: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhs = ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase0 | ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhs: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhs>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemCmp: any;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItem {
+    rhs?: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItemCmp;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItem: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsList = Array<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsList>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItem {
+    id: string;
+    outcome: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemOutcome;
+    conditions: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItemConditionsList;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItem: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItem>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesList = Array<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesItem>;
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesList: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesList>;
+export interface ListFlagVersionsResponseVersionsItemDataEnvironmentsValue {
+    reuse?: CreateFlagResponseEnvironmentsValueReuse;
+    targets?: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueTargetsMap;
+    revision?: number;
+    pausedOutcome: ListFlagVersionsResponseVersionsItemDataEnvironmentsValuePausedOutcome;
+    fallthrough: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueFallthrough;
+    active: boolean;
+    rules: ListFlagVersionsResponseVersionsItemDataEnvironmentsValueRulesList;
+}
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsValue: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsValue>;
+export type ListFlagVersionsResponseVersionsItemDataEnvironmentsMap = {
+    [key: string]: ListFlagVersionsResponseVersionsItemDataEnvironmentsValue | undefined;
+};
+export declare const ListFlagVersionsResponseVersionsItemDataEnvironmentsMap: S.Schema<ListFlagVersionsResponseVersionsItemDataEnvironmentsMap>;
+export type ListFlagVersionsResponseVersionsItemDataState = "active" | "archived";
+export declare const ListFlagVersionsResponseVersionsItemDataState: any;
+export interface ListFlagVersionsResponseVersionsItemData {
+    description?: string;
+    maintainerIds?: ListFlagVersionsResponseVersionsItemDataMaintainerIdsList;
+    permanent?: boolean;
+    tags?: ListFlagVersionsResponseVersionsItemDataTagsList;
+    experiment?: ListFlagVersionsResponseVersionsItemDataExperiment;
+    variants: ListFlagVersionsResponseVersionsItemDataVariantsList;
+    environments: ListFlagVersionsResponseVersionsItemDataEnvironmentsMap;
+    seed: number;
+    state: ListFlagVersionsResponseVersionsItemDataState;
+}
+export declare const ListFlagVersionsResponseVersionsItemData: S.Schema<ListFlagVersionsResponseVersionsItemData>;
+export type ListFlagVersionsResponseVersionsItemChangedEnvironmentsList = Array<string>;
+export declare const ListFlagVersionsResponseVersionsItemChangedEnvironmentsList: S.Schema<ListFlagVersionsResponseVersionsItemChangedEnvironmentsList>;
+export type ListFlagVersionsResponseVersionsItemMetadataCreator = FlagMetadataCreator;
+export declare const ListFlagVersionsResponseVersionsItemMetadataCreator: S.Schema<FlagMetadataCreator>;
+export type ListFlagVersionsResponseVersionsItemMetadata = FlagMetadata;
+export declare const ListFlagVersionsResponseVersionsItemMetadata: S.Schema<FlagMetadata>;
+export interface ListFlagVersionsResponseVersionsItem {
+    createdBy?: string;
+    message?: string;
+    data: ListFlagVersionsResponseVersionsItemData;
+    id: string;
+    revision: number;
+    createdAt: number;
+    flagId: string;
+    changedEnvironments: ListFlagVersionsResponseVersionsItemChangedEnvironmentsList;
+    metadata?: FlagMetadata;
+}
+export declare const ListFlagVersionsResponseVersionsItem: S.Schema<ListFlagVersionsResponseVersionsItem>;
+export type ListFlagVersionsResponseVersionsList = Array<ListFlagVersionsResponseVersionsItem>;
+export declare const ListFlagVersionsResponseVersionsList: S.Schema<ListFlagVersionsResponseVersionsList>;
+export interface ListFlagVersionsResponse {
+    versions: ListFlagVersionsResponseVersionsList;
+    pagination: unknown;
+}
+export declare const ListFlagVersionsResponse: S.Schema<ListFlagVersionsResponse>;
+/** The state of the flags to retrieve. Defaults to `active`. */
+export type ListTeamFlagsRequestState = "active" | "archived";
+export declare const ListTeamFlagsRequestState: any;
+/** The kind of flags to retrieve. */
+export type ListTeamFlagsRequestKind = "boolean" | "string" | "number" | "json";
+export declare const ListTeamFlagsRequestKind: any;
+/** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+export type ListTeamFlagsRequestTagsList = Array<string>;
+export declare const ListTeamFlagsRequestTagsList: S.Schema<ListTeamFlagsRequestTagsList>;
+export interface ListTeamFlagsRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The state of the flags to retrieve. Defaults to `active`. */
+    state?: ListTeamFlagsRequestState | (string & {});
+    /** Deprecated. Whether to include creator metadata in each flag in the response. Resolve creator identity client-side (e.g. via the team members endpoint) instead; this parameter will be removed in a future release. */
+    withMetadata?: boolean;
+    /** Maximum number of flags to return. */
+    limit?: number;
+    /** Pagination cursor to continue from. */
+    cursor?: string;
+    /** Search flags by their slug or description. Case-insensitive. */
+    search?: string;
+    /** The kind of flags to retrieve. */
+    kind?: ListTeamFlagsRequestKind | (string & {});
+    /** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+    tags?: ListTeamFlagsRequestTagsList;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListTeamFlagsRequest: S.Schema<ListTeamFlagsRequest>;
+export type ListTeamFlagsResponseDataList = Array<Flag>;
+export declare const ListTeamFlagsResponseDataList: S.Schema<ListTeamFlagsResponseDataList>;
+export type ListTeamFlagsResponsePagination = ListFlagsResponsePagination;
+export declare const ListTeamFlagsResponsePagination: S.Schema<ListFlagsResponsePagination>;
+export interface ListTeamFlagsResponse {
+    data: ListTeamFlagsResponseDataList;
+    pagination: ListFlagsResponsePagination;
+}
+export declare const ListTeamFlagsResponse: S.Schema<ListTeamFlagsResponse>;
+export interface ListTeamFlagSettingsRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** Maximum number of settings to return. */
+    limit?: number;
+    /** Pagination cursor to continue from. */
+    cursor?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListTeamFlagSettingsRequest: S.Schema<ListTeamFlagSettingsRequest>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemTypeName = "settings";
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemTypeName: any;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemEnvironmentsList = Array<string>;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEnvironmentsList: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEnvironmentsList>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsItem = GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsItem: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsList = Array<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsList: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsList>;
+export interface ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItem {
+    key: string;
+    type: string;
+    labels?: ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItemLabelsList;
+}
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItem: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItem>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesList = Array<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesItem>;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesList: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesList>;
+export interface ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItem {
+    kind: string;
+    label: string;
+    attributes: ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItemAttributesList;
+}
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItem: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItem>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesList = Array<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesItem>;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesList: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesList>;
+export type ListTeamFlagSettingsResponseBodyCase1DataItemMetadata = GetFlagSettingsResponseMetadata;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItemMetadata: S.Schema<GetFlagSettingsResponseMetadata>;
+export interface ListTeamFlagSettingsResponseBodyCase1DataItem {
+    typeName: ListTeamFlagSettingsResponseBodyCase1DataItemTypeName;
+    projectId: string;
+    ownerId?: string;
+    enabled: boolean;
+    environments: ListTeamFlagSettingsResponseBodyCase1DataItemEnvironmentsList;
+    entities: ListTeamFlagSettingsResponseBodyCase1DataItemEntitiesList;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata: GetFlagSettingsResponseMetadata;
+}
+export declare const ListTeamFlagSettingsResponseBodyCase1DataItem: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataItem>;
+export type ListTeamFlagSettingsResponseBodyCase1DataList = Array<ListTeamFlagSettingsResponseBodyCase1DataItem>;
+export declare const ListTeamFlagSettingsResponseBodyCase1DataList: S.Schema<ListTeamFlagSettingsResponseBodyCase1DataList>;
+export type ListTeamFlagSettingsResponseBodyCase1Pagination = ListFlagsResponsePagination;
+export declare const ListTeamFlagSettingsResponseBodyCase1Pagination: S.Schema<ListFlagsResponsePagination>;
+export interface ListTeamFlagSettingsResponseBodyCase1 {
+    data: ListTeamFlagSettingsResponseBodyCase1DataList;
+    pagination: ListFlagsResponsePagination;
+}
+export declare const ListTeamFlagSettingsResponseBodyCase1: S.Schema<ListTeamFlagSettingsResponseBodyCase1>;
+export type ListTeamFlagSettingsResponseBody = unknown | ListTeamFlagSettingsResponseBodyCase1;
+export declare const ListTeamFlagSettingsResponseBody: S.Schema<ListTeamFlagSettingsResponseBody>;
+export type ListTeamFlagSettingsResponse = ListTeamFlagSettingsResponseBody;
+export declare const ListTeamFlagSettingsResponse: S.Schema<ListTeamFlagSettingsResponse>;
+/** The state of the flags to retrieve. Defaults to `active`. */
+export type ListTeamFlagsV2RequestState = "active" | "archived";
+export declare const ListTeamFlagsV2RequestState: any;
+/** The kind of flags to retrieve. */
+export type ListTeamFlagsV2RequestKind = "boolean" | "string" | "number" | "json";
+export declare const ListTeamFlagsV2RequestKind: any;
+/** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+export type ListTeamFlagsV2RequestTagsList = Array<string>;
+export declare const ListTeamFlagsV2RequestTagsList: S.Schema<ListTeamFlagsV2RequestTagsList>;
+/** Filter flags by maintainer user id. Repeat the parameter for multiple maintainers (any may match). */
+export type ListTeamFlagsV2RequestMaintainerIdsList = Array<string>;
+export declare const ListTeamFlagsV2RequestMaintainerIdsList: S.Schema<ListTeamFlagsV2RequestMaintainerIdsList>;
+export interface ListTeamFlagsV2Request {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The state of the flags to retrieve. Defaults to `active`. */
+    state?: ListTeamFlagsV2RequestState | (string & {});
+    /** Maximum number of flags to return. */
+    limit?: number;
+    /** Pagination cursor to continue from. */
+    cursor?: string;
+    /** Search flags by their slug or description. Case-insensitive. */
+    search?: string;
+    /** The kind of flags to retrieve. */
+    kind?: ListTeamFlagsV2RequestKind | (string & {});
+    /** Filter flags by tag. Repeat the parameter for multiple tags (all must match). */
+    tags?: ListTeamFlagsV2RequestTagsList;
+    /** Filter flags by the id of the entity that created them (a user or team id). */
+    createdBy?: string;
+    /** Filter flags by maintainer user id. Repeat the parameter for multiple maintainers (any may match). */
+    maintainerIds?: ListTeamFlagsV2RequestMaintainerIdsList;
+    /** Whether to include Marketplace experimentation items in the paginated response. Defaults to false. */
+    includeMarketplaceFlags?: boolean;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListTeamFlagsV2Request: S.Schema<ListTeamFlagsV2Request>;
+export type ListTeamFlagsV2ResponsePagination = ListFlagsResponsePagination;
+export declare const ListTeamFlagsV2ResponsePagination: S.Schema<ListFlagsResponsePagination>;
+export type ListTeamFlagsV2ResponseDataItem = Flag | MarketplaceFlag;
+export declare const ListTeamFlagsV2ResponseDataItem: S.Schema<ListTeamFlagsV2ResponseDataItem>;
+export type ListTeamFlagsV2ResponseDataList = Array<ListTeamFlagsV2ResponseDataItem>;
+export declare const ListTeamFlagsV2ResponseDataList: S.Schema<ListTeamFlagsV2ResponseDataList>;
+export interface ListTeamFlagsV2Response {
+    pagination: ListFlagsResponsePagination;
+    data: ListTeamFlagsV2ResponseDataList;
+}
+export declare const ListTeamFlagsV2Response: S.Schema<ListTeamFlagsV2Response>;
+export type UpdateFlagRequestVariantsItemValueCase4List = Array<unknown>;
+export declare const UpdateFlagRequestVariantsItemValueCase4List: S.Schema<UpdateFlagRequestVariantsItemValueCase4List>;
+export type UpdateFlagRequestVariantsItemValue = string | number | boolean | unknown | UpdateFlagRequestVariantsItemValueCase4List;
+export declare const UpdateFlagRequestVariantsItemValue: S.Schema<UpdateFlagRequestVariantsItemValue>;
+export interface UpdateFlagRequestVariantsItem {
+    /** The id of the variant */
+    id: string;
+    /** A label for the variant */
+    label?: string;
+    /** A description of the variant */
+    description?: string;
+    value: UpdateFlagRequestVariantsItemValue;
+}
+export declare const UpdateFlagRequestVariantsItem: S.Schema<UpdateFlagRequestVariantsItem>;
+/** The variants of the flag */
+export type UpdateFlagRequestVariantsList = Array<UpdateFlagRequestVariantsItem>;
+export declare const UpdateFlagRequestVariantsList: S.Schema<UpdateFlagRequestVariantsList>;
+/** Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration */
+export type UpdateFlagRequestEnvironmentsValueReuse = CreateFlagRequestEnvironmentsValueReuse;
+export declare const UpdateFlagRequestEnvironmentsValueReuse: S.Schema<CreateFlagRequestEnvironmentsValueReuse>;
+export type UpdateFlagRequestEnvironmentsValueTargetsValueValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagRequestEnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagRequestEnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagRequestEnvironmentsValueTargetsValueValueValueList: S.Schema<UpdateFlagRequestEnvironmentsValueTargetsValueValueValueList>;
+export type UpdateFlagRequestEnvironmentsValueTargetsValueValueMap = {
+    [key: string]: UpdateFlagRequestEnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsValueTargetsValueValueMap: S.Schema<UpdateFlagRequestEnvironmentsValueTargetsValueValueMap>;
+export type UpdateFlagRequestEnvironmentsValueTargetsValueMap = {
+    [key: string]: UpdateFlagRequestEnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsValueTargetsValueMap: S.Schema<UpdateFlagRequestEnvironmentsValueTargetsValueMap>;
+/** Allows assigning targets to variants while bypassing the flag's rules */
+export type UpdateFlagRequestEnvironmentsValueTargetsMap = {
+    [key: string]: UpdateFlagRequestEnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsValueTargetsMap: S.Schema<UpdateFlagRequestEnvironmentsValueTargetsMap>;
+export type UpdateFlagRequestEnvironmentsValuePausedOutcome = CreateFlagRequestEnvironmentsValuePausedOutcome;
+export declare const UpdateFlagRequestEnvironmentsValuePausedOutcome: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp = "eq" | "!eq" | "oneOf" | "!oneOf" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "startsWith" | "!startsWith" | "endsWith" | "!endsWith" | "contains" | "!contains" | "ex" | "!ex" | "gt" | "gte" | "lt" | "lte" | "regex" | "!regex" | "before" | "after";
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp: any;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type = "list/inline" | "list";
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type: any;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList = Array<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItem>;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList>;
+export interface UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0 {
+    type: UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0Type | (string & {});
+    items: UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsList;
+}
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs = UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 | string | number | boolean;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export interface UpdateFlagRequestEnvironmentsValueRulesItemConditionsItem {
+    lhs: UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemCmp | (string & {});
+    rhs?: UpdateFlagRequestEnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+}
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsItem: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItem>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemConditionsList = Array<UpdateFlagRequestEnvironmentsValueRulesItemConditionsItem>;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemConditionsList: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemConditionsList>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase0 = CreateFlagRequestEnvironmentsValuePausedOutcome;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase0: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+/** The distribution for each variant */
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** The distribution for each variant */
+    weights: UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+}
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem = CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+/** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** Epoch ms when the rollout begins */
+    startTimestamp: number;
+    /** The variant to roll away from */
+    rollFromVariantId: string;
+    /** The variant to roll towards */
+    rollToVariantId: string;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+    /** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+    slots: UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2>;
+export type UpdateFlagRequestEnvironmentsValueRulesItemOutcome = CreateFlagRequestEnvironmentsValuePausedOutcome | UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase1 | UpdateFlagRequestEnvironmentsValueRulesItemOutcomeCase2;
+export declare const UpdateFlagRequestEnvironmentsValueRulesItemOutcome: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItemOutcome>;
+export interface UpdateFlagRequestEnvironmentsValueRulesItem {
+    id: string;
+    conditions: UpdateFlagRequestEnvironmentsValueRulesItemConditionsList;
+    outcome: UpdateFlagRequestEnvironmentsValueRulesItemOutcome;
+}
+export declare const UpdateFlagRequestEnvironmentsValueRulesItem: S.Schema<UpdateFlagRequestEnvironmentsValueRulesItem>;
+export type UpdateFlagRequestEnvironmentsValueRulesList = Array<UpdateFlagRequestEnvironmentsValueRulesItem>;
+export declare const UpdateFlagRequestEnvironmentsValueRulesList: S.Schema<UpdateFlagRequestEnvironmentsValueRulesList>;
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase0 = CreateFlagRequestEnvironmentsValuePausedOutcome;
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase0: S.Schema<CreateFlagRequestEnvironmentsValuePausedOutcome>;
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+/** The distribution for each variant */
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap: S.Schema<UpdateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap>;
+export interface UpdateFlagRequestEnvironmentsValueFallthroughCase1 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** The distribution for each variant */
+    weights: UpdateFlagRequestEnvironmentsValueFallthroughCase1WeightsMap;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+}
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase1: S.Schema<UpdateFlagRequestEnvironmentsValueFallthroughCase1>;
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase2Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase2Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsItem = CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem;
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+/** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+export type UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagRequestEnvironmentsValueRulesItemOutcomeCase2SlotsItem>;
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsList: S.Schema<UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsList>;
+export interface UpdateFlagRequestEnvironmentsValueFallthroughCase2 {
+    type: unknown;
+    base: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+    /** Epoch ms when the rollout begins */
+    startTimestamp: number;
+    /** The variant to roll away from */
+    rollFromVariantId: string;
+    /** The variant to roll towards */
+    rollToVariantId: string;
+    /** This variant will be used when the base attribute does not exist */
+    defaultVariantId: string;
+    /** Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely. */
+    slots: UpdateFlagRequestEnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const UpdateFlagRequestEnvironmentsValueFallthroughCase2: S.Schema<UpdateFlagRequestEnvironmentsValueFallthroughCase2>;
+export type UpdateFlagRequestEnvironmentsValueFallthrough = CreateFlagRequestEnvironmentsValuePausedOutcome | UpdateFlagRequestEnvironmentsValueFallthroughCase1 | UpdateFlagRequestEnvironmentsValueFallthroughCase2;
+export declare const UpdateFlagRequestEnvironmentsValueFallthrough: S.Schema<UpdateFlagRequestEnvironmentsValueFallthrough>;
+export interface UpdateFlagRequestEnvironmentsValue {
+    active: boolean;
+    /** Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration */
+    reuse?: CreateFlagRequestEnvironmentsValueReuse;
+    /** Allows assigning targets to variants while bypassing the flag's rules */
+    targets?: UpdateFlagRequestEnvironmentsValueTargetsMap;
+    pausedOutcome: CreateFlagRequestEnvironmentsValuePausedOutcome;
+    rules: UpdateFlagRequestEnvironmentsValueRulesList;
+    fallthrough: UpdateFlagRequestEnvironmentsValueFallthrough;
+    /** The revision of the environment config */
+    revision?: number;
+}
+export declare const UpdateFlagRequestEnvironmentsValue: S.Schema<UpdateFlagRequestEnvironmentsValue>;
+/** The configuration for the flag in different environments */
+export type UpdateFlagRequestEnvironmentsMap = {
+    [key: string]: UpdateFlagRequestEnvironmentsValue | undefined;
+};
+export declare const UpdateFlagRequestEnvironmentsMap: S.Schema<UpdateFlagRequestEnvironmentsMap>;
+export type UpdateFlagRequestState = "active" | "archived";
+export declare const UpdateFlagRequestState: any;
+/** The user ids of the maintainers of the flag */
+export type UpdateFlagRequestMaintainerIdsList = Array<string>;
+export declare const UpdateFlagRequestMaintainerIdsList: S.Schema<UpdateFlagRequestMaintainerIdsList>;
+/** Tags for categorizing the flag */
+export type UpdateFlagRequestTagsList = Array<string>;
+export declare const UpdateFlagRequestTagsList: S.Schema<UpdateFlagRequestTagsList>;
+export interface UpdateFlagRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The flag id or name */
+    flagIdOrSlug: string;
+    /** Etag to match, can be used interchangeably with the `if-match` header */
+    ifMatch?: string;
+    /** Whether to include metadata in the response */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The user who created this patch */
+    createdBy?: string;
+    /** Additional message for this version */
+    message?: string;
+    /** The variants of the flag */
+    variants?: UpdateFlagRequestVariantsList;
+    /** The configuration for the flag in different environments */
+    environments?: UpdateFlagRequestEnvironmentsMap;
+    /** A random seed to prevent split points in different flags from having the same targets */
+    seed?: number;
+    /** A description of the flag */
+    description?: string;
+    state?: UpdateFlagRequestState | (string & {});
+    /** The user ids of the maintainers of the flag */
+    maintainerIds?: UpdateFlagRequestMaintainerIdsList;
+    /** Whether this flag is marked as permanent, indicating it should not be removed */
+    permanent?: boolean;
+    /** Tags for categorizing the flag */
+    tags?: UpdateFlagRequestTagsList;
+}
+export declare const UpdateFlagRequest: S.Schema<UpdateFlagRequest>;
+export type UpdateFlagResponseBodyCase0MaintainerIdsList = Array<string>;
+export declare const UpdateFlagResponseBodyCase0MaintainerIdsList: S.Schema<UpdateFlagResponseBodyCase0MaintainerIdsList>;
+export type UpdateFlagResponseBodyCase0TagsList = Array<string>;
+export declare const UpdateFlagResponseBodyCase0TagsList: S.Schema<UpdateFlagResponseBodyCase0TagsList>;
+export type UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricType: any;
+export type UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricUnit: any;
+export type UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemDirectionality: any;
+export interface UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricType;
+    metricUnit: UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemMetricUnit;
+    directionality: UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItemDirectionality;
+}
+export declare const UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItem: S.Schema<UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItem>;
+export type UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsList = Array<UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsItem>;
+export declare const UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsList: S.Schema<UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsList>;
+export type UpdateFlagResponseBodyCase0ExperimentDevice = "android" | "desktop" | "ios" | "mweb";
+export declare const UpdateFlagResponseBodyCase0ExperimentDevice: any;
+export type UpdateFlagResponseBodyCase0ExperimentDurationUnit = "days" | "exposures";
+export declare const UpdateFlagResponseBodyCase0ExperimentDurationUnit: any;
+export type UpdateFlagResponseBodyCase0ExperimentAllocationUnit = "cookieId" | "userId" | "visitorId";
+export declare const UpdateFlagResponseBodyCase0ExperimentAllocationUnit: any;
+export type UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricType = "count" | "currency" | "percentage";
+export declare const UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricType: any;
+export type UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricUnit = "session" | "user" | "visitor";
+export declare const UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricUnit: any;
+export type UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemDirectionality = "decreaseIsGood" | "increaseIsGood";
+export declare const UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemDirectionality: any;
+export interface UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItem {
+    description?: string;
+    metricFormula?: string;
+    name: string;
+    metricType: UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricType;
+    metricUnit: UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemMetricUnit;
+    directionality: UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItemDirectionality;
+}
+export declare const UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItem: S.Schema<UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItem>;
+export type UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsList = Array<UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsItem>;
+export declare const UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsList: S.Schema<UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsList>;
+export type UpdateFlagResponseBodyCase0ExperimentStatus = "closed" | "draft" | "paused" | "running";
+export declare const UpdateFlagResponseBodyCase0ExperimentStatus: any;
+export interface UpdateFlagResponseBodyCase0Experiment {
+    id?: string;
+    name?: string;
+    numVariants?: number;
+    surfaceArea?: string;
+    stickyRequirement?: boolean;
+    layer?: string;
+    guardrailMetrics?: UpdateFlagResponseBodyCase0ExperimentGuardrailMetricsList;
+    hypothesis?: string;
+    device?: UpdateFlagResponseBodyCase0ExperimentDevice;
+    controlVariantId?: string;
+    startedAt?: number;
+    endedAt?: number;
+    decision?: string;
+    decisionReason?: string;
+    duration?: number;
+    durationUnit?: UpdateFlagResponseBodyCase0ExperimentDurationUnit;
+    allocationPercent?: number;
+    allocationUnit: UpdateFlagResponseBodyCase0ExperimentAllocationUnit;
+    primaryMetrics: UpdateFlagResponseBodyCase0ExperimentPrimaryMetricsList;
+    status: UpdateFlagResponseBodyCase0ExperimentStatus;
+}
+export declare const UpdateFlagResponseBodyCase0Experiment: S.Schema<UpdateFlagResponseBodyCase0Experiment>;
+export type UpdateFlagResponseBodyCase0VariantsList = Array<unknown>;
+export declare const UpdateFlagResponseBodyCase0VariantsList: S.Schema<UpdateFlagResponseBodyCase0VariantsList>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueReuse = CreateFlagResponseEnvironmentsValueReuse;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueReuse: S.Schema<CreateFlagResponseEnvironmentsValueReuse>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueList>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueMap = {
+    [key: string]: UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueValueList | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueMap>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueMap = {
+    [key: string]: UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueValueMap | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueMap>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueTargetsMap = {
+    [key: string]: UpdateFlagResponseBodyCase0EnvironmentsValueTargetsValueMap | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueTargetsMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueTargetsMap>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcomeType = "variant";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcomeType: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcome {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcomeType;
+    variantId: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcome: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcome>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0Type = "variant";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0Type: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0Type;
+    variantId: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Type = "split";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Type: any;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1BaseType = "entity";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1BaseType: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Base {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Base: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Base>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1WeightsMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1WeightsMap>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Type;
+    base: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1Base;
+    weights: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Type = "rollout";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Type: any;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2BaseType = "entity";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2BaseType: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Base {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Base: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Base>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsList>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Type;
+    base: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2SlotsList;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueFallthrough = UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase0 | UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase1 | UpdateFlagResponseBodyCase0EnvironmentsValueFallthroughCase2;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueFallthrough: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueFallthrough>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0Type = "variant";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0Type: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0Type;
+    variantId: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Type = "split";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Type: any;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1BaseType = "entity";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1BaseType: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Base {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Base: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Base>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1WeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1WeightsMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1WeightsMap>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Type;
+    base: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1Base;
+    weights: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1WeightsMap;
+    defaultVariantId: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Type = "rollout";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Type: any;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2BaseType = "entity";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2BaseType: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Base {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Base: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Base>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsItem = CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsItem: S.Schema<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsList = Array<CreateFlagResponseEnvironmentsValueFallthroughCase2SlotsItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsList>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Type;
+    base: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2Base;
+    defaultVariantId: string;
+    startTimestamp: number;
+    rollFromVariantId: string;
+    rollToVariantId: string;
+    slots: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2SlotsList;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcome = UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase0 | UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase1 | UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcomeCase2;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcome: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcome>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2Type: any;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList = Array<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2Type;
+    items: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3Type: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhs = string | number | UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase2 | UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhsCase3 | boolean;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhs: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhs>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0Type: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0Type;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1Type: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1 {
+    type: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhs = UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase0 | UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhs: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhs>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemCmp: any;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItem {
+    rhs?: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemLhs;
+    cmp: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItemCmp;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItem: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsList = Array<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsList>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValueRulesItem {
+    id: string;
+    outcome: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemOutcome;
+    conditions: UpdateFlagResponseBodyCase0EnvironmentsValueRulesItemConditionsList;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesItem: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItem>;
+export type UpdateFlagResponseBodyCase0EnvironmentsValueRulesList = Array<UpdateFlagResponseBodyCase0EnvironmentsValueRulesItem>;
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValueRulesList: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValueRulesList>;
+export interface UpdateFlagResponseBodyCase0EnvironmentsValue {
+    reuse?: CreateFlagResponseEnvironmentsValueReuse;
+    targets?: UpdateFlagResponseBodyCase0EnvironmentsValueTargetsMap;
+    revision?: number;
+    pausedOutcome: UpdateFlagResponseBodyCase0EnvironmentsValuePausedOutcome;
+    fallthrough: UpdateFlagResponseBodyCase0EnvironmentsValueFallthrough;
+    active: boolean;
+    rules: UpdateFlagResponseBodyCase0EnvironmentsValueRulesList;
+}
+export declare const UpdateFlagResponseBodyCase0EnvironmentsValue: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsValue>;
+export type UpdateFlagResponseBodyCase0EnvironmentsMap = {
+    [key: string]: UpdateFlagResponseBodyCase0EnvironmentsValue | undefined;
+};
+export declare const UpdateFlagResponseBodyCase0EnvironmentsMap: S.Schema<UpdateFlagResponseBodyCase0EnvironmentsMap>;
+export type UpdateFlagResponseBodyCase0Kind = "boolean" | "json" | "number" | "string";
+export declare const UpdateFlagResponseBodyCase0Kind: any;
+export type UpdateFlagResponseBodyCase0State = "active" | "archived";
+export declare const UpdateFlagResponseBodyCase0State: any;
+export type UpdateFlagResponseBodyCase0TypeName = "flag";
+export declare const UpdateFlagResponseBodyCase0TypeName: any;
+export interface UpdateFlagResponseBodyCase0 {
+    description?: string;
+    maintainerIds?: UpdateFlagResponseBodyCase0MaintainerIdsList;
+    permanent?: boolean;
+    tags?: UpdateFlagResponseBodyCase0TagsList;
+    experiment?: UpdateFlagResponseBodyCase0Experiment;
+    updatedBy?: string;
+    variants: UpdateFlagResponseBodyCase0VariantsList;
+    id: string;
+    environments: UpdateFlagResponseBodyCase0EnvironmentsMap;
+    kind: UpdateFlagResponseBodyCase0Kind;
+    revision: number;
+    seed: number;
+    state: UpdateFlagResponseBodyCase0State;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    ownerId: string;
+    projectId: string;
+    typeName: UpdateFlagResponseBodyCase0TypeName;
+}
+export declare const UpdateFlagResponseBodyCase0: S.Schema<UpdateFlagResponseBodyCase0>;
+export type UpdateFlagResponseBody = UpdateFlagResponseBodyCase0 | Flag;
+export declare const UpdateFlagResponseBody: S.Schema<UpdateFlagResponseBody>;
+export type UpdateFlagResponse = UpdateFlagResponseBody;
+export declare const UpdateFlagResponse: S.Schema<UpdateFlagResponse>;
+export type UpdateFlagSegmentRequestOperationsItemAction = "add" | "remove";
+export declare const UpdateFlagSegmentRequestOperationsItemAction: any;
+export type UpdateFlagSegmentRequestOperationsItemField = "include" | "exclude";
+export declare const UpdateFlagSegmentRequestOperationsItemField: any;
+export type UpdateFlagSegmentRequestOperationsItemValue = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagSegmentRequestOperationsItemValue: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export interface UpdateFlagSegmentRequestOperationsItem {
+    action: UpdateFlagSegmentRequestOperationsItemAction | (string & {});
+    field: UpdateFlagSegmentRequestOperationsItemField | (string & {});
+    entity: string;
+    attribute: string;
+    value: CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+}
+export declare const UpdateFlagSegmentRequestOperationsItem: S.Schema<UpdateFlagSegmentRequestOperationsItem>;
+export type UpdateFlagSegmentRequestOperationsList = Array<UpdateFlagSegmentRequestOperationsItem>;
+export declare const UpdateFlagSegmentRequestOperationsList: S.Schema<UpdateFlagSegmentRequestOperationsList>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemLhsCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemLhsCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemLhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemLhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemLhs = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemLhs: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItemLhs>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemCmp = "eq" | "!eq" | "oneOf" | "!oneOf" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "startsWith" | "!startsWith" | "endsWith" | "!endsWith" | "contains" | "!contains" | "ex" | "!ex" | "gt" | "gte" | "lt" | "lte" | "regex" | "!regex" | "before" | "after";
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemCmp: any;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type = "list/inline" | "list";
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type: any;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList = Array<UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsItem>;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList>;
+export interface UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0 {
+    type: UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0Type | (string & {});
+    items: UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0ItemsList;
+}
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemRhs = UpdateFlagSegmentRequestDataRulesItemConditionsItemRhsCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase1 | string | number | boolean;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemRhs: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItemRhs>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export interface UpdateFlagSegmentRequestDataRulesItemConditionsItem {
+    lhs: UpdateFlagSegmentRequestDataRulesItemConditionsItemLhs;
+    cmp: UpdateFlagSegmentRequestDataRulesItemConditionsItemCmp | (string & {});
+    rhs?: UpdateFlagSegmentRequestDataRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+}
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsItem: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsItem>;
+export type UpdateFlagSegmentRequestDataRulesItemConditionsList = Array<UpdateFlagSegmentRequestDataRulesItemConditionsItem>;
+export declare const UpdateFlagSegmentRequestDataRulesItemConditionsList: S.Schema<UpdateFlagSegmentRequestDataRulesItemConditionsList>;
+export type UpdateFlagSegmentRequestDataRulesItemOutcomeCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0;
+export declare const UpdateFlagSegmentRequestDataRulesItemOutcomeCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0>;
+export type UpdateFlagSegmentRequestDataRulesItemOutcomeCase1Base = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemOutcomeCase1Base: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagSegmentRequestDataRulesItemOutcomeCase1 = CreateFlagSegmentRequestDataRulesItemOutcomeCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemOutcomeCase1: S.Schema<CreateFlagSegmentRequestDataRulesItemOutcomeCase1>;
+export type UpdateFlagSegmentRequestDataRulesItemOutcome = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemLhsCase0 | CreateFlagSegmentRequestDataRulesItemOutcomeCase1;
+export declare const UpdateFlagSegmentRequestDataRulesItemOutcome: S.Schema<UpdateFlagSegmentRequestDataRulesItemOutcome>;
+export interface UpdateFlagSegmentRequestDataRulesItem {
+    id: string;
+    conditions: UpdateFlagSegmentRequestDataRulesItemConditionsList;
+    outcome: UpdateFlagSegmentRequestDataRulesItemOutcome;
+}
+export declare const UpdateFlagSegmentRequestDataRulesItem: S.Schema<UpdateFlagSegmentRequestDataRulesItem>;
+export type UpdateFlagSegmentRequestDataRulesList = Array<UpdateFlagSegmentRequestDataRulesItem>;
+export declare const UpdateFlagSegmentRequestDataRulesList: S.Schema<UpdateFlagSegmentRequestDataRulesList>;
+export type UpdateFlagSegmentRequestDataIncludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagSegmentRequestDataIncludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagSegmentRequestDataIncludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagSegmentRequestDataIncludeValueValueList: S.Schema<UpdateFlagSegmentRequestDataIncludeValueValueList>;
+export type UpdateFlagSegmentRequestDataIncludeValueMap = {
+    [key: string]: UpdateFlagSegmentRequestDataIncludeValueValueList | undefined;
+};
+export declare const UpdateFlagSegmentRequestDataIncludeValueMap: S.Schema<UpdateFlagSegmentRequestDataIncludeValueMap>;
+export type UpdateFlagSegmentRequestDataIncludeMap = {
+    [key: string]: UpdateFlagSegmentRequestDataIncludeValueMap | undefined;
+};
+export declare const UpdateFlagSegmentRequestDataIncludeMap: S.Schema<UpdateFlagSegmentRequestDataIncludeMap>;
+export type UpdateFlagSegmentRequestDataExcludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagSegmentRequestDataExcludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagSegmentRequestDataExcludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagSegmentRequestDataExcludeValueValueList: S.Schema<UpdateFlagSegmentRequestDataExcludeValueValueList>;
+export type UpdateFlagSegmentRequestDataExcludeValueMap = {
+    [key: string]: UpdateFlagSegmentRequestDataExcludeValueValueList | undefined;
+};
+export declare const UpdateFlagSegmentRequestDataExcludeValueMap: S.Schema<UpdateFlagSegmentRequestDataExcludeValueMap>;
+export type UpdateFlagSegmentRequestDataExcludeMap = {
+    [key: string]: UpdateFlagSegmentRequestDataExcludeValueMap | undefined;
+};
+export declare const UpdateFlagSegmentRequestDataExcludeMap: S.Schema<UpdateFlagSegmentRequestDataExcludeMap>;
+/** The data of the segment */
+export interface UpdateFlagSegmentRequestData {
+    rules?: UpdateFlagSegmentRequestDataRulesList;
+    include?: UpdateFlagSegmentRequestDataIncludeMap;
+    exclude?: UpdateFlagSegmentRequestDataExcludeMap;
+}
+export declare const UpdateFlagSegmentRequestData: S.Schema<UpdateFlagSegmentRequestData>;
+export interface UpdateFlagSegmentRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The segment slug */
+    segmentIdOrSlug: string;
+    /** Whether to include metadata */
+    withMetadata?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    operations?: UpdateFlagSegmentRequestOperationsList;
+    label?: string;
+    description?: string;
+    /** The data of the segment */
+    data?: UpdateFlagSegmentRequestData;
+    hint?: string;
+}
+export declare const UpdateFlagSegmentRequest: S.Schema<UpdateFlagSegmentRequest>;
+export type UpdateFlagSegmentResponseBodyCase0UsedByFlagsList = Array<string>;
+export declare const UpdateFlagSegmentResponseBodyCase0UsedByFlagsList: S.Schema<UpdateFlagSegmentResponseBodyCase0UsedByFlagsList>;
+export type UpdateFlagSegmentResponseBodyCase0UsedBySegmentsList = Array<string>;
+export declare const UpdateFlagSegmentResponseBodyCase0UsedBySegmentsList: S.Schema<UpdateFlagSegmentResponseBodyCase0UsedBySegmentsList>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0Type = "all";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0Type: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0Type;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Type = "split";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Type: any;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1BaseType = "entity";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1BaseType: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Base {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1BaseType;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Base: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Base>;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Type;
+    base: UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1Base;
+    passPromille: number;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcome = UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase0 | UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcomeCase1;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcome: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcome>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2Type = "list" | "list/inline";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2Type: any;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItemCase0 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItemCase0: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItemCase1 = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItemCase1: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItem = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase0 | CreateFlagRequestEnvironmentsValueRulesItemConditionsItemRhsCase0ItemsItemCase1;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItem: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItem>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsList = Array<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsItem>;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsList: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsList>;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2Type;
+    items: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2ItemsList;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3Type = "regex";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3Type: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3Type;
+    pattern: string;
+    flags: string;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhs = string | number | UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase2 | UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhsCase3 | boolean;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhs: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhs>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemCmpOptions = CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemCmpOptions: S.Schema<CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0Type = "segment";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0Type: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0Type;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1Type = "entity";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1Type: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1 {
+    type: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1Type;
+    kind: string;
+    attribute: string;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhs = UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase0 | UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhsCase1;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhs: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhs>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemCmp = "!contains" | "!endsWith" | "!eq" | "!ex" | "!oneOf" | "!regex" | "!startsWith" | "after" | "before" | "contains" | "containsAllOf" | "containsAnyOf" | "containsNoneOf" | "endsWith" | "eq" | "ex" | "gt" | "gte" | "lt" | "lte" | "oneOf" | "regex" | "startsWith";
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemCmp: any;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItem {
+    rhs?: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemRhs;
+    cmpOptions?: CreateFlagRequestEnvironmentsValueRulesItemConditionsItemCmpOptions;
+    lhs: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemLhs;
+    cmp: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItemCmp;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItem: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItem>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsList = Array<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsItem>;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsList: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsList>;
+export interface UpdateFlagSegmentResponseBodyCase0DataRulesItem {
+    id: string;
+    outcome: UpdateFlagSegmentResponseBodyCase0DataRulesItemOutcome;
+    conditions: UpdateFlagSegmentResponseBodyCase0DataRulesItemConditionsList;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesItem: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesItem>;
+export type UpdateFlagSegmentResponseBodyCase0DataRulesList = Array<UpdateFlagSegmentResponseBodyCase0DataRulesItem>;
+export declare const UpdateFlagSegmentResponseBodyCase0DataRulesList: S.Schema<UpdateFlagSegmentResponseBodyCase0DataRulesList>;
+export type UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueList: S.Schema<UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueList>;
+export type UpdateFlagSegmentResponseBodyCase0DataIncludeValueMap = {
+    [key: string]: UpdateFlagSegmentResponseBodyCase0DataIncludeValueValueList | undefined;
+};
+export declare const UpdateFlagSegmentResponseBodyCase0DataIncludeValueMap: S.Schema<UpdateFlagSegmentResponseBodyCase0DataIncludeValueMap>;
+export type UpdateFlagSegmentResponseBodyCase0DataIncludeMap = {
+    [key: string]: UpdateFlagSegmentResponseBodyCase0DataIncludeValueMap | undefined;
+};
+export declare const UpdateFlagSegmentResponseBodyCase0DataIncludeMap: S.Schema<UpdateFlagSegmentResponseBodyCase0DataIncludeMap>;
+export type UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueItem = CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem;
+export declare const UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueItem: S.Schema<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export type UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueList = Array<CreateFlagRequestEnvironmentsValueTargetsValueValueValueItem>;
+export declare const UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueList: S.Schema<UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueList>;
+export type UpdateFlagSegmentResponseBodyCase0DataExcludeValueMap = {
+    [key: string]: UpdateFlagSegmentResponseBodyCase0DataExcludeValueValueList | undefined;
+};
+export declare const UpdateFlagSegmentResponseBodyCase0DataExcludeValueMap: S.Schema<UpdateFlagSegmentResponseBodyCase0DataExcludeValueMap>;
+export type UpdateFlagSegmentResponseBodyCase0DataExcludeMap = {
+    [key: string]: UpdateFlagSegmentResponseBodyCase0DataExcludeValueMap | undefined;
+};
+export declare const UpdateFlagSegmentResponseBodyCase0DataExcludeMap: S.Schema<UpdateFlagSegmentResponseBodyCase0DataExcludeMap>;
+export interface UpdateFlagSegmentResponseBodyCase0Data {
+    rules?: UpdateFlagSegmentResponseBodyCase0DataRulesList;
+    include?: UpdateFlagSegmentResponseBodyCase0DataIncludeMap;
+    exclude?: UpdateFlagSegmentResponseBodyCase0DataExcludeMap;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0Data: S.Schema<UpdateFlagSegmentResponseBodyCase0Data>;
+export type UpdateFlagSegmentResponseBodyCase0TypeName = "segment";
+export declare const UpdateFlagSegmentResponseBodyCase0TypeName: any;
+export interface UpdateFlagSegmentResponseBodyCase0 {
+    description?: string;
+    createdBy?: string;
+    usedByFlags?: UpdateFlagSegmentResponseBodyCase0UsedByFlagsList;
+    usedBySegments?: UpdateFlagSegmentResponseBodyCase0UsedBySegmentsList;
+    data: UpdateFlagSegmentResponseBodyCase0Data;
+    id: string;
+    label: string;
+    slug: string;
+    createdAt: number;
+    updatedAt: number;
+    projectId: string;
+    typeName: UpdateFlagSegmentResponseBodyCase0TypeName;
+    hint: string;
+}
+export declare const UpdateFlagSegmentResponseBodyCase0: S.Schema<UpdateFlagSegmentResponseBodyCase0>;
+export type UpdateFlagSegmentResponseBody = UpdateFlagSegmentResponseBodyCase0 | Segment;
+export declare const UpdateFlagSegmentResponseBody: S.Schema<UpdateFlagSegmentResponseBody>;
+export type UpdateFlagSegmentResponse = UpdateFlagSegmentResponseBody;
+export declare const UpdateFlagSegmentResponse: S.Schema<UpdateFlagSegmentResponse>;
+export type UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsItem = GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem;
+export declare const UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsItem: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export type UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsList = Array<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export declare const UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsList: S.Schema<UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsList>;
+export interface UpdateFlagSettingsRequestEntitiesItemAttributesItem {
+    key: string;
+    type: string;
+    labels?: UpdateFlagSettingsRequestEntitiesItemAttributesItemLabelsList;
+}
+export declare const UpdateFlagSettingsRequestEntitiesItemAttributesItem: S.Schema<UpdateFlagSettingsRequestEntitiesItemAttributesItem>;
+export type UpdateFlagSettingsRequestEntitiesItemAttributesList = Array<UpdateFlagSettingsRequestEntitiesItemAttributesItem>;
+export declare const UpdateFlagSettingsRequestEntitiesItemAttributesList: S.Schema<UpdateFlagSettingsRequestEntitiesItemAttributesList>;
+export interface UpdateFlagSettingsRequestEntitiesItem {
+    kind: string;
+    label: string;
+    attributes: UpdateFlagSettingsRequestEntitiesItemAttributesList;
+}
+export declare const UpdateFlagSettingsRequestEntitiesItem: S.Schema<UpdateFlagSettingsRequestEntitiesItem>;
+export type UpdateFlagSettingsRequestEntitiesList = Array<UpdateFlagSettingsRequestEntitiesItem>;
+export declare const UpdateFlagSettingsRequestEntitiesList: S.Schema<UpdateFlagSettingsRequestEntitiesList>;
+/** The environments to sync */
+export type UpdateFlagSettingsRequestEnvironmentsList = Array<string>;
+export declare const UpdateFlagSettingsRequestEnvironmentsList: S.Schema<UpdateFlagSettingsRequestEnvironmentsList>;
+export interface UpdateFlagSettingsRequest {
+    /** The project id or name */
+    projectIdOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    enabled?: boolean;
+    entities?: UpdateFlagSettingsRequestEntitiesList;
+    /** The environments to sync */
+    environments?: UpdateFlagSettingsRequestEnvironmentsList;
+}
+export declare const UpdateFlagSettingsRequest: S.Schema<UpdateFlagSettingsRequest>;
+export type UpdateFlagSettingsResponseTypeName = "settings";
+export declare const UpdateFlagSettingsResponseTypeName: any;
+export type UpdateFlagSettingsResponseEnvironmentsList = Array<string>;
+export declare const UpdateFlagSettingsResponseEnvironmentsList: S.Schema<UpdateFlagSettingsResponseEnvironmentsList>;
+export type UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsItem = GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem;
+export declare const UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsItem: S.Schema<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export type UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsList = Array<GetFlagSettingsResponseEntitiesItemAttributesItemLabelsItem>;
+export declare const UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsList: S.Schema<UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsList>;
+export interface UpdateFlagSettingsResponseEntitiesItemAttributesItem {
+    key: string;
+    type: string;
+    labels?: UpdateFlagSettingsResponseEntitiesItemAttributesItemLabelsList;
+}
+export declare const UpdateFlagSettingsResponseEntitiesItemAttributesItem: S.Schema<UpdateFlagSettingsResponseEntitiesItemAttributesItem>;
+export type UpdateFlagSettingsResponseEntitiesItemAttributesList = Array<UpdateFlagSettingsResponseEntitiesItemAttributesItem>;
+export declare const UpdateFlagSettingsResponseEntitiesItemAttributesList: S.Schema<UpdateFlagSettingsResponseEntitiesItemAttributesList>;
+export interface UpdateFlagSettingsResponseEntitiesItem {
+    kind: string;
+    label: string;
+    attributes: UpdateFlagSettingsResponseEntitiesItemAttributesList;
+}
+export declare const UpdateFlagSettingsResponseEntitiesItem: S.Schema<UpdateFlagSettingsResponseEntitiesItem>;
+export type UpdateFlagSettingsResponseEntitiesList = Array<UpdateFlagSettingsResponseEntitiesItem>;
+export declare const UpdateFlagSettingsResponseEntitiesList: S.Schema<UpdateFlagSettingsResponseEntitiesList>;
+export type UpdateFlagSettingsResponseMetadata = GetFlagSettingsResponseMetadata;
+export declare const UpdateFlagSettingsResponseMetadata: S.Schema<GetFlagSettingsResponseMetadata>;
+export interface UpdateFlagSettingsResponse {
+    typeName: UpdateFlagSettingsResponseTypeName;
+    projectId: string;
+    ownerId?: string;
+    enabled: boolean;
+    environments: UpdateFlagSettingsResponseEnvironmentsList;
+    entities: UpdateFlagSettingsResponseEntitiesList;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata: GetFlagSettingsResponseMetadata;
+}
+export declare const UpdateFlagSettingsResponse: S.Schema<UpdateFlagSettingsResponse>;
+export type CreateFlagError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Create a flag Create a new feature flag for a project. The flag must have a unique slug within the project and specify its kind (boolean, string, number, or json). */
+export declare const createFlag: API.OperationMethod<CreateFlagRequest, CreateFlagResponse, CreateFlagError, VercelOpContext>;
+export type CreateFlagSegmentError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Create a segment Create a new feature flag segment. */
+export declare const createFlagSegment: API.OperationMethod<CreateFlagSegmentRequest, CreateFlagSegmentResponse, CreateFlagSegmentError, VercelOpContext>;
+export type CreateSdkKeyError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Create an SDK key Creates an SDK key. */
+export declare const createSdkKey: API.OperationMethod<CreateSdkKeyRequest, FlagsSdkKeyWithSecrets, CreateSdkKeyError, VercelOpContext>;
+export type DeleteFlagError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Delete a flag Permanently delete a feature flag from the project. This action cannot be undone. Consider archiving the flag instead if you may need it in the future. */
+export declare const deleteFlag: API.OperationMethod<DeleteFlagRequest, DeleteFlagResponse, DeleteFlagError, VercelOpContext>;
+export type DeleteFlagSegmentError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Delete a segment Delete a feature flag segment. */
+export declare const deleteFlagSegment: API.OperationMethod<DeleteFlagSegmentRequest, DeleteFlagSegmentResponse, DeleteFlagSegmentError, VercelOpContext>;
+export type DeleteSdkKeyError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Delete an SDK key Deletes an SDK key. */
+export declare const deleteSdkKey: API.OperationMethod<DeleteSdkKeyRequest, DeleteSdkKeyResponse, DeleteSdkKeyError, VercelOpContext>;
+export type GetDeploymentFeatureFlagsError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Retrieve the feature flags of a deployment Retrieve the feature flags of a deployment. */
+export declare const getDeploymentFeatureFlags: API.OperationMethod<GetDeploymentFeatureFlagsRequest, GetDeploymentFeatureFlagsResponse, GetDeploymentFeatureFlagsError, VercelOpContext>;
+export type GetFlagError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** Get a flag Retrieve a specific feature flag by its ID or slug. */
+export declare const getFlag: API.OperationMethod<GetFlagRequest, Flag, GetFlagError, VercelOpContext>;
+export type GetFlagSegmentError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** Get a segment Retrieve a feature flag segment by ID or slug. */
+export declare const getFlagSegment: API.OperationMethod<GetFlagSegmentRequest, Segment, GetFlagSegmentError, VercelOpContext>;
+export type GetFlagSettingsError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** Get project flag settings Retrieve feature flag settings for a project. */
+export declare const getFlagSettings: API.OperationMethod<GetFlagSettingsRequest, GetFlagSettingsResponse, GetFlagSettingsError, VercelOpContext>;
+export type GetSdkKeysError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** Get all SDK keys Gets all SDK keys for a project. */
+export declare const getSdkKeys: API.OperationMethod<GetSdkKeysRequest, GetSdkKeysResponse, GetSdkKeysError, VercelOpContext>;
+export type ListFlagsError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** List flags Retrieve feature flags for a project. The list can be filtered by state and supports pagination. */
+export declare const listFlags: API.OperationMethod<ListFlagsRequest, ListFlagsResponse, ListFlagsError, VercelOpContext>;
+export type ListFlagSegmentsError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** List segments List all feature flag segments for a project. */
+export declare const listFlagSegments: API.OperationMethod<ListFlagSegmentsRequest, ListFlagSegmentsResponse, ListFlagSegmentsError, VercelOpContext>;
+export type ListFlagsV2Error = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** List flags Retrieve feature flags for a project. Returns an opaque cursor for pagination. */
+export declare const listFlagsV2: API.OperationMethod<ListFlagsV2Request, ListFlagsV2Response, ListFlagsV2Error, VercelOpContext>;
+export type ListFlagVersionsError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** List flag versions Lists flag versions for a given flag. */
+export declare const listFlagVersions: API.OperationMethod<ListFlagVersionsRequest, ListFlagVersionsResponse, ListFlagVersionsError, VercelOpContext>;
+export type ListTeamFlagsError = BadRequest | Forbidden | VercelOpError;
+/** List all flags for a team Retrieve all feature flags for a team across all projects. The list can be filtered by state and supports pagination. */
+export declare const listTeamFlags: API.OperationMethod<ListTeamFlagsRequest, ListTeamFlagsResponse, ListTeamFlagsError, VercelOpContext>;
+export type ListTeamFlagSettingsError = BadRequest | Forbidden | VercelOpError;
+/** List team project flag settings Retrieve feature flag settings for projects in a team. */
+export declare const listTeamFlagSettings: API.OperationMethod<ListTeamFlagSettingsRequest, ListTeamFlagSettingsResponse, ListTeamFlagSettingsError, VercelOpContext>;
+export type ListTeamFlagsV2Error = BadRequest | Forbidden | VercelOpError;
+/** List all flags for a team Retrieve all feature flags for a team across all projects. Returns an opaque cursor for pagination. */
+export declare const listTeamFlagsV2: API.OperationMethod<ListTeamFlagsV2Request, ListTeamFlagsV2Response, ListTeamFlagsV2Error, VercelOpContext>;
+export type UpdateFlagError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Update a flag Update an existing feature flag. This endpoint supports partial updates, allowing you to modify specific properties like variants, environments, or state without providing the full flag configuration. */
+export declare const updateFlag: API.OperationMethod<UpdateFlagRequest, UpdateFlagResponse, UpdateFlagError, VercelOpContext>;
+export type UpdateFlagSegmentError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Update a segment Update an existing feature flag segment. */
+export declare const updateFlagSegment: API.OperationMethod<UpdateFlagSegmentRequest, UpdateFlagSegmentResponse, UpdateFlagSegmentError, VercelOpContext>;
+export type UpdateFlagSettingsError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Update project flag settings Update feature flag settings for a project. */
+export declare const updateFlagSettings: API.OperationMethod<UpdateFlagSettingsRequest, UpdateFlagSettingsResponse, UpdateFlagSettingsError, VercelOpContext>;
+//# sourceMappingURL=feature_flags.d.ts.map