import * as z from "zod/v3";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
/**
 * The kind of flag
 */
export declare const CreateFlagKind: {
    readonly Boolean: "boolean";
    readonly String: "string";
    readonly Number: "number";
    readonly Json: "json";
};
/**
 * The kind of flag
 */
export type CreateFlagKind = ClosedEnum<typeof CreateFlagKind>;
export type Value4 = {};
export type CreateFlagVariants = {
    /**
     * The id of the variant
     */
    id: string;
    /**
     * A label for the variant
     */
    label?: string | undefined;
    /**
     * A description of the variant
     */
    description?: string | undefined;
    value?: any | undefined;
};
/**
 * Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration
 */
export type CreateFlagReuse = {
    /**
     * Whether the reuse is active or not
     */
    active: boolean;
    /**
     * The environment to link to
     */
    environment: string;
};
export type CreateFlagTargets = {
    note?: string | undefined;
    value: string;
};
export type CreateFlagPausedOutcome = {
    type?: any | undefined;
    variantId: string;
};
export type CreateFlagLhs2 = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type CreateFlagLhs1 = {
    type?: any | undefined;
};
export type CreateFlagLhs = CreateFlagLhs2 | CreateFlagLhs1;
export declare const CreateFlagCmp: {
    readonly Eq: "eq";
    readonly NotEq: "!eq";
    readonly OneOf: "oneOf";
    readonly NotOneOf: "!oneOf";
    readonly ContainsAllOf: "containsAllOf";
    readonly ContainsAnyOf: "containsAnyOf";
    readonly ContainsNoneOf: "containsNoneOf";
    readonly StartsWith: "startsWith";
    readonly NotStartsWith: "!startsWith";
    readonly EndsWith: "endsWith";
    readonly NotEndsWith: "!endsWith";
    readonly Contains: "contains";
    readonly NotContains: "!contains";
    readonly Ex: "ex";
    readonly NotEx: "!ex";
    readonly Gt: "gt";
    readonly Gte: "gte";
    readonly Lt: "lt";
    readonly Lte: "lte";
    readonly Regex: "regex";
    readonly NotRegex: "!regex";
    readonly Before: "before";
    readonly After: "after";
};
export type CreateFlagCmp = ClosedEnum<typeof CreateFlagCmp>;
export type Rhs2 = {
    type?: any | undefined;
    pattern: string;
    flags: string;
};
export declare const CreateFlagRhsType: {
    readonly ListInline: "list/inline";
    readonly List: "list";
};
export type CreateFlagRhsType = ClosedEnum<typeof CreateFlagRhsType>;
export type CreateFlagItems2 = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
export type CreateFlagItems1 = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
export type CreateFlagRhsItems = CreateFlagItems1 | CreateFlagItems2;
export type Rhs1 = {
    type: CreateFlagRhsType;
    items: Array<CreateFlagItems1 | CreateFlagItems2>;
};
export type CreateFlagRhs = Rhs2 | Rhs1 | string | number | boolean;
export type CreateFlagCmpOptions = {
    ignoreCase?: boolean | undefined;
};
export type CreateFlagConditions = {
    lhs: CreateFlagLhs2 | CreateFlagLhs1;
    cmp: CreateFlagCmp;
    rhs?: Rhs2 | Rhs1 | string | number | boolean | undefined;
    cmpOptions?: CreateFlagCmpOptions | undefined;
};
export type CreateFlagOutcomeFeatureFlagsBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type CreateFlagOutcomeSlots = {
    /**
     * 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 type CreateFlagOutcome3 = {
    type?: any | undefined;
    base: CreateFlagOutcomeFeatureFlagsBase;
    /**
     * 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: Array<CreateFlagOutcomeSlots>;
};
export type CreateFlagOutcomeBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type CreateFlagOutcome2 = {
    type?: any | undefined;
    base: CreateFlagOutcomeBase;
    /**
     * The distribution for each variant
     */
    weights: {
        [k: string]: number;
    };
    /**
     * This variant will be used when the base attribute does not exist
     */
    defaultVariantId: string;
};
export type CreateFlagOutcome1 = {
    type?: any | undefined;
    variantId: string;
};
export type CreateFlagOutcome = CreateFlagOutcome3 | CreateFlagOutcome2 | CreateFlagOutcome1;
export type CreateFlagRules = {
    id: string;
    conditions: Array<CreateFlagConditions>;
    outcome: CreateFlagOutcome3 | CreateFlagOutcome2 | CreateFlagOutcome1;
};
export type CreateFlagFallthroughFeatureFlagsBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type FallthroughSlots = {
    /**
     * 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 type CreateFlagFallthrough3 = {
    type?: any | undefined;
    base: CreateFlagFallthroughFeatureFlagsBase;
    /**
     * 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: Array<FallthroughSlots>;
};
export type CreateFlagFallthroughBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type CreateFlagFallthrough2 = {
    type?: any | undefined;
    base: CreateFlagFallthroughBase;
    /**
     * The distribution for each variant
     */
    weights: {
        [k: string]: number;
    };
    /**
     * This variant will be used when the base attribute does not exist
     */
    defaultVariantId: string;
};
export type CreateFlagFallthrough1 = {
    type?: any | undefined;
    variantId: string;
};
export type CreateFlagFallthrough = CreateFlagFallthrough3 | CreateFlagFallthrough2 | CreateFlagFallthrough1;
export type CreateFlagEnvironments = {
    active: boolean;
    /**
     * Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration
     */
    reuse?: CreateFlagReuse | undefined;
    /**
     * Allows assigning targets to variants while bypassing the flag's rules
     */
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<CreateFlagTargets>;
            };
        };
    } | undefined;
    pausedOutcome: CreateFlagPausedOutcome;
    rules: Array<CreateFlagRules>;
    fallthrough: CreateFlagFallthrough3 | CreateFlagFallthrough2 | CreateFlagFallthrough1;
    /**
     * The revision of the environment config
     */
    revision?: number | undefined;
};
export declare const CreateFlagState: {
    readonly Active: "active";
    readonly Archived: "archived";
};
export type CreateFlagState = ClosedEnum<typeof CreateFlagState>;
export type CreateFlagRequestBody = {
    /**
     * A unique (per project) key for the flag, composed of letters, numbers, dashes, and underscores
     */
    slug: string;
    /**
     * The kind of flag
     */
    kind: CreateFlagKind;
    /**
     * The variants of the flag
     */
    variants?: Array<CreateFlagVariants> | undefined;
    /**
     * The configuration for the flag in different environments
     */
    environments: {
        [k: string]: CreateFlagEnvironments;
    };
    /**
     * A random seed to prevent split points in different flags from having the same targets
     */
    seed?: number | undefined;
    /**
     * A description of the flag
     */
    description?: string | undefined;
    state?: CreateFlagState | undefined;
    /**
     * The user ids of the maintainers of the flag
     */
    maintainerIds?: Array<string> | undefined;
    /**
     * Whether this flag is marked as permanent, indicating it should not be removed
     */
    permanent?: boolean | undefined;
    /**
     * Tags for categorizing the flag
     */
    tags?: Array<string> | undefined;
};
export type CreateFlagRequest = {
    /**
     * The project id or name
     */
    projectIdOrName: string;
    /**
     * The Team identifier to perform the request on behalf of.
     */
    teamId?: string | undefined;
    /**
     * The Team slug to perform the request on behalf of.
     */
    slug?: string | undefined;
    requestBody?: CreateFlagRequestBody | undefined;
};
export declare const CreateFlagMetricType: {
    readonly Count: "count";
    readonly Currency: "currency";
    readonly Percentage: "percentage";
};
export type CreateFlagMetricType = ClosedEnum<typeof CreateFlagMetricType>;
export declare const CreateFlagMetricUnit: {
    readonly Session: "session";
    readonly User: "user";
    readonly Visitor: "visitor";
};
export type CreateFlagMetricUnit = ClosedEnum<typeof CreateFlagMetricUnit>;
export declare const CreateFlagDirectionality: {
    readonly DecreaseIsGood: "decreaseIsGood";
    readonly IncreaseIsGood: "increaseIsGood";
};
export type CreateFlagDirectionality = ClosedEnum<typeof CreateFlagDirectionality>;
export type CreateFlagGuardrailMetrics = {
    description?: string | undefined;
    metricFormula?: string | undefined;
    name: string;
    metricType: CreateFlagMetricType;
    metricUnit: CreateFlagMetricUnit;
    directionality: CreateFlagDirectionality;
};
export declare const CreateFlagDevice: {
    readonly Android: "android";
    readonly Desktop: "desktop";
    readonly Ios: "ios";
    readonly Mweb: "mweb";
};
export type CreateFlagDevice = ClosedEnum<typeof CreateFlagDevice>;
export declare const CreateFlagDurationUnit: {
    readonly Days: "days";
    readonly Exposures: "exposures";
};
export type CreateFlagDurationUnit = ClosedEnum<typeof CreateFlagDurationUnit>;
export declare const CreateFlagAllocationUnit: {
    readonly CookieId: "cookieId";
    readonly UserId: "userId";
    readonly VisitorId: "visitorId";
};
export type CreateFlagAllocationUnit = ClosedEnum<typeof CreateFlagAllocationUnit>;
export declare const CreateFlagFeatureFlagsMetricType: {
    readonly Count: "count";
    readonly Currency: "currency";
    readonly Percentage: "percentage";
};
export type CreateFlagFeatureFlagsMetricType = ClosedEnum<typeof CreateFlagFeatureFlagsMetricType>;
export declare const CreateFlagFeatureFlagsMetricUnit: {
    readonly Session: "session";
    readonly User: "user";
    readonly Visitor: "visitor";
};
export type CreateFlagFeatureFlagsMetricUnit = ClosedEnum<typeof CreateFlagFeatureFlagsMetricUnit>;
export declare const CreateFlagFeatureFlagsDirectionality: {
    readonly DecreaseIsGood: "decreaseIsGood";
    readonly IncreaseIsGood: "increaseIsGood";
};
export type CreateFlagFeatureFlagsDirectionality = ClosedEnum<typeof CreateFlagFeatureFlagsDirectionality>;
export type CreateFlagPrimaryMetrics = {
    description?: string | undefined;
    metricFormula?: string | undefined;
    name: string;
    metricType: CreateFlagFeatureFlagsMetricType;
    metricUnit: CreateFlagFeatureFlagsMetricUnit;
    directionality: CreateFlagFeatureFlagsDirectionality;
};
export declare const CreateFlagStatus: {
    readonly Closed: "closed";
    readonly Draft: "draft";
    readonly Paused: "paused";
    readonly Running: "running";
};
export type CreateFlagStatus = ClosedEnum<typeof CreateFlagStatus>;
export type CreateFlagExperiment = {
    id?: string | undefined;
    name?: string | undefined;
    numVariants?: number | undefined;
    surfaceArea?: string | undefined;
    stickyRequirement?: boolean | undefined;
    layer?: string | undefined;
    guardrailMetrics?: Array<CreateFlagGuardrailMetrics> | undefined;
    hypothesis?: string | undefined;
    device?: CreateFlagDevice | undefined;
    controlVariantId?: string | undefined;
    startedAt?: number | undefined;
    endedAt?: number | undefined;
    decision?: string | undefined;
    decisionReason?: string | undefined;
    duration?: number | undefined;
    durationUnit?: CreateFlagDurationUnit | undefined;
    allocationPercent?: number | undefined;
    allocationUnit: CreateFlagAllocationUnit;
    primaryMetrics: Array<CreateFlagPrimaryMetrics>;
    status: CreateFlagStatus;
};
export type CreateFlagFeatureFlagsVariants = {};
export type CreateFlagFeatureFlagsReuse = {
    active: boolean;
    environment: string;
};
export type CreateFlagFeatureFlagsTargets = {
    note?: string | undefined;
    value: string;
};
export declare const CreateFlagType: {
    readonly Variant: "variant";
};
export type CreateFlagType = ClosedEnum<typeof CreateFlagType>;
export type CreateFlagFeatureFlagsPausedOutcome = {
    type: CreateFlagType;
    variantId: string;
};
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType: {
    readonly Entity: "entity";
};
export type CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType = ClosedEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType>;
export type CreateFlagFallthroughFeatureFlagsResponse201Base = {
    type: CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType;
    kind: string;
    attribute: string;
};
export type CreateFlagFallthroughSlots = {
    promille: number;
    durationMs: number;
};
export type CreateFlagFallthroughFeatureFlags3 = {
    type: "rollout";
    base: CreateFlagFallthroughFeatureFlagsResponse201Base;
    defaultVariantId: string;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    slots: Array<CreateFlagFallthroughSlots>;
};
export declare const CreateFlagFallthroughFeatureFlagsResponse201Type: {
    readonly Entity: "entity";
};
export type CreateFlagFallthroughFeatureFlagsResponse201Type = ClosedEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201Type>;
export type CreateFlagFallthroughFeatureFlagsResponseBase = {
    type: CreateFlagFallthroughFeatureFlagsResponse201Type;
    kind: string;
    attribute: string;
};
export type CreateFlagFallthroughFeatureFlags2 = {
    type: "split";
    base: CreateFlagFallthroughFeatureFlagsResponseBase;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
export type CreateFlagFallthroughFeatureFlags1 = {
    type: "variant";
    variantId: string;
};
export type CreateFlagFeatureFlagsFallthrough = CreateFlagFallthroughFeatureFlags1 | CreateFlagFallthroughFeatureFlags2 | CreateFlagFallthroughFeatureFlags3;
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType: {
    readonly Entity: "entity";
};
export type CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType = ClosedEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType>;
export type CreateFlagOutcomeFeatureFlagsResponse201Base = {
    type: CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType;
    kind: string;
    attribute: string;
};
export type CreateFlagOutcomeFeatureFlagsSlots = {
    promille: number;
    durationMs: number;
};
export type CreateFlagOutcomeFeatureFlags3 = {
    type: "rollout";
    base: CreateFlagOutcomeFeatureFlagsResponse201Base;
    defaultVariantId: string;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    slots: Array<CreateFlagOutcomeFeatureFlagsSlots>;
};
export declare const CreateFlagOutcomeFeatureFlagsResponse201Type: {
    readonly Entity: "entity";
};
export type CreateFlagOutcomeFeatureFlagsResponse201Type = ClosedEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201Type>;
export type CreateFlagOutcomeFeatureFlagsResponseBase = {
    type: CreateFlagOutcomeFeatureFlagsResponse201Type;
    kind: string;
    attribute: string;
};
export type CreateFlagOutcomeFeatureFlags2 = {
    type: "split";
    base: CreateFlagOutcomeFeatureFlagsResponseBase;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
export type CreateFlagOutcomeFeatureFlags1 = {
    type: "variant";
    variantId: string;
};
export type CreateFlagFeatureFlagsOutcome = CreateFlagOutcomeFeatureFlags1 | CreateFlagOutcomeFeatureFlags2 | CreateFlagOutcomeFeatureFlags3;
export declare const CreateFlagRhsFeatureFlagsResponseType: {
    readonly Regex: "regex";
};
export type CreateFlagRhsFeatureFlagsResponseType = ClosedEnum<typeof CreateFlagRhsFeatureFlagsResponseType>;
export type CreateFlagRhs4 = {
    type: CreateFlagRhsFeatureFlagsResponseType;
    pattern: string;
    flags: string;
};
export declare const CreateFlagRhsFeatureFlagsType: {
    readonly List: "list";
    readonly ListInline: "list/inline";
};
export type CreateFlagRhsFeatureFlagsType = ClosedEnum<typeof CreateFlagRhsFeatureFlagsType>;
export type CreateFlagItemsFeatureFlags2 = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
export type CreateFlagItemsFeatureFlags1 = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
export type CreateFlagRhsFeatureFlagsItems = CreateFlagItemsFeatureFlags1 | CreateFlagItemsFeatureFlags2;
export type CreateFlagRhs3 = {
    type: CreateFlagRhsFeatureFlagsType;
    items: Array<CreateFlagItemsFeatureFlags1 | CreateFlagItemsFeatureFlags2>;
};
export type CreateFlagFeatureFlagsRhs = CreateFlagRhs4 | CreateFlagRhs3 | string | number | boolean;
export type CreateFlagFeatureFlagsCmpOptions = {
    ignoreCase?: boolean | undefined;
};
export type CreateFlagLhsFeatureFlags2 = {
    type: "entity";
    kind: string;
    attribute: string;
};
export type CreateFlagLhsFeatureFlags1 = {
    type: "segment";
};
export type CreateFlagFeatureFlagsLhs = CreateFlagLhsFeatureFlags1 | CreateFlagLhsFeatureFlags2;
export declare const CreateFlagFeatureFlagsCmp: {
    readonly NotContains: "!contains";
    readonly NotEndsWith: "!endsWith";
    readonly NotEq: "!eq";
    readonly NotEx: "!ex";
    readonly NotOneOf: "!oneOf";
    readonly NotRegex: "!regex";
    readonly NotStartsWith: "!startsWith";
    readonly After: "after";
    readonly Before: "before";
    readonly Contains: "contains";
    readonly ContainsAllOf: "containsAllOf";
    readonly ContainsAnyOf: "containsAnyOf";
    readonly ContainsNoneOf: "containsNoneOf";
    readonly EndsWith: "endsWith";
    readonly Eq: "eq";
    readonly Ex: "ex";
    readonly Gt: "gt";
    readonly Gte: "gte";
    readonly Lt: "lt";
    readonly Lte: "lte";
    readonly OneOf: "oneOf";
    readonly Regex: "regex";
    readonly StartsWith: "startsWith";
};
export type CreateFlagFeatureFlagsCmp = ClosedEnum<typeof CreateFlagFeatureFlagsCmp>;
export type CreateFlagFeatureFlagsConditions = {
    rhs?: CreateFlagRhs4 | CreateFlagRhs3 | string | number | boolean | undefined;
    cmpOptions?: CreateFlagFeatureFlagsCmpOptions | undefined;
    lhs: CreateFlagLhsFeatureFlags1 | CreateFlagLhsFeatureFlags2;
    cmp: CreateFlagFeatureFlagsCmp;
};
export type CreateFlagFeatureFlagsRules = {
    id: string;
    outcome: CreateFlagOutcomeFeatureFlags1 | CreateFlagOutcomeFeatureFlags2 | CreateFlagOutcomeFeatureFlags3;
    conditions: Array<CreateFlagFeatureFlagsConditions>;
};
export type CreateFlagFeatureFlagsEnvironments = {
    reuse?: CreateFlagFeatureFlagsReuse | undefined;
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<CreateFlagFeatureFlagsTargets>;
            };
        };
    } | undefined;
    revision?: number | undefined;
    pausedOutcome: CreateFlagFeatureFlagsPausedOutcome;
    fallthrough: CreateFlagFallthroughFeatureFlags1 | CreateFlagFallthroughFeatureFlags2 | CreateFlagFallthroughFeatureFlags3;
    active: boolean;
    rules: Array<CreateFlagFeatureFlagsRules>;
};
export declare const CreateFlagFeatureFlagsKind: {
    readonly Boolean: "boolean";
    readonly Json: "json";
    readonly Number: "number";
    readonly String: "string";
};
export type CreateFlagFeatureFlagsKind = ClosedEnum<typeof CreateFlagFeatureFlagsKind>;
export declare const CreateFlagFeatureFlagsState: {
    readonly Active: "active";
    readonly Archived: "archived";
};
export type CreateFlagFeatureFlagsState = ClosedEnum<typeof CreateFlagFeatureFlagsState>;
export declare const CreateFlagTypeName: {
    readonly Flag: "flag";
};
export type CreateFlagTypeName = ClosedEnum<typeof CreateFlagTypeName>;
export type CreateFlagResponseBody = {
    description?: string | undefined;
    maintainerIds?: Array<string> | undefined;
    permanent?: boolean | undefined;
    tags?: Array<string> | undefined;
    experiment?: CreateFlagExperiment | undefined;
    variants: Array<CreateFlagFeatureFlagsVariants>;
    id: string;
    environments: {
        [k: string]: CreateFlagFeatureFlagsEnvironments;
    };
    kind: CreateFlagFeatureFlagsKind;
    revision: number;
    seed: number;
    state: CreateFlagFeatureFlagsState;
    slug: string;
    createdAt: number;
    updatedAt: number;
    createdBy: string;
    ownerId: string;
    projectId: string;
    typeName: CreateFlagTypeName;
};
/** @internal */
export declare const CreateFlagKind$outboundSchema: z.ZodNativeEnum<typeof CreateFlagKind>;
/** @internal */
export type Value4$Outbound = {};
/** @internal */
export declare const Value4$outboundSchema: z.ZodType<Value4$Outbound, z.ZodTypeDef, Value4>;
export declare function value4ToJSON(value4: Value4): string;
/** @internal */
export type CreateFlagVariants$Outbound = {
    id: string;
    label?: string | undefined;
    description?: string | undefined;
    value?: any | undefined;
};
/** @internal */
export declare const CreateFlagVariants$outboundSchema: z.ZodType<CreateFlagVariants$Outbound, z.ZodTypeDef, CreateFlagVariants>;
export declare function createFlagVariantsToJSON(createFlagVariants: CreateFlagVariants): string;
/** @internal */
export type CreateFlagReuse$Outbound = {
    active: boolean;
    environment: string;
};
/** @internal */
export declare const CreateFlagReuse$outboundSchema: z.ZodType<CreateFlagReuse$Outbound, z.ZodTypeDef, CreateFlagReuse>;
export declare function createFlagReuseToJSON(createFlagReuse: CreateFlagReuse): string;
/** @internal */
export type CreateFlagTargets$Outbound = {
    note?: string | undefined;
    value: string;
};
/** @internal */
export declare const CreateFlagTargets$outboundSchema: z.ZodType<CreateFlagTargets$Outbound, z.ZodTypeDef, CreateFlagTargets>;
export declare function createFlagTargetsToJSON(createFlagTargets: CreateFlagTargets): string;
/** @internal */
export type CreateFlagPausedOutcome$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const CreateFlagPausedOutcome$outboundSchema: z.ZodType<CreateFlagPausedOutcome$Outbound, z.ZodTypeDef, CreateFlagPausedOutcome>;
export declare function createFlagPausedOutcomeToJSON(createFlagPausedOutcome: CreateFlagPausedOutcome): string;
/** @internal */
export type CreateFlagLhs2$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const CreateFlagLhs2$outboundSchema: z.ZodType<CreateFlagLhs2$Outbound, z.ZodTypeDef, CreateFlagLhs2>;
export declare function createFlagLhs2ToJSON(createFlagLhs2: CreateFlagLhs2): string;
/** @internal */
export type CreateFlagLhs1$Outbound = {
    type?: any | undefined;
};
/** @internal */
export declare const CreateFlagLhs1$outboundSchema: z.ZodType<CreateFlagLhs1$Outbound, z.ZodTypeDef, CreateFlagLhs1>;
export declare function createFlagLhs1ToJSON(createFlagLhs1: CreateFlagLhs1): string;
/** @internal */
export type CreateFlagLhs$Outbound = CreateFlagLhs2$Outbound | CreateFlagLhs1$Outbound;
/** @internal */
export declare const CreateFlagLhs$outboundSchema: z.ZodType<CreateFlagLhs$Outbound, z.ZodTypeDef, CreateFlagLhs>;
export declare function createFlagLhsToJSON(createFlagLhs: CreateFlagLhs): string;
/** @internal */
export declare const CreateFlagCmp$outboundSchema: z.ZodNativeEnum<typeof CreateFlagCmp>;
/** @internal */
export type Rhs2$Outbound = {
    type?: any | undefined;
    pattern: string;
    flags: string;
};
/** @internal */
export declare const Rhs2$outboundSchema: z.ZodType<Rhs2$Outbound, z.ZodTypeDef, Rhs2>;
export declare function rhs2ToJSON(rhs2: Rhs2): string;
/** @internal */
export declare const CreateFlagRhsType$outboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsType>;
/** @internal */
export type CreateFlagItems2$Outbound = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
/** @internal */
export declare const CreateFlagItems2$outboundSchema: z.ZodType<CreateFlagItems2$Outbound, z.ZodTypeDef, CreateFlagItems2>;
export declare function createFlagItems2ToJSON(createFlagItems2: CreateFlagItems2): string;
/** @internal */
export type CreateFlagItems1$Outbound = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
/** @internal */
export declare const CreateFlagItems1$outboundSchema: z.ZodType<CreateFlagItems1$Outbound, z.ZodTypeDef, CreateFlagItems1>;
export declare function createFlagItems1ToJSON(createFlagItems1: CreateFlagItems1): string;
/** @internal */
export type CreateFlagRhsItems$Outbound = CreateFlagItems1$Outbound | CreateFlagItems2$Outbound;
/** @internal */
export declare const CreateFlagRhsItems$outboundSchema: z.ZodType<CreateFlagRhsItems$Outbound, z.ZodTypeDef, CreateFlagRhsItems>;
export declare function createFlagRhsItemsToJSON(createFlagRhsItems: CreateFlagRhsItems): string;
/** @internal */
export type Rhs1$Outbound = {
    type: string;
    items: Array<CreateFlagItems1$Outbound | CreateFlagItems2$Outbound>;
};
/** @internal */
export declare const Rhs1$outboundSchema: z.ZodType<Rhs1$Outbound, z.ZodTypeDef, Rhs1>;
export declare function rhs1ToJSON(rhs1: Rhs1): string;
/** @internal */
export type CreateFlagRhs$Outbound = Rhs2$Outbound | Rhs1$Outbound | string | number | boolean;
/** @internal */
export declare const CreateFlagRhs$outboundSchema: z.ZodType<CreateFlagRhs$Outbound, z.ZodTypeDef, CreateFlagRhs>;
export declare function createFlagRhsToJSON(createFlagRhs: CreateFlagRhs): string;
/** @internal */
export type CreateFlagCmpOptions$Outbound = {
    ignoreCase?: boolean | undefined;
};
/** @internal */
export declare const CreateFlagCmpOptions$outboundSchema: z.ZodType<CreateFlagCmpOptions$Outbound, z.ZodTypeDef, CreateFlagCmpOptions>;
export declare function createFlagCmpOptionsToJSON(createFlagCmpOptions: CreateFlagCmpOptions): string;
/** @internal */
export type CreateFlagConditions$Outbound = {
    lhs: CreateFlagLhs2$Outbound | CreateFlagLhs1$Outbound;
    cmp: string;
    rhs?: Rhs2$Outbound | Rhs1$Outbound | string | number | boolean | undefined;
    cmpOptions?: CreateFlagCmpOptions$Outbound | undefined;
};
/** @internal */
export declare const CreateFlagConditions$outboundSchema: z.ZodType<CreateFlagConditions$Outbound, z.ZodTypeDef, CreateFlagConditions>;
export declare function createFlagConditionsToJSON(createFlagConditions: CreateFlagConditions): string;
/** @internal */
export type CreateFlagOutcomeFeatureFlagsBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsBase$outboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsBase$Outbound, z.ZodTypeDef, CreateFlagOutcomeFeatureFlagsBase>;
export declare function createFlagOutcomeFeatureFlagsBaseToJSON(createFlagOutcomeFeatureFlagsBase: CreateFlagOutcomeFeatureFlagsBase): string;
/** @internal */
export type CreateFlagOutcomeSlots$Outbound = {
    promille: number;
    durationMs: number;
};
/** @internal */
export declare const CreateFlagOutcomeSlots$outboundSchema: z.ZodType<CreateFlagOutcomeSlots$Outbound, z.ZodTypeDef, CreateFlagOutcomeSlots>;
export declare function createFlagOutcomeSlotsToJSON(createFlagOutcomeSlots: CreateFlagOutcomeSlots): string;
/** @internal */
export type CreateFlagOutcome3$Outbound = {
    type?: any | undefined;
    base: CreateFlagOutcomeFeatureFlagsBase$Outbound;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    defaultVariantId: string;
    slots: Array<CreateFlagOutcomeSlots$Outbound>;
};
/** @internal */
export declare const CreateFlagOutcome3$outboundSchema: z.ZodType<CreateFlagOutcome3$Outbound, z.ZodTypeDef, CreateFlagOutcome3>;
export declare function createFlagOutcome3ToJSON(createFlagOutcome3: CreateFlagOutcome3): string;
/** @internal */
export type CreateFlagOutcomeBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const CreateFlagOutcomeBase$outboundSchema: z.ZodType<CreateFlagOutcomeBase$Outbound, z.ZodTypeDef, CreateFlagOutcomeBase>;
export declare function createFlagOutcomeBaseToJSON(createFlagOutcomeBase: CreateFlagOutcomeBase): string;
/** @internal */
export type CreateFlagOutcome2$Outbound = {
    type?: any | undefined;
    base: CreateFlagOutcomeBase$Outbound;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
/** @internal */
export declare const CreateFlagOutcome2$outboundSchema: z.ZodType<CreateFlagOutcome2$Outbound, z.ZodTypeDef, CreateFlagOutcome2>;
export declare function createFlagOutcome2ToJSON(createFlagOutcome2: CreateFlagOutcome2): string;
/** @internal */
export type CreateFlagOutcome1$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const CreateFlagOutcome1$outboundSchema: z.ZodType<CreateFlagOutcome1$Outbound, z.ZodTypeDef, CreateFlagOutcome1>;
export declare function createFlagOutcome1ToJSON(createFlagOutcome1: CreateFlagOutcome1): string;
/** @internal */
export type CreateFlagOutcome$Outbound = CreateFlagOutcome3$Outbound | CreateFlagOutcome2$Outbound | CreateFlagOutcome1$Outbound;
/** @internal */
export declare const CreateFlagOutcome$outboundSchema: z.ZodType<CreateFlagOutcome$Outbound, z.ZodTypeDef, CreateFlagOutcome>;
export declare function createFlagOutcomeToJSON(createFlagOutcome: CreateFlagOutcome): string;
/** @internal */
export type CreateFlagRules$Outbound = {
    id: string;
    conditions: Array<CreateFlagConditions$Outbound>;
    outcome: CreateFlagOutcome3$Outbound | CreateFlagOutcome2$Outbound | CreateFlagOutcome1$Outbound;
};
/** @internal */
export declare const CreateFlagRules$outboundSchema: z.ZodType<CreateFlagRules$Outbound, z.ZodTypeDef, CreateFlagRules>;
export declare function createFlagRulesToJSON(createFlagRules: CreateFlagRules): string;
/** @internal */
export type CreateFlagFallthroughFeatureFlagsBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsBase$outboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsBase$Outbound, z.ZodTypeDef, CreateFlagFallthroughFeatureFlagsBase>;
export declare function createFlagFallthroughFeatureFlagsBaseToJSON(createFlagFallthroughFeatureFlagsBase: CreateFlagFallthroughFeatureFlagsBase): string;
/** @internal */
export type FallthroughSlots$Outbound = {
    promille: number;
    durationMs: number;
};
/** @internal */
export declare const FallthroughSlots$outboundSchema: z.ZodType<FallthroughSlots$Outbound, z.ZodTypeDef, FallthroughSlots>;
export declare function fallthroughSlotsToJSON(fallthroughSlots: FallthroughSlots): string;
/** @internal */
export type CreateFlagFallthrough3$Outbound = {
    type?: any | undefined;
    base: CreateFlagFallthroughFeatureFlagsBase$Outbound;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    defaultVariantId: string;
    slots: Array<FallthroughSlots$Outbound>;
};
/** @internal */
export declare const CreateFlagFallthrough3$outboundSchema: z.ZodType<CreateFlagFallthrough3$Outbound, z.ZodTypeDef, CreateFlagFallthrough3>;
export declare function createFlagFallthrough3ToJSON(createFlagFallthrough3: CreateFlagFallthrough3): string;
/** @internal */
export type CreateFlagFallthroughBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const CreateFlagFallthroughBase$outboundSchema: z.ZodType<CreateFlagFallthroughBase$Outbound, z.ZodTypeDef, CreateFlagFallthroughBase>;
export declare function createFlagFallthroughBaseToJSON(createFlagFallthroughBase: CreateFlagFallthroughBase): string;
/** @internal */
export type CreateFlagFallthrough2$Outbound = {
    type?: any | undefined;
    base: CreateFlagFallthroughBase$Outbound;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
/** @internal */
export declare const CreateFlagFallthrough2$outboundSchema: z.ZodType<CreateFlagFallthrough2$Outbound, z.ZodTypeDef, CreateFlagFallthrough2>;
export declare function createFlagFallthrough2ToJSON(createFlagFallthrough2: CreateFlagFallthrough2): string;
/** @internal */
export type CreateFlagFallthrough1$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const CreateFlagFallthrough1$outboundSchema: z.ZodType<CreateFlagFallthrough1$Outbound, z.ZodTypeDef, CreateFlagFallthrough1>;
export declare function createFlagFallthrough1ToJSON(createFlagFallthrough1: CreateFlagFallthrough1): string;
/** @internal */
export type CreateFlagFallthrough$Outbound = CreateFlagFallthrough3$Outbound | CreateFlagFallthrough2$Outbound | CreateFlagFallthrough1$Outbound;
/** @internal */
export declare const CreateFlagFallthrough$outboundSchema: z.ZodType<CreateFlagFallthrough$Outbound, z.ZodTypeDef, CreateFlagFallthrough>;
export declare function createFlagFallthroughToJSON(createFlagFallthrough: CreateFlagFallthrough): string;
/** @internal */
export type CreateFlagEnvironments$Outbound = {
    active: boolean;
    reuse?: CreateFlagReuse$Outbound | undefined;
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<CreateFlagTargets$Outbound>;
            };
        };
    } | undefined;
    pausedOutcome: CreateFlagPausedOutcome$Outbound;
    rules: Array<CreateFlagRules$Outbound>;
    fallthrough: CreateFlagFallthrough3$Outbound | CreateFlagFallthrough2$Outbound | CreateFlagFallthrough1$Outbound;
    revision?: number | undefined;
};
/** @internal */
export declare const CreateFlagEnvironments$outboundSchema: z.ZodType<CreateFlagEnvironments$Outbound, z.ZodTypeDef, CreateFlagEnvironments>;
export declare function createFlagEnvironmentsToJSON(createFlagEnvironments: CreateFlagEnvironments): string;
/** @internal */
export declare const CreateFlagState$outboundSchema: z.ZodNativeEnum<typeof CreateFlagState>;
/** @internal */
export type CreateFlagRequestBody$Outbound = {
    slug: string;
    kind: string;
    variants?: Array<CreateFlagVariants$Outbound> | undefined;
    environments: {
        [k: string]: CreateFlagEnvironments$Outbound;
    };
    seed?: number | undefined;
    description?: string | undefined;
    state?: string | undefined;
    maintainerIds?: Array<string> | undefined;
    permanent?: boolean | undefined;
    tags?: Array<string> | undefined;
};
/** @internal */
export declare const CreateFlagRequestBody$outboundSchema: z.ZodType<CreateFlagRequestBody$Outbound, z.ZodTypeDef, CreateFlagRequestBody>;
export declare function createFlagRequestBodyToJSON(createFlagRequestBody: CreateFlagRequestBody): string;
/** @internal */
export type CreateFlagRequest$Outbound = {
    projectIdOrName: string;
    teamId?: string | undefined;
    slug?: string | undefined;
    RequestBody?: CreateFlagRequestBody$Outbound | undefined;
};
/** @internal */
export declare const CreateFlagRequest$outboundSchema: z.ZodType<CreateFlagRequest$Outbound, z.ZodTypeDef, CreateFlagRequest>;
export declare function createFlagRequestToJSON(createFlagRequest: CreateFlagRequest): string;
/** @internal */
export declare const CreateFlagMetricType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagMetricType>;
/** @internal */
export declare const CreateFlagMetricUnit$inboundSchema: z.ZodNativeEnum<typeof CreateFlagMetricUnit>;
/** @internal */
export declare const CreateFlagDirectionality$inboundSchema: z.ZodNativeEnum<typeof CreateFlagDirectionality>;
/** @internal */
export declare const CreateFlagGuardrailMetrics$inboundSchema: z.ZodType<CreateFlagGuardrailMetrics, z.ZodTypeDef, unknown>;
export declare function createFlagGuardrailMetricsFromJSON(jsonString: string): SafeParseResult<CreateFlagGuardrailMetrics, SDKValidationError>;
/** @internal */
export declare const CreateFlagDevice$inboundSchema: z.ZodNativeEnum<typeof CreateFlagDevice>;
/** @internal */
export declare const CreateFlagDurationUnit$inboundSchema: z.ZodNativeEnum<typeof CreateFlagDurationUnit>;
/** @internal */
export declare const CreateFlagAllocationUnit$inboundSchema: z.ZodNativeEnum<typeof CreateFlagAllocationUnit>;
/** @internal */
export declare const CreateFlagFeatureFlagsMetricType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsMetricType>;
/** @internal */
export declare const CreateFlagFeatureFlagsMetricUnit$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsMetricUnit>;
/** @internal */
export declare const CreateFlagFeatureFlagsDirectionality$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsDirectionality>;
/** @internal */
export declare const CreateFlagPrimaryMetrics$inboundSchema: z.ZodType<CreateFlagPrimaryMetrics, z.ZodTypeDef, unknown>;
export declare function createFlagPrimaryMetricsFromJSON(jsonString: string): SafeParseResult<CreateFlagPrimaryMetrics, SDKValidationError>;
/** @internal */
export declare const CreateFlagStatus$inboundSchema: z.ZodNativeEnum<typeof CreateFlagStatus>;
/** @internal */
export declare const CreateFlagExperiment$inboundSchema: z.ZodType<CreateFlagExperiment, z.ZodTypeDef, unknown>;
export declare function createFlagExperimentFromJSON(jsonString: string): SafeParseResult<CreateFlagExperiment, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsVariants$inboundSchema: z.ZodType<CreateFlagFeatureFlagsVariants, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsVariantsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsVariants, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsReuse$inboundSchema: z.ZodType<CreateFlagFeatureFlagsReuse, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsReuseFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsReuse, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsTargets$inboundSchema: z.ZodType<CreateFlagFeatureFlagsTargets, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsTargetsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsTargets, SDKValidationError>;
/** @internal */
export declare const CreateFlagType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagType>;
/** @internal */
export declare const CreateFlagFeatureFlagsPausedOutcome$inboundSchema: z.ZodType<CreateFlagFeatureFlagsPausedOutcome, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsPausedOutcomeFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsPausedOutcome, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201Base$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsResponse201Base, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlagsResponse201BaseFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlagsResponse201Base, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughSlots$inboundSchema: z.ZodType<CreateFlagFallthroughSlots, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughSlotsFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughSlots, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags3$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags3FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201Type$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201Type>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponseBase$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags2$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags1$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsFallthrough$inboundSchema: z.ZodType<CreateFlagFeatureFlagsFallthrough, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsFallthroughFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsFallthrough, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201Base$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsResponse201Base, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsResponse201BaseFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsResponse201Base, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsSlots$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsSlots, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsSlotsFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsSlots, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags3$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags3FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201Type$inboundSchema: z.ZodNativeEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201Type>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponseBase$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags2$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags1$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsOutcome$inboundSchema: z.ZodType<CreateFlagFeatureFlagsOutcome, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsOutcomeFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsOutcome, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsFeatureFlagsResponseType>;
/** @internal */
export declare const CreateFlagRhs4$inboundSchema: z.ZodType<CreateFlagRhs4, z.ZodTypeDef, unknown>;
export declare function createFlagRhs4FromJSON(jsonString: string): SafeParseResult<CreateFlagRhs4, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsFeatureFlagsType>;
/** @internal */
export declare const CreateFlagItemsFeatureFlags2$inboundSchema: z.ZodType<CreateFlagItemsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagItemsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagItemsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagItemsFeatureFlags1$inboundSchema: z.ZodType<CreateFlagItemsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagItemsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagItemsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsItems$inboundSchema: z.ZodType<CreateFlagRhsFeatureFlagsItems, z.ZodTypeDef, unknown>;
export declare function createFlagRhsFeatureFlagsItemsFromJSON(jsonString: string): SafeParseResult<CreateFlagRhsFeatureFlagsItems, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhs3$inboundSchema: z.ZodType<CreateFlagRhs3, z.ZodTypeDef, unknown>;
export declare function createFlagRhs3FromJSON(jsonString: string): SafeParseResult<CreateFlagRhs3, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsRhs$inboundSchema: z.ZodType<CreateFlagFeatureFlagsRhs, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsRhsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsRhs, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsCmpOptions$inboundSchema: z.ZodType<CreateFlagFeatureFlagsCmpOptions, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsCmpOptionsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsCmpOptions, SDKValidationError>;
/** @internal */
export declare const CreateFlagLhsFeatureFlags2$inboundSchema: z.ZodType<CreateFlagLhsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagLhsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagLhsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagLhsFeatureFlags1$inboundSchema: z.ZodType<CreateFlagLhsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagLhsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagLhsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsLhs$inboundSchema: z.ZodType<CreateFlagFeatureFlagsLhs, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsLhsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsLhs, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsCmp$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsCmp>;
/** @internal */
export declare const CreateFlagFeatureFlagsConditions$inboundSchema: z.ZodType<CreateFlagFeatureFlagsConditions, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsConditionsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsConditions, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsRules$inboundSchema: z.ZodType<CreateFlagFeatureFlagsRules, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsRulesFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsRules, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsEnvironments$inboundSchema: z.ZodType<CreateFlagFeatureFlagsEnvironments, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsEnvironmentsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsEnvironments, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsKind$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsKind>;
/** @internal */
export declare const CreateFlagFeatureFlagsState$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsState>;
/** @internal */
export declare const CreateFlagTypeName$inboundSchema: z.ZodNativeEnum<typeof CreateFlagTypeName>;
/** @internal */
export declare const CreateFlagResponseBody$inboundSchema: z.ZodType<CreateFlagResponseBody, z.ZodTypeDef, unknown>;
export declare function createFlagResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateFlagResponseBody, SDKValidationError>;
//# sourceMappingURL=createflagop.d.ts.map