@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,023 lines • 45.8 kB
TypeScript
import * as z from "zod/v3";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
/**
* The kind of flag
*/
export declare const CreateFlagKind: {
readonly Boolean: "boolean";
readonly String: "string";
readonly Number: "number";
readonly Json: "json";
};
/**
* The kind of flag
*/
export type CreateFlagKind = ClosedEnum<typeof CreateFlagKind>;
export type Value4 = {};
export type CreateFlagVariants = {
/**
* The id of the variant
*/
id: string;
/**
* A label for the variant
*/
label?: string | undefined;
/**
* A description of the variant
*/
description?: string | undefined;
value?: any | undefined;
};
/**
* Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration
*/
export type CreateFlagReuse = {
/**
* Whether the reuse is active or not
*/
active: boolean;
/**
* The environment to link to
*/
environment: string;
};
export type CreateFlagTargets = {
note?: string | undefined;
value: string;
};
export type CreateFlagPausedOutcome = {
type?: any | undefined;
variantId: string;
};
export type CreateFlagLhs2 = {
type?: any | undefined;
kind: string;
attribute: string;
};
export type CreateFlagLhs1 = {
type?: any | undefined;
};
export type CreateFlagLhs = CreateFlagLhs2 | CreateFlagLhs1;
export declare const CreateFlagCmp: {
readonly Eq: "eq";
readonly NotEq: "!eq";
readonly OneOf: "oneOf";
readonly NotOneOf: "!oneOf";
readonly ContainsAllOf: "containsAllOf";
readonly ContainsAnyOf: "containsAnyOf";
readonly ContainsNoneOf: "containsNoneOf";
readonly StartsWith: "startsWith";
readonly NotStartsWith: "!startsWith";
readonly EndsWith: "endsWith";
readonly NotEndsWith: "!endsWith";
readonly Contains: "contains";
readonly NotContains: "!contains";
readonly Ex: "ex";
readonly NotEx: "!ex";
readonly Gt: "gt";
readonly Gte: "gte";
readonly Lt: "lt";
readonly Lte: "lte";
readonly Regex: "regex";
readonly NotRegex: "!regex";
readonly Before: "before";
readonly After: "after";
};
export type CreateFlagCmp = ClosedEnum<typeof CreateFlagCmp>;
export type Rhs2 = {
type?: any | undefined;
pattern: string;
flags: string;
};
export declare const CreateFlagRhsType: {
readonly ListInline: "list/inline";
readonly List: "list";
};
export type CreateFlagRhsType = ClosedEnum<typeof CreateFlagRhsType>;
export type CreateFlagItems2 = {
label?: string | undefined;
note?: string | undefined;
value: string;
};
export type CreateFlagItems1 = {
label?: string | undefined;
note?: string | undefined;
value: number;
};
export type CreateFlagRhsItems = CreateFlagItems1 | CreateFlagItems2;
export type Rhs1 = {
type: CreateFlagRhsType;
items: Array<CreateFlagItems1 | CreateFlagItems2>;
};
export type CreateFlagRhs = Rhs2 | Rhs1 | string | number | boolean;
export type CreateFlagCmpOptions = {
ignoreCase?: boolean | undefined;
};
export type CreateFlagConditions = {
lhs: CreateFlagLhs2 | CreateFlagLhs1;
cmp: CreateFlagCmp;
rhs?: Rhs2 | Rhs1 | string | number | boolean | undefined;
cmpOptions?: CreateFlagCmpOptions | undefined;
};
export type CreateFlagOutcomeFeatureFlagsBase = {
type?: any | undefined;
kind: string;
attribute: string;
};
export type CreateFlagOutcomeSlots = {
/**
* Promille of traffic for rollToVariant (0-100_000, where 1_000 = 1%)
*/
promille: number;
/**
* How long this promille is served in ms before moving to the next slot.
*/
durationMs: number;
};
export type CreateFlagOutcome3 = {
type?: any | undefined;
base: CreateFlagOutcomeFeatureFlagsBase;
/**
* Epoch ms when the rollout begins
*/
startTimestamp: number;
/**
* The variant to roll away from
*/
rollFromVariantId: string;
/**
* The variant to roll towards
*/
rollToVariantId: string;
/**
* This variant will be used when the base attribute does not exist
*/
defaultVariantId: string;
/**
* Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely.
*/
slots: Array<CreateFlagOutcomeSlots>;
};
export type CreateFlagOutcomeBase = {
type?: any | undefined;
kind: string;
attribute: string;
};
export type CreateFlagOutcome2 = {
type?: any | undefined;
base: CreateFlagOutcomeBase;
/**
* The distribution for each variant
*/
weights: {
[k: string]: number;
};
/**
* This variant will be used when the base attribute does not exist
*/
defaultVariantId: string;
};
export type CreateFlagOutcome1 = {
type?: any | undefined;
variantId: string;
};
export type CreateFlagOutcome = CreateFlagOutcome3 | CreateFlagOutcome2 | CreateFlagOutcome1;
export type CreateFlagRules = {
id: string;
conditions: Array<CreateFlagConditions>;
outcome: CreateFlagOutcome3 | CreateFlagOutcome2 | CreateFlagOutcome1;
};
export type CreateFlagFallthroughFeatureFlagsBase = {
type?: any | undefined;
kind: string;
attribute: string;
};
export type FallthroughSlots = {
/**
* Promille of traffic for rollToVariant (0-100_000, where 1_000 = 1%)
*/
promille: number;
/**
* How long this promille is served in ms before moving to the next slot.
*/
durationMs: number;
};
export type CreateFlagFallthrough3 = {
type?: any | undefined;
base: CreateFlagFallthroughFeatureFlagsBase;
/**
* Epoch ms when the rollout begins
*/
startTimestamp: number;
/**
* The variant to roll away from
*/
rollFromVariantId: string;
/**
* The variant to roll towards
*/
rollToVariantId: string;
/**
* This variant will be used when the base attribute does not exist
*/
defaultVariantId: string;
/**
* Each slot defines a promille and how long it is served for. After all slots expire, 100% is served indefinitely. The final implicit 100% slot does not need to be listed. Example: [[5_000, 21_600_000], [10_000, 28_800_000]] means 5‰ for 6h, then 10‰ for 8h, then 100% indefinitely.
*/
slots: Array<FallthroughSlots>;
};
export type CreateFlagFallthroughBase = {
type?: any | undefined;
kind: string;
attribute: string;
};
export type CreateFlagFallthrough2 = {
type?: any | undefined;
base: CreateFlagFallthroughBase;
/**
* The distribution for each variant
*/
weights: {
[k: string]: number;
};
/**
* This variant will be used when the base attribute does not exist
*/
defaultVariantId: string;
};
export type CreateFlagFallthrough1 = {
type?: any | undefined;
variantId: string;
};
export type CreateFlagFallthrough = CreateFlagFallthrough3 | CreateFlagFallthrough2 | CreateFlagFallthrough1;
export type CreateFlagEnvironments = {
active: boolean;
/**
* Allows linking this environment to another environment so this flag will be evaluated with the other flag's configuration
*/
reuse?: CreateFlagReuse | undefined;
/**
* Allows assigning targets to variants while bypassing the flag's rules
*/
targets?: {
[k: string]: {
[k: string]: {
[k: string]: Array<CreateFlagTargets>;
};
};
} | undefined;
pausedOutcome: CreateFlagPausedOutcome;
rules: Array<CreateFlagRules>;
fallthrough: CreateFlagFallthrough3 | CreateFlagFallthrough2 | CreateFlagFallthrough1;
/**
* The revision of the environment config
*/
revision?: number | undefined;
};
export declare const CreateFlagState: {
readonly Active: "active";
readonly Archived: "archived";
};
export type CreateFlagState = ClosedEnum<typeof CreateFlagState>;
export type CreateFlagRequestBody = {
/**
* A unique (per project) key for the flag, composed of letters, numbers, dashes, and underscores
*/
slug: string;
/**
* The kind of flag
*/
kind: CreateFlagKind;
/**
* The variants of the flag
*/
variants?: Array<CreateFlagVariants> | undefined;
/**
* The configuration for the flag in different environments
*/
environments: {
[k: string]: CreateFlagEnvironments;
};
/**
* A random seed to prevent split points in different flags from having the same targets
*/
seed?: number | undefined;
/**
* A description of the flag
*/
description?: string | undefined;
state?: CreateFlagState | undefined;
/**
* The user ids of the maintainers of the flag
*/
maintainerIds?: Array<string> | undefined;
/**
* Whether this flag is marked as permanent, indicating it should not be removed
*/
permanent?: boolean | undefined;
/**
* Tags for categorizing the flag
*/
tags?: Array<string> | undefined;
};
export type CreateFlagRequest = {
/**
* The project id or name
*/
projectIdOrName: string;
/**
* The Team identifier to perform the request on behalf of.
*/
teamId?: string | undefined;
/**
* The Team slug to perform the request on behalf of.
*/
slug?: string | undefined;
requestBody?: CreateFlagRequestBody | undefined;
};
export type CreateFlagFeatureFlagsVariants = {};
export type CreateFlagFeatureFlagsReuse = {
active: boolean;
environment: string;
};
export type CreateFlagFeatureFlagsTargets = {
note?: string | undefined;
value: string;
};
export declare const CreateFlagType: {
readonly Variant: "variant";
};
export type CreateFlagType = ClosedEnum<typeof CreateFlagType>;
export type CreateFlagFeatureFlagsPausedOutcome = {
type: CreateFlagType;
variantId: string;
};
export type CreateFlagFallthrough4 = {
type: "experiment";
};
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType: {
readonly Entity: "entity";
};
export type CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType = ClosedEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType>;
export type CreateFlagFallthroughFeatureFlagsResponse201Base = {
type: CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType;
kind: string;
attribute: string;
};
export type CreateFlagFallthroughSlots = {
promille: number;
durationMs: number;
};
export type CreateFlagFallthroughFeatureFlags3 = {
type: "rollout";
base: CreateFlagFallthroughFeatureFlagsResponse201Base;
defaultVariantId: string;
startTimestamp: number;
rollFromVariantId: string;
rollToVariantId: string;
slots: Array<CreateFlagFallthroughSlots>;
};
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType: {
readonly Entity: "entity";
};
export type CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType = ClosedEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType>;
export type CreateFlagFallthroughFeatureFlagsResponseBase = {
type: CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType;
kind: string;
attribute: string;
};
export type CreateFlagFallthroughFeatureFlags2 = {
type: "split";
base: CreateFlagFallthroughFeatureFlagsResponseBase;
weights: {
[k: string]: number;
};
defaultVariantId: string;
};
export type CreateFlagFallthroughFeatureFlags1 = {
type: "variant";
variantId: string;
};
export type CreateFlagFeatureFlagsFallthrough = CreateFlagFallthroughFeatureFlags1 | CreateFlagFallthroughFeatureFlags2 | CreateFlagFallthroughFeatureFlags3 | CreateFlagFallthrough4;
export type CreateFlagOutcome4 = {
type: "experiment";
};
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType: {
readonly Entity: "entity";
};
export type CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType = ClosedEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType>;
export type CreateFlagOutcomeFeatureFlagsResponse201Base = {
type: CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType;
kind: string;
attribute: string;
};
export type CreateFlagOutcomeFeatureFlagsSlots = {
promille: number;
durationMs: number;
};
export type CreateFlagOutcomeFeatureFlags3 = {
type: "rollout";
base: CreateFlagOutcomeFeatureFlagsResponse201Base;
defaultVariantId: string;
startTimestamp: number;
rollFromVariantId: string;
rollToVariantId: string;
slots: Array<CreateFlagOutcomeFeatureFlagsSlots>;
};
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType: {
readonly Entity: "entity";
};
export type CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType = ClosedEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType>;
export type CreateFlagOutcomeFeatureFlagsResponseBase = {
type: CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType;
kind: string;
attribute: string;
};
export type CreateFlagOutcomeFeatureFlags2 = {
type: "split";
base: CreateFlagOutcomeFeatureFlagsResponseBase;
weights: {
[k: string]: number;
};
defaultVariantId: string;
};
export type CreateFlagOutcomeFeatureFlags1 = {
type: "variant";
variantId: string;
};
export type CreateFlagFeatureFlagsOutcome = CreateFlagOutcomeFeatureFlags1 | CreateFlagOutcomeFeatureFlags2 | CreateFlagOutcomeFeatureFlags3 | CreateFlagOutcome4;
export declare const CreateFlagRhsFeatureFlagsResponseType: {
readonly Regex: "regex";
};
export type CreateFlagRhsFeatureFlagsResponseType = ClosedEnum<typeof CreateFlagRhsFeatureFlagsResponseType>;
export type CreateFlagRhs4 = {
type: CreateFlagRhsFeatureFlagsResponseType;
pattern: string;
flags: string;
};
export declare const CreateFlagRhsFeatureFlagsType: {
readonly List: "list";
readonly ListInline: "list/inline";
};
export type CreateFlagRhsFeatureFlagsType = ClosedEnum<typeof CreateFlagRhsFeatureFlagsType>;
export type CreateFlagItemsFeatureFlags2 = {
label?: string | undefined;
note?: string | undefined;
value: string;
};
export type CreateFlagItemsFeatureFlags1 = {
label?: string | undefined;
note?: string | undefined;
value: number;
};
export type CreateFlagRhsFeatureFlagsItems = CreateFlagItemsFeatureFlags1 | CreateFlagItemsFeatureFlags2;
export type CreateFlagRhs3 = {
type: CreateFlagRhsFeatureFlagsType;
items: Array<CreateFlagItemsFeatureFlags1 | CreateFlagItemsFeatureFlags2>;
};
export type CreateFlagFeatureFlagsRhs = CreateFlagRhs4 | CreateFlagRhs3 | string | number | boolean;
export type CreateFlagFeatureFlagsCmpOptions = {
ignoreCase?: boolean | undefined;
};
export type CreateFlagLhsFeatureFlags2 = {
type: "entity";
kind: string;
attribute: string;
};
export type CreateFlagLhsFeatureFlags1 = {
type: "segment";
};
export type CreateFlagFeatureFlagsLhs = CreateFlagLhsFeatureFlags1 | CreateFlagLhsFeatureFlags2;
export declare const CreateFlagFeatureFlagsCmp: {
readonly NotContains: "!contains";
readonly NotEndsWith: "!endsWith";
readonly NotEq: "!eq";
readonly NotEx: "!ex";
readonly NotOneOf: "!oneOf";
readonly NotRegex: "!regex";
readonly NotStartsWith: "!startsWith";
readonly After: "after";
readonly Before: "before";
readonly Contains: "contains";
readonly ContainsAllOf: "containsAllOf";
readonly ContainsAnyOf: "containsAnyOf";
readonly ContainsNoneOf: "containsNoneOf";
readonly EndsWith: "endsWith";
readonly Eq: "eq";
readonly Ex: "ex";
readonly Gt: "gt";
readonly Gte: "gte";
readonly Lt: "lt";
readonly Lte: "lte";
readonly OneOf: "oneOf";
readonly Regex: "regex";
readonly StartsWith: "startsWith";
};
export type CreateFlagFeatureFlagsCmp = ClosedEnum<typeof CreateFlagFeatureFlagsCmp>;
export type CreateFlagFeatureFlagsConditions = {
rhs?: CreateFlagRhs4 | CreateFlagRhs3 | string | number | boolean | undefined;
cmpOptions?: CreateFlagFeatureFlagsCmpOptions | undefined;
lhs: CreateFlagLhsFeatureFlags1 | CreateFlagLhsFeatureFlags2;
cmp: CreateFlagFeatureFlagsCmp;
};
export type CreateFlagFeatureFlagsRules = {
id: string;
outcome: CreateFlagOutcomeFeatureFlags1 | CreateFlagOutcomeFeatureFlags2 | CreateFlagOutcomeFeatureFlags3 | CreateFlagOutcome4;
conditions: Array<CreateFlagFeatureFlagsConditions>;
};
export type CreateFlagFeatureFlagsEnvironments = {
reuse?: CreateFlagFeatureFlagsReuse | undefined;
targets?: {
[k: string]: {
[k: string]: {
[k: string]: Array<CreateFlagFeatureFlagsTargets>;
};
};
} | undefined;
revision?: number | undefined;
pausedOutcome: CreateFlagFeatureFlagsPausedOutcome;
fallthrough: CreateFlagFallthroughFeatureFlags1 | CreateFlagFallthroughFeatureFlags2 | CreateFlagFallthroughFeatureFlags3 | CreateFlagFallthrough4;
active: boolean;
rules: Array<CreateFlagFeatureFlagsRules>;
};
export declare const CreateFlagFeatureFlagsKind: {
readonly Boolean: "boolean";
readonly Json: "json";
readonly Number: "number";
readonly String: "string";
};
export type CreateFlagFeatureFlagsKind = ClosedEnum<typeof CreateFlagFeatureFlagsKind>;
export declare const CreateFlagFeatureFlagsState: {
readonly Active: "active";
readonly Archived: "archived";
};
export type CreateFlagFeatureFlagsState = ClosedEnum<typeof CreateFlagFeatureFlagsState>;
export declare const CreateFlagTypeName: {
readonly Flag: "flag";
};
export type CreateFlagTypeName = ClosedEnum<typeof CreateFlagTypeName>;
export type CreateFlagResponseBody = {
description?: string | undefined;
variants: Array<CreateFlagFeatureFlagsVariants>;
id: string;
environments: {
[k: string]: CreateFlagFeatureFlagsEnvironments;
};
kind: CreateFlagFeatureFlagsKind;
revision: number;
seed: number;
state: CreateFlagFeatureFlagsState;
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: CreateFlagTypeName;
};
/** @internal */
export declare const CreateFlagKind$outboundSchema: z.ZodNativeEnum<typeof CreateFlagKind>;
/** @internal */
export type Value4$Outbound = {};
/** @internal */
export declare const Value4$outboundSchema: z.ZodType<Value4$Outbound, z.ZodTypeDef, Value4>;
export declare function value4ToJSON(value4: Value4): string;
/** @internal */
export type CreateFlagVariants$Outbound = {
id: string;
label?: string | undefined;
description?: string | undefined;
value?: any | undefined;
};
/** @internal */
export declare const CreateFlagVariants$outboundSchema: z.ZodType<CreateFlagVariants$Outbound, z.ZodTypeDef, CreateFlagVariants>;
export declare function createFlagVariantsToJSON(createFlagVariants: CreateFlagVariants): string;
/** @internal */
export type CreateFlagReuse$Outbound = {
active: boolean;
environment: string;
};
/** @internal */
export declare const CreateFlagReuse$outboundSchema: z.ZodType<CreateFlagReuse$Outbound, z.ZodTypeDef, CreateFlagReuse>;
export declare function createFlagReuseToJSON(createFlagReuse: CreateFlagReuse): string;
/** @internal */
export type CreateFlagTargets$Outbound = {
note?: string | undefined;
value: string;
};
/** @internal */
export declare const CreateFlagTargets$outboundSchema: z.ZodType<CreateFlagTargets$Outbound, z.ZodTypeDef, CreateFlagTargets>;
export declare function createFlagTargetsToJSON(createFlagTargets: CreateFlagTargets): string;
/** @internal */
export type CreateFlagPausedOutcome$Outbound = {
type?: any | undefined;
variantId: string;
};
/** @internal */
export declare const CreateFlagPausedOutcome$outboundSchema: z.ZodType<CreateFlagPausedOutcome$Outbound, z.ZodTypeDef, CreateFlagPausedOutcome>;
export declare function createFlagPausedOutcomeToJSON(createFlagPausedOutcome: CreateFlagPausedOutcome): string;
/** @internal */
export type CreateFlagLhs2$Outbound = {
type?: any | undefined;
kind: string;
attribute: string;
};
/** @internal */
export declare const CreateFlagLhs2$outboundSchema: z.ZodType<CreateFlagLhs2$Outbound, z.ZodTypeDef, CreateFlagLhs2>;
export declare function createFlagLhs2ToJSON(createFlagLhs2: CreateFlagLhs2): string;
/** @internal */
export type CreateFlagLhs1$Outbound = {
type?: any | undefined;
};
/** @internal */
export declare const CreateFlagLhs1$outboundSchema: z.ZodType<CreateFlagLhs1$Outbound, z.ZodTypeDef, CreateFlagLhs1>;
export declare function createFlagLhs1ToJSON(createFlagLhs1: CreateFlagLhs1): string;
/** @internal */
export type CreateFlagLhs$Outbound = CreateFlagLhs2$Outbound | CreateFlagLhs1$Outbound;
/** @internal */
export declare const CreateFlagLhs$outboundSchema: z.ZodType<CreateFlagLhs$Outbound, z.ZodTypeDef, CreateFlagLhs>;
export declare function createFlagLhsToJSON(createFlagLhs: CreateFlagLhs): string;
/** @internal */
export declare const CreateFlagCmp$outboundSchema: z.ZodNativeEnum<typeof CreateFlagCmp>;
/** @internal */
export type Rhs2$Outbound = {
type?: any | undefined;
pattern: string;
flags: string;
};
/** @internal */
export declare const Rhs2$outboundSchema: z.ZodType<Rhs2$Outbound, z.ZodTypeDef, Rhs2>;
export declare function rhs2ToJSON(rhs2: Rhs2): string;
/** @internal */
export declare const CreateFlagRhsType$outboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsType>;
/** @internal */
export type CreateFlagItems2$Outbound = {
label?: string | undefined;
note?: string | undefined;
value: string;
};
/** @internal */
export declare const CreateFlagItems2$outboundSchema: z.ZodType<CreateFlagItems2$Outbound, z.ZodTypeDef, CreateFlagItems2>;
export declare function createFlagItems2ToJSON(createFlagItems2: CreateFlagItems2): string;
/** @internal */
export type CreateFlagItems1$Outbound = {
label?: string | undefined;
note?: string | undefined;
value: number;
};
/** @internal */
export declare const CreateFlagItems1$outboundSchema: z.ZodType<CreateFlagItems1$Outbound, z.ZodTypeDef, CreateFlagItems1>;
export declare function createFlagItems1ToJSON(createFlagItems1: CreateFlagItems1): string;
/** @internal */
export type CreateFlagRhsItems$Outbound = CreateFlagItems1$Outbound | CreateFlagItems2$Outbound;
/** @internal */
export declare const CreateFlagRhsItems$outboundSchema: z.ZodType<CreateFlagRhsItems$Outbound, z.ZodTypeDef, CreateFlagRhsItems>;
export declare function createFlagRhsItemsToJSON(createFlagRhsItems: CreateFlagRhsItems): string;
/** @internal */
export type Rhs1$Outbound = {
type: string;
items: Array<CreateFlagItems1$Outbound | CreateFlagItems2$Outbound>;
};
/** @internal */
export declare const Rhs1$outboundSchema: z.ZodType<Rhs1$Outbound, z.ZodTypeDef, Rhs1>;
export declare function rhs1ToJSON(rhs1: Rhs1): string;
/** @internal */
export type CreateFlagRhs$Outbound = Rhs2$Outbound | Rhs1$Outbound | string | number | boolean;
/** @internal */
export declare const CreateFlagRhs$outboundSchema: z.ZodType<CreateFlagRhs$Outbound, z.ZodTypeDef, CreateFlagRhs>;
export declare function createFlagRhsToJSON(createFlagRhs: CreateFlagRhs): string;
/** @internal */
export type CreateFlagCmpOptions$Outbound = {
ignoreCase?: boolean | undefined;
};
/** @internal */
export declare const CreateFlagCmpOptions$outboundSchema: z.ZodType<CreateFlagCmpOptions$Outbound, z.ZodTypeDef, CreateFlagCmpOptions>;
export declare function createFlagCmpOptionsToJSON(createFlagCmpOptions: CreateFlagCmpOptions): string;
/** @internal */
export type CreateFlagConditions$Outbound = {
lhs: CreateFlagLhs2$Outbound | CreateFlagLhs1$Outbound;
cmp: string;
rhs?: Rhs2$Outbound | Rhs1$Outbound | string | number | boolean | undefined;
cmpOptions?: CreateFlagCmpOptions$Outbound | undefined;
};
/** @internal */
export declare const CreateFlagConditions$outboundSchema: z.ZodType<CreateFlagConditions$Outbound, z.ZodTypeDef, CreateFlagConditions>;
export declare function createFlagConditionsToJSON(createFlagConditions: CreateFlagConditions): string;
/** @internal */
export type CreateFlagOutcomeFeatureFlagsBase$Outbound = {
type?: any | undefined;
kind: string;
attribute: string;
};
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsBase$outboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsBase$Outbound, z.ZodTypeDef, CreateFlagOutcomeFeatureFlagsBase>;
export declare function createFlagOutcomeFeatureFlagsBaseToJSON(createFlagOutcomeFeatureFlagsBase: CreateFlagOutcomeFeatureFlagsBase): string;
/** @internal */
export type CreateFlagOutcomeSlots$Outbound = {
promille: number;
durationMs: number;
};
/** @internal */
export declare const CreateFlagOutcomeSlots$outboundSchema: z.ZodType<CreateFlagOutcomeSlots$Outbound, z.ZodTypeDef, CreateFlagOutcomeSlots>;
export declare function createFlagOutcomeSlotsToJSON(createFlagOutcomeSlots: CreateFlagOutcomeSlots): string;
/** @internal */
export type CreateFlagOutcome3$Outbound = {
type?: any | undefined;
base: CreateFlagOutcomeFeatureFlagsBase$Outbound;
startTimestamp: number;
rollFromVariantId: string;
rollToVariantId: string;
defaultVariantId: string;
slots: Array<CreateFlagOutcomeSlots$Outbound>;
};
/** @internal */
export declare const CreateFlagOutcome3$outboundSchema: z.ZodType<CreateFlagOutcome3$Outbound, z.ZodTypeDef, CreateFlagOutcome3>;
export declare function createFlagOutcome3ToJSON(createFlagOutcome3: CreateFlagOutcome3): string;
/** @internal */
export type CreateFlagOutcomeBase$Outbound = {
type?: any | undefined;
kind: string;
attribute: string;
};
/** @internal */
export declare const CreateFlagOutcomeBase$outboundSchema: z.ZodType<CreateFlagOutcomeBase$Outbound, z.ZodTypeDef, CreateFlagOutcomeBase>;
export declare function createFlagOutcomeBaseToJSON(createFlagOutcomeBase: CreateFlagOutcomeBase): string;
/** @internal */
export type CreateFlagOutcome2$Outbound = {
type?: any | undefined;
base: CreateFlagOutcomeBase$Outbound;
weights: {
[k: string]: number;
};
defaultVariantId: string;
};
/** @internal */
export declare const CreateFlagOutcome2$outboundSchema: z.ZodType<CreateFlagOutcome2$Outbound, z.ZodTypeDef, CreateFlagOutcome2>;
export declare function createFlagOutcome2ToJSON(createFlagOutcome2: CreateFlagOutcome2): string;
/** @internal */
export type CreateFlagOutcome1$Outbound = {
type?: any | undefined;
variantId: string;
};
/** @internal */
export declare const CreateFlagOutcome1$outboundSchema: z.ZodType<CreateFlagOutcome1$Outbound, z.ZodTypeDef, CreateFlagOutcome1>;
export declare function createFlagOutcome1ToJSON(createFlagOutcome1: CreateFlagOutcome1): string;
/** @internal */
export type CreateFlagOutcome$Outbound = CreateFlagOutcome3$Outbound | CreateFlagOutcome2$Outbound | CreateFlagOutcome1$Outbound;
/** @internal */
export declare const CreateFlagOutcome$outboundSchema: z.ZodType<CreateFlagOutcome$Outbound, z.ZodTypeDef, CreateFlagOutcome>;
export declare function createFlagOutcomeToJSON(createFlagOutcome: CreateFlagOutcome): string;
/** @internal */
export type CreateFlagRules$Outbound = {
id: string;
conditions: Array<CreateFlagConditions$Outbound>;
outcome: CreateFlagOutcome3$Outbound | CreateFlagOutcome2$Outbound | CreateFlagOutcome1$Outbound;
};
/** @internal */
export declare const CreateFlagRules$outboundSchema: z.ZodType<CreateFlagRules$Outbound, z.ZodTypeDef, CreateFlagRules>;
export declare function createFlagRulesToJSON(createFlagRules: CreateFlagRules): string;
/** @internal */
export type CreateFlagFallthroughFeatureFlagsBase$Outbound = {
type?: any | undefined;
kind: string;
attribute: string;
};
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsBase$outboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsBase$Outbound, z.ZodTypeDef, CreateFlagFallthroughFeatureFlagsBase>;
export declare function createFlagFallthroughFeatureFlagsBaseToJSON(createFlagFallthroughFeatureFlagsBase: CreateFlagFallthroughFeatureFlagsBase): string;
/** @internal */
export type FallthroughSlots$Outbound = {
promille: number;
durationMs: number;
};
/** @internal */
export declare const FallthroughSlots$outboundSchema: z.ZodType<FallthroughSlots$Outbound, z.ZodTypeDef, FallthroughSlots>;
export declare function fallthroughSlotsToJSON(fallthroughSlots: FallthroughSlots): string;
/** @internal */
export type CreateFlagFallthrough3$Outbound = {
type?: any | undefined;
base: CreateFlagFallthroughFeatureFlagsBase$Outbound;
startTimestamp: number;
rollFromVariantId: string;
rollToVariantId: string;
defaultVariantId: string;
slots: Array<FallthroughSlots$Outbound>;
};
/** @internal */
export declare const CreateFlagFallthrough3$outboundSchema: z.ZodType<CreateFlagFallthrough3$Outbound, z.ZodTypeDef, CreateFlagFallthrough3>;
export declare function createFlagFallthrough3ToJSON(createFlagFallthrough3: CreateFlagFallthrough3): string;
/** @internal */
export type CreateFlagFallthroughBase$Outbound = {
type?: any | undefined;
kind: string;
attribute: string;
};
/** @internal */
export declare const CreateFlagFallthroughBase$outboundSchema: z.ZodType<CreateFlagFallthroughBase$Outbound, z.ZodTypeDef, CreateFlagFallthroughBase>;
export declare function createFlagFallthroughBaseToJSON(createFlagFallthroughBase: CreateFlagFallthroughBase): string;
/** @internal */
export type CreateFlagFallthrough2$Outbound = {
type?: any | undefined;
base: CreateFlagFallthroughBase$Outbound;
weights: {
[k: string]: number;
};
defaultVariantId: string;
};
/** @internal */
export declare const CreateFlagFallthrough2$outboundSchema: z.ZodType<CreateFlagFallthrough2$Outbound, z.ZodTypeDef, CreateFlagFallthrough2>;
export declare function createFlagFallthrough2ToJSON(createFlagFallthrough2: CreateFlagFallthrough2): string;
/** @internal */
export type CreateFlagFallthrough1$Outbound = {
type?: any | undefined;
variantId: string;
};
/** @internal */
export declare const CreateFlagFallthrough1$outboundSchema: z.ZodType<CreateFlagFallthrough1$Outbound, z.ZodTypeDef, CreateFlagFallthrough1>;
export declare function createFlagFallthrough1ToJSON(createFlagFallthrough1: CreateFlagFallthrough1): string;
/** @internal */
export type CreateFlagFallthrough$Outbound = CreateFlagFallthrough3$Outbound | CreateFlagFallthrough2$Outbound | CreateFlagFallthrough1$Outbound;
/** @internal */
export declare const CreateFlagFallthrough$outboundSchema: z.ZodType<CreateFlagFallthrough$Outbound, z.ZodTypeDef, CreateFlagFallthrough>;
export declare function createFlagFallthroughToJSON(createFlagFallthrough: CreateFlagFallthrough): string;
/** @internal */
export type CreateFlagEnvironments$Outbound = {
active: boolean;
reuse?: CreateFlagReuse$Outbound | undefined;
targets?: {
[k: string]: {
[k: string]: {
[k: string]: Array<CreateFlagTargets$Outbound>;
};
};
} | undefined;
pausedOutcome: CreateFlagPausedOutcome$Outbound;
rules: Array<CreateFlagRules$Outbound>;
fallthrough: CreateFlagFallthrough3$Outbound | CreateFlagFallthrough2$Outbound | CreateFlagFallthrough1$Outbound;
revision?: number | undefined;
};
/** @internal */
export declare const CreateFlagEnvironments$outboundSchema: z.ZodType<CreateFlagEnvironments$Outbound, z.ZodTypeDef, CreateFlagEnvironments>;
export declare function createFlagEnvironmentsToJSON(createFlagEnvironments: CreateFlagEnvironments): string;
/** @internal */
export declare const CreateFlagState$outboundSchema: z.ZodNativeEnum<typeof CreateFlagState>;
/** @internal */
export type CreateFlagRequestBody$Outbound = {
slug: string;
kind: string;
variants?: Array<CreateFlagVariants$Outbound> | undefined;
environments: {
[k: string]: CreateFlagEnvironments$Outbound;
};
seed?: number | undefined;
description?: string | undefined;
state?: string | undefined;
maintainerIds?: Array<string> | undefined;
permanent?: boolean | undefined;
tags?: Array<string> | undefined;
};
/** @internal */
export declare const CreateFlagRequestBody$outboundSchema: z.ZodType<CreateFlagRequestBody$Outbound, z.ZodTypeDef, CreateFlagRequestBody>;
export declare function createFlagRequestBodyToJSON(createFlagRequestBody: CreateFlagRequestBody): string;
/** @internal */
export type CreateFlagRequest$Outbound = {
projectIdOrName: string;
teamId?: string | undefined;
slug?: string | undefined;
RequestBody?: CreateFlagRequestBody$Outbound | undefined;
};
/** @internal */
export declare const CreateFlagRequest$outboundSchema: z.ZodType<CreateFlagRequest$Outbound, z.ZodTypeDef, CreateFlagRequest>;
export declare function createFlagRequestToJSON(createFlagRequest: CreateFlagRequest): string;
/** @internal */
export declare const CreateFlagFeatureFlagsVariants$inboundSchema: z.ZodType<CreateFlagFeatureFlagsVariants, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsVariantsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsVariants, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsReuse$inboundSchema: z.ZodType<CreateFlagFeatureFlagsReuse, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsReuseFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsReuse, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsTargets$inboundSchema: z.ZodType<CreateFlagFeatureFlagsTargets, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsTargetsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsTargets, SDKValidationError>;
/** @internal */
export declare const CreateFlagType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagType>;
/** @internal */
export declare const CreateFlagFeatureFlagsPausedOutcome$inboundSchema: z.ZodType<CreateFlagFeatureFlagsPausedOutcome, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsPausedOutcomeFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsPausedOutcome, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthrough4$inboundSchema: z.ZodType<CreateFlagFallthrough4, z.ZodTypeDef, unknown>;
export declare function createFlagFallthrough4FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthrough4, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONType>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201Base$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsResponse201Base, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlagsResponse201BaseFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlagsResponse201Base, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughSlots$inboundSchema: z.ZodType<CreateFlagFallthroughSlots, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughSlotsFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughSlots, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags3$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags3FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFallthroughFeatureFlagsResponse201ApplicationJSONResponseBodyType>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlagsResponseBase$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags2$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagFallthroughFeatureFlags1$inboundSchema: z.ZodType<CreateFlagFallthroughFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagFallthroughFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagFallthroughFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsFallthrough$inboundSchema: z.ZodType<CreateFlagFeatureFlagsFallthrough, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsFallthroughFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsFallthrough, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcome4$inboundSchema: z.ZodType<CreateFlagOutcome4, z.ZodTypeDef, unknown>;
export declare function createFlagOutcome4FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcome4, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONType>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201Base$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsResponse201Base, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsResponse201BaseFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsResponse201Base, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsSlots$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsSlots, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsSlotsFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsSlots, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags3$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags3, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags3FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags3, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagOutcomeFeatureFlagsResponse201ApplicationJSONResponseBodyType>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlagsResponseBase$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlagsResponseBase, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlagsResponseBaseFromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlagsResponseBase, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags2$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagOutcomeFeatureFlags1$inboundSchema: z.ZodType<CreateFlagOutcomeFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagOutcomeFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagOutcomeFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsOutcome$inboundSchema: z.ZodType<CreateFlagFeatureFlagsOutcome, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsOutcomeFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsOutcome, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsFeatureFlagsResponseType>;
/** @internal */
export declare const CreateFlagRhs4$inboundSchema: z.ZodType<CreateFlagRhs4, z.ZodTypeDef, unknown>;
export declare function createFlagRhs4FromJSON(jsonString: string): SafeParseResult<CreateFlagRhs4, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsType$inboundSchema: z.ZodNativeEnum<typeof CreateFlagRhsFeatureFlagsType>;
/** @internal */
export declare const CreateFlagItemsFeatureFlags2$inboundSchema: z.ZodType<CreateFlagItemsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagItemsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagItemsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagItemsFeatureFlags1$inboundSchema: z.ZodType<CreateFlagItemsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagItemsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagItemsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhsFeatureFlagsItems$inboundSchema: z.ZodType<CreateFlagRhsFeatureFlagsItems, z.ZodTypeDef, unknown>;
export declare function createFlagRhsFeatureFlagsItemsFromJSON(jsonString: string): SafeParseResult<CreateFlagRhsFeatureFlagsItems, SDKValidationError>;
/** @internal */
export declare const CreateFlagRhs3$inboundSchema: z.ZodType<CreateFlagRhs3, z.ZodTypeDef, unknown>;
export declare function createFlagRhs3FromJSON(jsonString: string): SafeParseResult<CreateFlagRhs3, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsRhs$inboundSchema: z.ZodType<CreateFlagFeatureFlagsRhs, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsRhsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsRhs, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsCmpOptions$inboundSchema: z.ZodType<CreateFlagFeatureFlagsCmpOptions, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsCmpOptionsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsCmpOptions, SDKValidationError>;
/** @internal */
export declare const CreateFlagLhsFeatureFlags2$inboundSchema: z.ZodType<CreateFlagLhsFeatureFlags2, z.ZodTypeDef, unknown>;
export declare function createFlagLhsFeatureFlags2FromJSON(jsonString: string): SafeParseResult<CreateFlagLhsFeatureFlags2, SDKValidationError>;
/** @internal */
export declare const CreateFlagLhsFeatureFlags1$inboundSchema: z.ZodType<CreateFlagLhsFeatureFlags1, z.ZodTypeDef, unknown>;
export declare function createFlagLhsFeatureFlags1FromJSON(jsonString: string): SafeParseResult<CreateFlagLhsFeatureFlags1, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsLhs$inboundSchema: z.ZodType<CreateFlagFeatureFlagsLhs, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsLhsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsLhs, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsCmp$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsCmp>;
/** @internal */
export declare const CreateFlagFeatureFlagsConditions$inboundSchema: z.ZodType<CreateFlagFeatureFlagsConditions, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsConditionsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsConditions, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsRules$inboundSchema: z.ZodType<CreateFlagFeatureFlagsRules, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsRulesFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsRules, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsEnvironments$inboundSchema: z.ZodType<CreateFlagFeatureFlagsEnvironments, z.ZodTypeDef, unknown>;
export declare function createFlagFeatureFlagsEnvironmentsFromJSON(jsonString: string): SafeParseResult<CreateFlagFeatureFlagsEnvironments, SDKValidationError>;
/** @internal */
export declare const CreateFlagFeatureFlagsKind$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsKind>;
/** @internal */
export declare const CreateFlagFeatureFlagsState$inboundSchema: z.ZodNativeEnum<typeof CreateFlagFeatureFlagsState>;
/** @internal */
export declare const CreateFlagTypeName$inboundSchema: z.ZodNativeEnum<typeof CreateFlagTypeName>;
/** @internal */
export declare const CreateFlagResponseBody$inboundSchema: z.ZodType<CreateFlagResponseBody, z.ZodTypeDef, unknown>;
export declare function createFlagResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateFlagResponseBody, SDKValidationError>;
//# sourceMappingURL=createflagop.d.ts.map