@vercel/sdk
Version:
<p align="center"> <a href="https://vercel.com"> <img src="https://assets.vercel.com/image/upload/v1588805858/repositories/vercel/logo.png" height="96"> <h3 align="center">Vercel</h3> </a> <p align="center">Develop. Preview. Ship.</p> </p>
1,041 lines • 46.5 kB
TypeScript
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 type ResponseBodyValue = string | number | {
[k: string]: any;
} | Array<any> | boolean;
export type ResponseBodyVariants = {
description?: string | undefined;
label?: string | undefined;
value: string | number | {
[k: string]: any;
} | Array<any> | boolean | null;
id: string;
};
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 type UpdateFlagFallthrough4 = {
type: "experiment";
};
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 UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType: {
readonly Entity: "entity";
};
export type UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType>;
export type UpdateFlagFallthroughFeatureFlagsResponseBase = {
type: UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType;
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 | UpdateFlagFallthrough4;
export type UpdateFlagOutcome4 = {
type: "experiment";
};
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 UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType: {
readonly Entity: "entity";
};
export type UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType>;
export type UpdateFlagOutcomeFeatureFlagsResponseBase = {
type: UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType;
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 | UpdateFlagOutcome4;
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 | UpdateFlagOutcome4;
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 | UpdateFlagFallthrough4;
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;
variants: Array<ResponseBodyVariants>;
id: string;
environments: {
[k: string]: ResponseBodyEnvironments;
};
kind: ResponseBodyKind;
revision: number;
seed: number;
state: ResponseBodyState;
maintainerIds?: Array<string> | undefined;
permanent?: boolean | undefined;
tags?: Array<string> | undefined;
slug: string;
createdAt: number;
updatedAt: number;
updatedBy?: string | undefined;
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 ResponseBodyValue$inboundSchema: z.ZodType<ResponseBodyValue, z.ZodTypeDef, unknown>;
export declare function responseBodyValueFromJSON(jsonString: string): SafeParseResult<ResponseBodyValue, 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 UpdateFlagFallthrough4$inboundSchema: z.ZodType<UpdateFlagFallthrough4, z.ZodTypeDef, unknown>;
export declare function updateFlagFallthrough4FromJSON(jsonString: string): SafeParseResult<UpdateFlagFallthrough4, 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 UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType>;
/** @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 UpdateFlagOutcome4$inboundSchema: z.ZodType<UpdateFlagOutcome4, z.ZodTypeDef, unknown>;
export declare function updateFlagOutcome4FromJSON(jsonString: string): SafeParseResult<UpdateFlagOutcome4, 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 UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateFlagOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType>;
/** @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