import * as z from "zod/v3";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { Flag } from "./flag.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
export type UpdateFlagValue4 = {};
export type UpdateFlagVariants = {
    /**
     * 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 UpdateFlagReuse = {
    /**
     * Whether the reuse is active or not
     */
    active: boolean;
    /**
     * The environment to link to
     */
    environment: string;
};
export type UpdateFlagTargets = {
    note?: string | undefined;
    value: string;
};
export type UpdateFlagPausedOutcome = {
    type?: any | undefined;
    variantId: string;
};
export type UpdateFlagLhs2 = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type UpdateFlagLhs1 = {
    type?: any | undefined;
};
export type UpdateFlagLhs = UpdateFlagLhs2 | UpdateFlagLhs1;
export declare const UpdateFlagCmp: {
    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 UpdateFlagCmp = ClosedEnum<typeof UpdateFlagCmp>;
export type UpdateFlagRhs2 = {
    type?: any | undefined;
    pattern: string;
    flags: string;
};
export declare const UpdateFlagRhsType: {
    readonly ListInline: "list/inline";
    readonly List: "list";
};
export type UpdateFlagRhsType = ClosedEnum<typeof UpdateFlagRhsType>;
export type UpdateFlagItems2 = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
export type UpdateFlagItems1 = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
export type UpdateFlagRhsItems = UpdateFlagItems1 | UpdateFlagItems2;
export type UpdateFlagRhs1 = {
    type: UpdateFlagRhsType;
    items: Array<UpdateFlagItems1 | UpdateFlagItems2>;
};
export type UpdateFlagRhs = UpdateFlagRhs2 | UpdateFlagRhs1 | string | number | boolean;
export type UpdateFlagCmpOptions = {
    ignoreCase?: boolean | undefined;
};
export type UpdateFlagConditions = {
    lhs: UpdateFlagLhs2 | UpdateFlagLhs1;
    cmp: UpdateFlagCmp;
    rhs?: UpdateFlagRhs2 | UpdateFlagRhs1 | string | number | boolean | undefined;
    cmpOptions?: UpdateFlagCmpOptions | undefined;
};
export type UpdateFlagOutcomeFeatureFlagsBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type UpdateFlagOutcomeSlots = {
    /**
     * 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 UpdateFlagOutcome3 = {
    type?: any | undefined;
    base: UpdateFlagOutcomeFeatureFlagsBase;
    /**
     * 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<UpdateFlagOutcomeSlots>;
};
export type UpdateFlagOutcomeBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type UpdateFlagOutcome2 = {
    type?: any | undefined;
    base: UpdateFlagOutcomeBase;
    /**
     * 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 UpdateFlagOutcome1 = {
    type?: any | undefined;
    variantId: string;
};
export type UpdateFlagOutcome = UpdateFlagOutcome3 | UpdateFlagOutcome2 | UpdateFlagOutcome1;
export type UpdateFlagRules = {
    id: string;
    conditions: Array<UpdateFlagConditions>;
    outcome: UpdateFlagOutcome3 | UpdateFlagOutcome2 | UpdateFlagOutcome1;
};
export type UpdateFlagFallthroughFeatureFlagsBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type UpdateFlagFallthroughSlots = {
    /**
     * 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 UpdateFlagFallthrough3 = {
    type?: any | undefined;
    base: UpdateFlagFallthroughFeatureFlagsBase;
    /**
     * 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<UpdateFlagFallthroughSlots>;
};
export type UpdateFlagFallthroughBase = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
export type UpdateFlagFallthrough2 = {
    type?: any | undefined;
    base: UpdateFlagFallthroughBase;
    /**
     * 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 UpdateFlagFallthrough1 = {
    type?: any | undefined;
    variantId: string;
};
export type UpdateFlagFallthrough = UpdateFlagFallthrough3 | UpdateFlagFallthrough2 | UpdateFlagFallthrough1;
export type UpdateFlagEnvironments = {
    active: boolean;
    /**
     * Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration
     */
    reuse?: UpdateFlagReuse | undefined;
    /**
     * Allows assigning targets to variants while bypassing the flag's rules
     */
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<UpdateFlagTargets>;
            };
        };
    } | undefined;
    pausedOutcome: UpdateFlagPausedOutcome;
    rules: Array<UpdateFlagRules>;
    fallthrough: UpdateFlagFallthrough3 | UpdateFlagFallthrough2 | UpdateFlagFallthrough1;
    /**
     * The revision of the environment config
     */
    revision?: number | undefined;
};
export declare const UpdateFlagState: {
    readonly Active: "active";
    readonly Archived: "archived";
};
export type UpdateFlagState = ClosedEnum<typeof UpdateFlagState>;
export type UpdateFlagRequestBody = {
    /**
     * The user who created this patch
     */
    createdBy?: string | undefined;
    /**
     * Additional message for this version
     */
    message?: string | undefined;
    /**
     * The variants of the flag
     */
    variants?: Array<UpdateFlagVariants> | undefined;
    /**
     * The configuration for the flag in different environments
     */
    environments?: {
        [k: string]: UpdateFlagEnvironments;
    } | undefined;
    /**
     * 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?: UpdateFlagState | 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 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 | undefined;
    /**
     * Whether to include metadata in the response
     */
    withMetadata?: boolean | undefined;
    /**
     * 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?: UpdateFlagRequestBody | undefined;
};
export declare const ResponseBodyMetricType: {
    readonly Count: "count";
    readonly Currency: "currency";
    readonly Percentage: "percentage";
};
export type ResponseBodyMetricType = ClosedEnum<typeof ResponseBodyMetricType>;
export declare const ResponseBodyMetricUnit: {
    readonly Session: "session";
    readonly User: "user";
    readonly Visitor: "visitor";
};
export type ResponseBodyMetricUnit = ClosedEnum<typeof ResponseBodyMetricUnit>;
export declare const ResponseBodyDirectionality: {
    readonly DecreaseIsGood: "decreaseIsGood";
    readonly IncreaseIsGood: "increaseIsGood";
};
export type ResponseBodyDirectionality = ClosedEnum<typeof ResponseBodyDirectionality>;
export type ResponseBodyGuardrailMetrics = {
    description?: string | undefined;
    metricFormula?: string | undefined;
    name: string;
    metricType: ResponseBodyMetricType;
    metricUnit: ResponseBodyMetricUnit;
    directionality: ResponseBodyDirectionality;
};
export declare const ResponseBodyDevice: {
    readonly Android: "android";
    readonly Desktop: "desktop";
    readonly Ios: "ios";
    readonly Mweb: "mweb";
};
export type ResponseBodyDevice = ClosedEnum<typeof ResponseBodyDevice>;
export declare const ResponseBodyDurationUnit: {
    readonly Days: "days";
    readonly Exposures: "exposures";
};
export type ResponseBodyDurationUnit = ClosedEnum<typeof ResponseBodyDurationUnit>;
export declare const ResponseBodyAllocationUnit: {
    readonly CookieId: "cookieId";
    readonly UserId: "userId";
    readonly VisitorId: "visitorId";
};
export type ResponseBodyAllocationUnit = ClosedEnum<typeof ResponseBodyAllocationUnit>;
export declare const UpdateFlagResponseBodyMetricType: {
    readonly Count: "count";
    readonly Currency: "currency";
    readonly Percentage: "percentage";
};
export type UpdateFlagResponseBodyMetricType = ClosedEnum<typeof UpdateFlagResponseBodyMetricType>;
export declare const UpdateFlagResponseBodyMetricUnit: {
    readonly Session: "session";
    readonly User: "user";
    readonly Visitor: "visitor";
};
export type UpdateFlagResponseBodyMetricUnit = ClosedEnum<typeof UpdateFlagResponseBodyMetricUnit>;
export declare const UpdateFlagResponseBodyDirectionality: {
    readonly DecreaseIsGood: "decreaseIsGood";
    readonly IncreaseIsGood: "increaseIsGood";
};
export type UpdateFlagResponseBodyDirectionality = ClosedEnum<typeof UpdateFlagResponseBodyDirectionality>;
export type ResponseBodyPrimaryMetrics = {
    description?: string | undefined;
    metricFormula?: string | undefined;
    name: string;
    metricType: UpdateFlagResponseBodyMetricType;
    metricUnit: UpdateFlagResponseBodyMetricUnit;
    directionality: UpdateFlagResponseBodyDirectionality;
};
export declare const UpdateFlagResponseBodyStatus: {
    readonly Closed: "closed";
    readonly Draft: "draft";
    readonly Paused: "paused";
    readonly Running: "running";
};
export type UpdateFlagResponseBodyStatus = ClosedEnum<typeof UpdateFlagResponseBodyStatus>;
export type ResponseBodyExperiment = {
    id?: string | undefined;
    name?: string | undefined;
    numVariants?: number | undefined;
    surfaceArea?: string | undefined;
    stickyRequirement?: boolean | undefined;
    layer?: string | undefined;
    guardrailMetrics?: Array<ResponseBodyGuardrailMetrics> | undefined;
    hypothesis?: string | undefined;
    device?: ResponseBodyDevice | undefined;
    controlVariantId?: string | undefined;
    startedAt?: number | undefined;
    endedAt?: number | undefined;
    decision?: string | undefined;
    decisionReason?: string | undefined;
    duration?: number | undefined;
    durationUnit?: ResponseBodyDurationUnit | undefined;
    allocationPercent?: number | undefined;
    allocationUnit: ResponseBodyAllocationUnit;
    primaryMetrics: Array<ResponseBodyPrimaryMetrics>;
    status: UpdateFlagResponseBodyStatus;
};
export type ResponseBodyVariants = {};
export type ResponseBodyReuse = {
    active: boolean;
    environment: string;
};
export type UpdateFlagResponseBodyTargets = {
    note?: string | undefined;
    value: string;
};
export declare const UpdateFlagResponseBodyType: {
    readonly Variant: "variant";
};
export type UpdateFlagResponseBodyType = ClosedEnum<typeof UpdateFlagResponseBodyType>;
export type ResponseBodyPausedOutcome = {
    type: UpdateFlagResponseBodyType;
    variantId: string;
};
export declare const UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType: {
    readonly Entity: "entity";
};
export type UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType>;
export type UpdateFlagFallthroughFeatureFlagsResponse200Base = {
    type: UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType;
    kind: string;
    attribute: string;
};
export type UpdateFlagFallthroughFeatureFlagsSlots = {
    promille: number;
    durationMs: number;
};
export type UpdateFlagFallthroughFeatureFlags3 = {
    type: "rollout";
    base: UpdateFlagFallthroughFeatureFlagsResponse200Base;
    defaultVariantId: string;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    slots: Array<UpdateFlagFallthroughFeatureFlagsSlots>;
};
export declare const UpdateFlagFallthroughFeatureFlagsResponse200Type: {
    readonly Entity: "entity";
};
export type UpdateFlagFallthroughFeatureFlagsResponse200Type = ClosedEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200Type>;
export type UpdateFlagFallthroughFeatureFlagsResponseBase = {
    type: UpdateFlagFallthroughFeatureFlagsResponse200Type;
    kind: string;
    attribute: string;
};
export type UpdateFlagFallthroughFeatureFlags2 = {
    type: "split";
    base: UpdateFlagFallthroughFeatureFlagsResponseBase;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
export type UpdateFlagFallthroughFeatureFlags1 = {
    type: "variant";
    variantId: string;
};
export type ResponseBodyFallthrough = UpdateFlagFallthroughFeatureFlags1 | UpdateFlagFallthroughFeatureFlags2 | UpdateFlagFallthroughFeatureFlags3;
export declare const UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType: {
    readonly Entity: "entity";
};
export type UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType>;
export type UpdateFlagOutcomeFeatureFlagsResponse200Base = {
    type: UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType;
    kind: string;
    attribute: string;
};
export type UpdateFlagOutcomeFeatureFlagsSlots = {
    promille: number;
    durationMs: number;
};
export type UpdateFlagOutcomeFeatureFlags3 = {
    type: "rollout";
    base: UpdateFlagOutcomeFeatureFlagsResponse200Base;
    defaultVariantId: string;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    slots: Array<UpdateFlagOutcomeFeatureFlagsSlots>;
};
export declare const UpdateFlagOutcomeFeatureFlagsResponse200Type: {
    readonly Entity: "entity";
};
export type UpdateFlagOutcomeFeatureFlagsResponse200Type = ClosedEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200Type>;
export type UpdateFlagOutcomeFeatureFlagsResponseBase = {
    type: UpdateFlagOutcomeFeatureFlagsResponse200Type;
    kind: string;
    attribute: string;
};
export type UpdateFlagOutcomeFeatureFlags2 = {
    type: "split";
    base: UpdateFlagOutcomeFeatureFlagsResponseBase;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
export type UpdateFlagOutcomeFeatureFlags1 = {
    type: "variant";
    variantId: string;
};
export type ResponseBodyOutcome = UpdateFlagOutcomeFeatureFlags1 | UpdateFlagOutcomeFeatureFlags2 | UpdateFlagOutcomeFeatureFlags3;
export declare const UpdateFlagRhsFeatureFlagsResponseType: {
    readonly Regex: "regex";
};
export type UpdateFlagRhsFeatureFlagsResponseType = ClosedEnum<typeof UpdateFlagRhsFeatureFlagsResponseType>;
export type UpdateFlagRhs4 = {
    type: UpdateFlagRhsFeatureFlagsResponseType;
    pattern: string;
    flags: string;
};
export declare const UpdateFlagRhsFeatureFlagsType: {
    readonly List: "list";
    readonly ListInline: "list/inline";
};
export type UpdateFlagRhsFeatureFlagsType = ClosedEnum<typeof UpdateFlagRhsFeatureFlagsType>;
export type UpdateFlagItemsFeatureFlags2 = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
export type UpdateFlagItemsFeatureFlags1 = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
export type UpdateFlagRhsFeatureFlagsItems = UpdateFlagItemsFeatureFlags1 | UpdateFlagItemsFeatureFlags2;
export type UpdateFlagRhs3 = {
    type: UpdateFlagRhsFeatureFlagsType;
    items: Array<UpdateFlagItemsFeatureFlags1 | UpdateFlagItemsFeatureFlags2>;
};
export type ResponseBodyRhs = UpdateFlagRhs4 | UpdateFlagRhs3 | string | number | boolean;
export type ResponseBodyCmpOptions = {
    ignoreCase?: boolean | undefined;
};
export type UpdateFlagLhsFeatureFlags2 = {
    type: "entity";
    kind: string;
    attribute: string;
};
export type UpdateFlagLhsFeatureFlags1 = {
    type: "segment";
};
export type ResponseBodyLhs = UpdateFlagLhsFeatureFlags1 | UpdateFlagLhsFeatureFlags2;
export declare const ResponseBodyCmp: {
    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 ResponseBodyCmp = ClosedEnum<typeof ResponseBodyCmp>;
export type ResponseBodyConditions = {
    rhs?: UpdateFlagRhs4 | UpdateFlagRhs3 | string | number | boolean | undefined;
    cmpOptions?: ResponseBodyCmpOptions | undefined;
    lhs: UpdateFlagLhsFeatureFlags1 | UpdateFlagLhsFeatureFlags2;
    cmp: ResponseBodyCmp;
};
export type ResponseBodyRules = {
    id: string;
    outcome: UpdateFlagOutcomeFeatureFlags1 | UpdateFlagOutcomeFeatureFlags2 | UpdateFlagOutcomeFeatureFlags3;
    conditions: Array<ResponseBodyConditions>;
};
export type ResponseBodyEnvironments = {
    reuse?: ResponseBodyReuse | undefined;
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<UpdateFlagResponseBodyTargets>;
            };
        };
    } | undefined;
    revision?: number | undefined;
    pausedOutcome: ResponseBodyPausedOutcome;
    fallthrough: UpdateFlagFallthroughFeatureFlags1 | UpdateFlagFallthroughFeatureFlags2 | UpdateFlagFallthroughFeatureFlags3;
    active: boolean;
    rules: Array<ResponseBodyRules>;
};
export declare const ResponseBodyKind: {
    readonly Boolean: "boolean";
    readonly Json: "json";
    readonly Number: "number";
    readonly String: "string";
};
export type ResponseBodyKind = ClosedEnum<typeof ResponseBodyKind>;
export declare const ResponseBodyState: {
    readonly Active: "active";
    readonly Archived: "archived";
};
export type ResponseBodyState = ClosedEnum<typeof ResponseBodyState>;
export declare const ResponseBodyTypeName: {
    readonly Flag: "flag";
};
export type ResponseBodyTypeName = ClosedEnum<typeof ResponseBodyTypeName>;
export type UpdateFlagResponseBody1 = {
    description?: string | undefined;
    maintainerIds?: Array<string> | undefined;
    permanent?: boolean | undefined;
    tags?: Array<string> | undefined;
    experiment?: ResponseBodyExperiment | undefined;
    variants: Array<ResponseBodyVariants>;
    id: string;
    environments: {
        [k: string]: ResponseBodyEnvironments;
    };
    kind: ResponseBodyKind;
    revision: number;
    seed: number;
    state: ResponseBodyState;
    slug: string;
    createdAt: number;
    updatedAt: number;
    createdBy: string;
    ownerId: string;
    projectId: string;
    typeName: ResponseBodyTypeName;
};
export type UpdateFlagResponseBody = UpdateFlagResponseBody1 | Flag;
/** @internal */
export type UpdateFlagValue4$Outbound = {};
/** @internal */
export declare const UpdateFlagValue4$outboundSchema: z.ZodType<UpdateFlagValue4$Outbound, z.ZodTypeDef, UpdateFlagValue4>;
export declare function updateFlagValue4ToJSON(updateFlagValue4: UpdateFlagValue4): string;
/** @internal */
export type UpdateFlagVariants$Outbound = {
    id: string;
    label?: string | undefined;
    description?: string | undefined;
    value?: any | undefined;
};
/** @internal */
export declare const UpdateFlagVariants$outboundSchema: z.ZodType<UpdateFlagVariants$Outbound, z.ZodTypeDef, UpdateFlagVariants>;
export declare function updateFlagVariantsToJSON(updateFlagVariants: UpdateFlagVariants): string;
/** @internal */
export type UpdateFlagReuse$Outbound = {
    active: boolean;
    environment: string;
};
/** @internal */
export declare const UpdateFlagReuse$outboundSchema: z.ZodType<UpdateFlagReuse$Outbound, z.ZodTypeDef, UpdateFlagReuse>;
export declare function updateFlagReuseToJSON(updateFlagReuse: UpdateFlagReuse): string;
/** @internal */
export type UpdateFlagTargets$Outbound = {
    note?: string | undefined;
    value: string;
};
/** @internal */
export declare const UpdateFlagTargets$outboundSchema: z.ZodType<UpdateFlagTargets$Outbound, z.ZodTypeDef, UpdateFlagTargets>;
export declare function updateFlagTargetsToJSON(updateFlagTargets: UpdateFlagTargets): string;
/** @internal */
export type UpdateFlagPausedOutcome$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const UpdateFlagPausedOutcome$outboundSchema: z.ZodType<UpdateFlagPausedOutcome$Outbound, z.ZodTypeDef, UpdateFlagPausedOutcome>;
export declare function updateFlagPausedOutcomeToJSON(updateFlagPausedOutcome: UpdateFlagPausedOutcome): string;
/** @internal */
export type UpdateFlagLhs2$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const UpdateFlagLhs2$outboundSchema: z.ZodType<UpdateFlagLhs2$Outbound, z.ZodTypeDef, UpdateFlagLhs2>;
export declare function updateFlagLhs2ToJSON(updateFlagLhs2: UpdateFlagLhs2): string;
/** @internal */
export type UpdateFlagLhs1$Outbound = {
    type?: any | undefined;
};
/** @internal */
export declare const UpdateFlagLhs1$outboundSchema: z.ZodType<UpdateFlagLhs1$Outbound, z.ZodTypeDef, UpdateFlagLhs1>;
export declare function updateFlagLhs1ToJSON(updateFlagLhs1: UpdateFlagLhs1): string;
/** @internal */
export type UpdateFlagLhs$Outbound = UpdateFlagLhs2$Outbound | UpdateFlagLhs1$Outbound;
/** @internal */
export declare const UpdateFlagLhs$outboundSchema: z.ZodType<UpdateFlagLhs$Outbound, z.ZodTypeDef, UpdateFlagLhs>;
export declare function updateFlagLhsToJSON(updateFlagLhs: UpdateFlagLhs): string;
/** @internal */
export declare const UpdateFlagCmp$outboundSchema: z.ZodNativeEnum<typeof UpdateFlagCmp>;
/** @internal */
export type UpdateFlagRhs2$Outbound = {
    type?: any | undefined;
    pattern: string;
    flags: string;
};
/** @internal */
export declare const UpdateFlagRhs2$outboundSchema: z.ZodType<UpdateFlagRhs2$Outbound, z.ZodTypeDef, UpdateFlagRhs2>;
export declare function updateFlagRhs2ToJSON(updateFlagRhs2: UpdateFlagRhs2): string;
/** @internal */
export declare const UpdateFlagRhsType$outboundSchema: z.ZodNativeEnum<typeof UpdateFlagRhsType>;
/** @internal */
export type UpdateFlagItems2$Outbound = {
    label?: string | undefined;
    note?: string | undefined;
    value: string;
};
/** @internal */
export declare const UpdateFlagItems2$outboundSchema: z.ZodType<UpdateFlagItems2$Outbound, z.ZodTypeDef, UpdateFlagItems2>;
export declare function updateFlagItems2ToJSON(updateFlagItems2: UpdateFlagItems2): string;
/** @internal */
export type UpdateFlagItems1$Outbound = {
    label?: string | undefined;
    note?: string | undefined;
    value: number;
};
/** @internal */
export declare const UpdateFlagItems1$outboundSchema: z.ZodType<UpdateFlagItems1$Outbound, z.ZodTypeDef, UpdateFlagItems1>;
export declare function updateFlagItems1ToJSON(updateFlagItems1: UpdateFlagItems1): string;
/** @internal */
export type UpdateFlagRhsItems$Outbound = UpdateFlagItems1$Outbound | UpdateFlagItems2$Outbound;
/** @internal */
export declare const UpdateFlagRhsItems$outboundSchema: z.ZodType<UpdateFlagRhsItems$Outbound, z.ZodTypeDef, UpdateFlagRhsItems>;
export declare function updateFlagRhsItemsToJSON(updateFlagRhsItems: UpdateFlagRhsItems): string;
/** @internal */
export type UpdateFlagRhs1$Outbound = {
    type: string;
    items: Array<UpdateFlagItems1$Outbound | UpdateFlagItems2$Outbound>;
};
/** @internal */
export declare const UpdateFlagRhs1$outboundSchema: z.ZodType<UpdateFlagRhs1$Outbound, z.ZodTypeDef, UpdateFlagRhs1>;
export declare function updateFlagRhs1ToJSON(updateFlagRhs1: UpdateFlagRhs1): string;
/** @internal */
export type UpdateFlagRhs$Outbound = UpdateFlagRhs2$Outbound | UpdateFlagRhs1$Outbound | string | number | boolean;
/** @internal */
export declare const UpdateFlagRhs$outboundSchema: z.ZodType<UpdateFlagRhs$Outbound, z.ZodTypeDef, UpdateFlagRhs>;
export declare function updateFlagRhsToJSON(updateFlagRhs: UpdateFlagRhs): string;
/** @internal */
export type UpdateFlagCmpOptions$Outbound = {
    ignoreCase?: boolean | undefined;
};
/** @internal */
export declare const UpdateFlagCmpOptions$outboundSchema: z.ZodType<UpdateFlagCmpOptions$Outbound, z.ZodTypeDef, UpdateFlagCmpOptions>;
export declare function updateFlagCmpOptionsToJSON(updateFlagCmpOptions: UpdateFlagCmpOptions): string;
/** @internal */
export type UpdateFlagConditions$Outbound = {
    lhs: UpdateFlagLhs2$Outbound | UpdateFlagLhs1$Outbound;
    cmp: string;
    rhs?: UpdateFlagRhs2$Outbound | UpdateFlagRhs1$Outbound | string | number | boolean | undefined;
    cmpOptions?: UpdateFlagCmpOptions$Outbound | undefined;
};
/** @internal */
export declare const UpdateFlagConditions$outboundSchema: z.ZodType<UpdateFlagConditions$Outbound, z.ZodTypeDef, UpdateFlagConditions>;
export declare function updateFlagConditionsToJSON(updateFlagConditions: UpdateFlagConditions): string;
/** @internal */
export type UpdateFlagOutcomeFeatureFlagsBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsBase$outboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlagsBase$Outbound, z.ZodTypeDef, UpdateFlagOutcomeFeatureFlagsBase>;
export declare function updateFlagOutcomeFeatureFlagsBaseToJSON(updateFlagOutcomeFeatureFlagsBase: UpdateFlagOutcomeFeatureFlagsBase): string;
/** @internal */
export type UpdateFlagOutcomeSlots$Outbound = {
    promille: number;
    durationMs: number;
};
/** @internal */
export declare const UpdateFlagOutcomeSlots$outboundSchema: z.ZodType<UpdateFlagOutcomeSlots$Outbound, z.ZodTypeDef, UpdateFlagOutcomeSlots>;
export declare function updateFlagOutcomeSlotsToJSON(updateFlagOutcomeSlots: UpdateFlagOutcomeSlots): string;
/** @internal */
export type UpdateFlagOutcome3$Outbound = {
    type?: any | undefined;
    base: UpdateFlagOutcomeFeatureFlagsBase$Outbound;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    defaultVariantId: string;
    slots: Array<UpdateFlagOutcomeSlots$Outbound>;
};
/** @internal */
export declare const UpdateFlagOutcome3$outboundSchema: z.ZodType<UpdateFlagOutcome3$Outbound, z.ZodTypeDef, UpdateFlagOutcome3>;
export declare function updateFlagOutcome3ToJSON(updateFlagOutcome3: UpdateFlagOutcome3): string;
/** @internal */
export type UpdateFlagOutcomeBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const UpdateFlagOutcomeBase$outboundSchema: z.ZodType<UpdateFlagOutcomeBase$Outbound, z.ZodTypeDef, UpdateFlagOutcomeBase>;
export declare function updateFlagOutcomeBaseToJSON(updateFlagOutcomeBase: UpdateFlagOutcomeBase): string;
/** @internal */
export type UpdateFlagOutcome2$Outbound = {
    type?: any | undefined;
    base: UpdateFlagOutcomeBase$Outbound;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
/** @internal */
export declare const UpdateFlagOutcome2$outboundSchema: z.ZodType<UpdateFlagOutcome2$Outbound, z.ZodTypeDef, UpdateFlagOutcome2>;
export declare function updateFlagOutcome2ToJSON(updateFlagOutcome2: UpdateFlagOutcome2): string;
/** @internal */
export type UpdateFlagOutcome1$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const UpdateFlagOutcome1$outboundSchema: z.ZodType<UpdateFlagOutcome1$Outbound, z.ZodTypeDef, UpdateFlagOutcome1>;
export declare function updateFlagOutcome1ToJSON(updateFlagOutcome1: UpdateFlagOutcome1): string;
/** @internal */
export type UpdateFlagOutcome$Outbound = UpdateFlagOutcome3$Outbound | UpdateFlagOutcome2$Outbound | UpdateFlagOutcome1$Outbound;
/** @internal */
export declare const UpdateFlagOutcome$outboundSchema: z.ZodType<UpdateFlagOutcome$Outbound, z.ZodTypeDef, UpdateFlagOutcome>;
export declare function updateFlagOutcomeToJSON(updateFlagOutcome: UpdateFlagOutcome): string;
/** @internal */
export type UpdateFlagRules$Outbound = {
    id: string;
    conditions: Array<UpdateFlagConditions$Outbound>;
    outcome: UpdateFlagOutcome3$Outbound | UpdateFlagOutcome2$Outbound | UpdateFlagOutcome1$Outbound;
};
/** @internal */
export declare const UpdateFlagRules$outboundSchema: z.ZodType<UpdateFlagRules$Outbound, z.ZodTypeDef, UpdateFlagRules>;
export declare function updateFlagRulesToJSON(updateFlagRules: UpdateFlagRules): string;
/** @internal */
export type UpdateFlagFallthroughFeatureFlagsBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsBase$outboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlagsBase$Outbound, z.ZodTypeDef, UpdateFlagFallthroughFeatureFlagsBase>;
export declare function updateFlagFallthroughFeatureFlagsBaseToJSON(updateFlagFallthroughFeatureFlagsBase: UpdateFlagFallthroughFeatureFlagsBase): string;
/** @internal */
export type UpdateFlagFallthroughSlots$Outbound = {
    promille: number;
    durationMs: number;
};
/** @internal */
export declare const UpdateFlagFallthroughSlots$outboundSchema: z.ZodType<UpdateFlagFallthroughSlots$Outbound, z.ZodTypeDef, UpdateFlagFallthroughSlots>;
export declare function updateFlagFallthroughSlotsToJSON(updateFlagFallthroughSlots: UpdateFlagFallthroughSlots): string;
/** @internal */
export type UpdateFlagFallthrough3$Outbound = {
    type?: any | undefined;
    base: UpdateFlagFallthroughFeatureFlagsBase$Outbound;
    startTimestamp: number;
    rollFromVariantId: string;
    rollToVariantId: string;
    defaultVariantId: string;
    slots: Array<UpdateFlagFallthroughSlots$Outbound>;
};
/** @internal */
export declare const UpdateFlagFallthrough3$outboundSchema: z.ZodType<UpdateFlagFallthrough3$Outbound, z.ZodTypeDef, UpdateFlagFallthrough3>;
export declare function updateFlagFallthrough3ToJSON(updateFlagFallthrough3: UpdateFlagFallthrough3): string;
/** @internal */
export type UpdateFlagFallthroughBase$Outbound = {
    type?: any | undefined;
    kind: string;
    attribute: string;
};
/** @internal */
export declare const UpdateFlagFallthroughBase$outboundSchema: z.ZodType<UpdateFlagFallthroughBase$Outbound, z.ZodTypeDef, UpdateFlagFallthroughBase>;
export declare function updateFlagFallthroughBaseToJSON(updateFlagFallthroughBase: UpdateFlagFallthroughBase): string;
/** @internal */
export type UpdateFlagFallthrough2$Outbound = {
    type?: any | undefined;
    base: UpdateFlagFallthroughBase$Outbound;
    weights: {
        [k: string]: number;
    };
    defaultVariantId: string;
};
/** @internal */
export declare const UpdateFlagFallthrough2$outboundSchema: z.ZodType<UpdateFlagFallthrough2$Outbound, z.ZodTypeDef, UpdateFlagFallthrough2>;
export declare function updateFlagFallthrough2ToJSON(updateFlagFallthrough2: UpdateFlagFallthrough2): string;
/** @internal */
export type UpdateFlagFallthrough1$Outbound = {
    type?: any | undefined;
    variantId: string;
};
/** @internal */
export declare const UpdateFlagFallthrough1$outboundSchema: z.ZodType<UpdateFlagFallthrough1$Outbound, z.ZodTypeDef, UpdateFlagFallthrough1>;
export declare function updateFlagFallthrough1ToJSON(updateFlagFallthrough1: UpdateFlagFallthrough1): string;
/** @internal */
export type UpdateFlagFallthrough$Outbound = UpdateFlagFallthrough3$Outbound | UpdateFlagFallthrough2$Outbound | UpdateFlagFallthrough1$Outbound;
/** @internal */
export declare const UpdateFlagFallthrough$outboundSchema: z.ZodType<UpdateFlagFallthrough$Outbound, z.ZodTypeDef, UpdateFlagFallthrough>;
export declare function updateFlagFallthroughToJSON(updateFlagFallthrough: UpdateFlagFallthrough): string;
/** @internal */
export type UpdateFlagEnvironments$Outbound = {
    active: boolean;
    reuse?: UpdateFlagReuse$Outbound | undefined;
    targets?: {
        [k: string]: {
            [k: string]: {
                [k: string]: Array<UpdateFlagTargets$Outbound>;
            };
        };
    } | undefined;
    pausedOutcome: UpdateFlagPausedOutcome$Outbound;
    rules: Array<UpdateFlagRules$Outbound>;
    fallthrough: UpdateFlagFallthrough3$Outbound | UpdateFlagFallthrough2$Outbound | UpdateFlagFallthrough1$Outbound;
    revision?: number | undefined;
};
/** @internal */
export declare const UpdateFlagEnvironments$outboundSchema: z.ZodType<UpdateFlagEnvironments$Outbound, z.ZodTypeDef, UpdateFlagEnvironments>;
export declare function updateFlagEnvironmentsToJSON(updateFlagEnvironments: UpdateFlagEnvironments): string;
/** @internal */
export declare const UpdateFlagState$outboundSchema: z.ZodNativeEnum<typeof UpdateFlagState>;
/** @internal */
export type UpdateFlagRequestBody$Outbound = {
    createdBy?: string | undefined;
    message?: string | undefined;
    variants?: Array<UpdateFlagVariants$Outbound> | undefined;
    environments?: {
        [k: string]: UpdateFlagEnvironments$Outbound;
    } | undefined;
    seed?: number | undefined;
    description?: string | undefined;
    state?: string | undefined;
    maintainerIds?: Array<string> | undefined;
    permanent?: boolean | undefined;
    tags?: Array<string> | undefined;
};
/** @internal */
export declare const UpdateFlagRequestBody$outboundSchema: z.ZodType<UpdateFlagRequestBody$Outbound, z.ZodTypeDef, UpdateFlagRequestBody>;
export declare function updateFlagRequestBodyToJSON(updateFlagRequestBody: UpdateFlagRequestBody): string;
/** @internal */
export type UpdateFlagRequest$Outbound = {
    projectIdOrName: string;
    flagIdOrSlug: string;
    ifMatch?: string | undefined;
    withMetadata?: boolean | undefined;
    teamId?: string | undefined;
    slug?: string | undefined;
    RequestBody?: UpdateFlagRequestBody$Outbound | undefined;
};
/** @internal */
export declare const UpdateFlagRequest$outboundSchema: z.ZodType<UpdateFlagRequest$Outbound, z.ZodTypeDef, UpdateFlagRequest>;
export declare function updateFlagRequestToJSON(updateFlagRequest: UpdateFlagRequest): string;
/** @internal */
export declare const ResponseBodyMetricType$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyMetricType>;
/** @internal */
export declare const ResponseBodyMetricUnit$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyMetricUnit>;
/** @internal */
export declare const ResponseBodyDirectionality$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyDirectionality>;
/** @internal */
export declare const ResponseBodyGuardrailMetrics$inboundSchema: z.ZodType<ResponseBodyGuardrailMetrics, z.ZodTypeDef, unknown>;
export declare function responseBodyGuardrailMetricsFromJSON(jsonString: string): SafeParseResult<ResponseBodyGuardrailMetrics, SDKValidationError>;
/** @internal */
export declare const ResponseBodyDevice$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyDevice>;
/** @internal */
export declare const ResponseBodyDurationUnit$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyDurationUnit>;
/** @internal */
export declare const ResponseBodyAllocationUnit$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyAllocationUnit>;
/** @internal */
export declare const UpdateFlagResponseBodyMetricType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagResponseBodyMetricType>;
/** @internal */
export declare const UpdateFlagResponseBodyMetricUnit$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagResponseBodyMetricUnit>;
/** @internal */
export declare const UpdateFlagResponseBodyDirectionality$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagResponseBodyDirectionality>;
/** @internal */
export declare const ResponseBodyPrimaryMetrics$inboundSchema: z.ZodType<ResponseBodyPrimaryMetrics, z.ZodTypeDef, unknown>;
export declare function responseBodyPrimaryMetricsFromJSON(jsonString: string): SafeParseResult<ResponseBodyPrimaryMetrics, SDKValidationError>;
/** @internal */
export declare const UpdateFlagResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagResponseBodyStatus>;
/** @internal */
export declare const ResponseBodyExperiment$inboundSchema: z.ZodType<ResponseBodyExperiment, z.ZodTypeDef, unknown>;
export declare function responseBodyExperimentFromJSON(jsonString: string): SafeParseResult<ResponseBodyExperiment, SDKValidationError>;
/** @internal */
export declare const ResponseBodyVariants$inboundSchema: z.ZodType<ResponseBodyVariants, z.ZodTypeDef, unknown>;
export declare function responseBodyVariantsFromJSON(jsonString: string): SafeParseResult<ResponseBodyVariants, SDKValidationError>;
/** @internal */
export declare const ResponseBodyReuse$inboundSchema: z.ZodType<ResponseBodyReuse, z.ZodTypeDef, unknown>;
export declare function responseBodyReuseFromJSON(jsonString: string): SafeParseResult<ResponseBodyReuse, SDKValidationError>;
/** @internal */
export declare const UpdateFlagResponseBodyTargets$inboundSchema: z.ZodType<UpdateFlagResponseBodyTargets, z.ZodTypeDef, unknown>;
export declare function updateFlagResponseBodyTargetsFromJSON(jsonString: string): SafeParseResult<UpdateFlagResponseBodyTargets, SDKValidationError>;
/** @internal */
export declare const UpdateFlagResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagResponseBodyType>;
/** @internal */
export declare const ResponseBodyPausedOutcome$inboundSchema: z.ZodType<ResponseBodyPausedOutcome, z.ZodTypeDef, unknown>;
export declare function responseBodyPausedOutcomeFromJSON(jsonString: string): SafeParseResult<ResponseBodyPausedOutcome, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONType>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsResponse200Base$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlagsResponse200Base, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlagsResponse200BaseFromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlagsResponse200Base, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsSlots$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlagsSlots, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlagsSlotsFromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlagsSlots, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlags3$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlags3FromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200Type>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlagsResponseBase$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlags2$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlags2FromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const UpdateFlagFallthroughFeatureFlags1$inboundSchema: z.ZodType<UpdateFlagFallthroughFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthroughFeatureFlags1FromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthroughFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const ResponseBodyFallthrough$inboundSchema: z.ZodType<ResponseBodyFallthrough, z.ZodTypeDef, unknown>;
export declare function responseBodyFallthroughFromJSON(jsonString: string): SafeParseResult<ResponseBodyFallthrough, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONType>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsResponse200Base$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlagsResponse200Base, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlagsResponse200BaseFromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlagsResponse200Base, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsSlots$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlagsSlots, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlagsSlotsFromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlagsSlots, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlags3$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlags3FromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200Type>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlagsResponseBase$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlags2$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlags2FromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const UpdateFlagOutcomeFeatureFlags1$inboundSchema: z.ZodType<UpdateFlagOutcomeFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcomeFeatureFlags1FromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcomeFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const ResponseBodyOutcome$inboundSchema: z.ZodType<ResponseBodyOutcome, z.ZodTypeDef, unknown>;
export declare function responseBodyOutcomeFromJSON(jsonString: string): SafeParseResult<ResponseBodyOutcome, SDKValidationError>;
/** @internal */
export declare const UpdateFlagRhsFeatureFlagsResponseType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagRhsFeatureFlagsResponseType>;
/** @internal */
export declare const UpdateFlagRhs4$inboundSchema: z.ZodType<UpdateFlagRhs4, z.ZodTypeDef, unknown>;
export declare function updateFlagRhs4FromJSON(jsonString: string): SafeParseResult<UpdateFlagRhs4, SDKValidationError>;
/** @internal */
export declare const UpdateFlagRhsFeatureFlagsType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagRhsFeatureFlagsType>;
/** @internal */
export declare const UpdateFlagItemsFeatureFlags2$inboundSchema: z.ZodType<UpdateFlagItemsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function updateFlagItemsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<UpdateFlagItemsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const UpdateFlagItemsFeatureFlags1$inboundSchema: z.ZodType<UpdateFlagItemsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function updateFlagItemsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<UpdateFlagItemsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const UpdateFlagRhsFeatureFlagsItems$inboundSchema: z.ZodType<UpdateFlagRhsFeatureFlagsItems, z.ZodTypeDef, unknown>;
export declare function updateFlagRhsFeatureFlagsItemsFromJSON(jsonString: string): SafeParseResult<UpdateFlagRhsFeatureFlagsItems, SDKValidationError>;
/** @internal */
export declare const UpdateFlagRhs3$inboundSchema: z.ZodType<UpdateFlagRhs3, z.ZodTypeDef, unknown>;
export declare function updateFlagRhs3FromJSON(jsonString: string): SafeParseResult<UpdateFlagRhs3, SDKValidationError>;
/** @internal */
export declare const ResponseBodyRhs$inboundSchema: z.ZodType<ResponseBodyRhs, z.ZodTypeDef, unknown>;
export declare function responseBodyRhsFromJSON(jsonString: string): SafeParseResult<ResponseBodyRhs, SDKValidationError>;
/** @internal */
export declare const ResponseBodyCmpOptions$inboundSchema: z.ZodType<ResponseBodyCmpOptions, z.ZodTypeDef, unknown>;
export declare function responseBodyCmpOptionsFromJSON(jsonString: string): SafeParseResult<ResponseBodyCmpOptions, SDKValidationError>;
/** @internal */
export declare const UpdateFlagLhsFeatureFlags2$inboundSchema: z.ZodType<UpdateFlagLhsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function updateFlagLhsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<UpdateFlagLhsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const UpdateFlagLhsFeatureFlags1$inboundSchema: z.ZodType<UpdateFlagLhsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function updateFlagLhsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<UpdateFlagLhsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const ResponseBodyLhs$inboundSchema: z.ZodType<ResponseBodyLhs, z.ZodTypeDef, unknown>;
export declare function responseBodyLhsFromJSON(jsonString: string): SafeParseResult<ResponseBodyLhs, SDKValidationError>;
/** @internal */
export declare const ResponseBodyCmp$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyCmp>;
/** @internal */
export declare const ResponseBodyConditions$inboundSchema: z.ZodType<ResponseBodyConditions, z.ZodTypeDef, unknown>;
export declare function responseBodyConditionsFromJSON(jsonString: string): SafeParseResult<ResponseBodyConditions, SDKValidationError>;
/** @internal */
export declare const ResponseBodyRules$inboundSchema: z.ZodType<ResponseBodyRules, z.ZodTypeDef, unknown>;
export declare function responseBodyRulesFromJSON(jsonString: string): SafeParseResult<ResponseBodyRules, SDKValidationError>;
/** @internal */
export declare const ResponseBodyEnvironments$inboundSchema: z.ZodType<ResponseBodyEnvironments, z.ZodTypeDef, unknown>;
export declare function responseBodyEnvironmentsFromJSON(jsonString: string): SafeParseResult<ResponseBodyEnvironments, SDKValidationError>;
/** @internal */
export declare const ResponseBodyKind$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyKind>;
/** @internal */
export declare const ResponseBodyState$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyState>;
/** @internal */
export declare const ResponseBodyTypeName$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyTypeName>;
/** @internal */
export declare const UpdateFlagResponseBody1$inboundSchema: z.ZodType<UpdateFlagResponseBody1, z.ZodTypeDef, unknown>;
export declare function updateFlagResponseBody1FromJSON(jsonString: string): SafeParseResult<UpdateFlagResponseBody1, SDKValidationError>;
/** @internal */
export declare const UpdateFlagResponseBody$inboundSchema: z.ZodType<UpdateFlagResponseBody, z.ZodTypeDef, unknown>;
export declare function updateFlagResponseBodyFromJSON(jsonString: string): SafeParseResult<UpdateFlagResponseBody, SDKValidationError>;
//# sourceMappingURL=updateflagop.d.ts.map