unleash-server 5.2.7 → 5.3.0

package/dist/lib/openapi/spec/import-toggles-schema.d.ts

@@ -4,12 +4,17 @@ export declare const importTogglesSchema: {
     readonly type: "object";
     readonly required: readonly ["project", "environment", "data"];
     readonly additionalProperties: false;
+    readonly description: "The result of the export operation for a project and environment, used at import";
     readonly properties: {
         readonly project: {
             readonly type: "string";
+            readonly example: "My awesome project";
+            readonly description: "The exported [project](https://docs.getunleash.io/reference/projects)";
         };
         readonly environment: {
             readonly type: "string";
+            readonly example: "development";
+            readonly description: "The exported [environment](https://docs.getunleash.io/reference/environments)";
         };
         readonly data: {
             readonly $ref: "#/components/schemas/exportResultSchema";
@@ -21,40 +26,105 @@ export declare const importTogglesSchema: {
                 readonly $id: "#/components/schemas/exportResultSchema";
                 readonly type: "object";
                 readonly additionalProperties: false;
+                readonly description: "The result of the export operation, providing you with the feature toggle definitions, strategy definitions and the rest of the elements relevant to the features (tags, environments etc.)";
                 readonly required: readonly ["features", "featureStrategies", "tagTypes"];
                 readonly properties: {
                     readonly features: {
                         readonly type: "array";
+                        readonly description: "All the exported features.";
+                        readonly example: readonly [{
+                            readonly name: "my-feature";
+                            readonly description: "best feature ever";
+                            readonly type: "release";
+                            readonly project: "default";
+                            readonly stale: false;
+                            readonly impressionData: false;
+                            readonly archived: false;
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/featureSchema";
                         };
                     };
                     readonly featureStrategies: {
                         readonly type: "array";
+                        readonly description: "All strategy instances that are used by the exported features in the `features` list.";
+                        readonly example: readonly [{
+                            readonly name: "flexibleRollout";
+                            readonly id: "924974d7-8003-43ee-87eb-c5f887c06fd1";
+                            readonly featureName: "my-feature";
+                            readonly title: "Rollout 50%";
+                            readonly parameters: {
+                                readonly groupId: "default";
+                                readonly rollout: "50";
+                                readonly stickiness: "random";
+                            };
+                            readonly constraints: readonly [];
+                            readonly disabled: false;
+                            readonly segments: readonly [1];
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/featureStrategySchema";
                         };
                     };
                     readonly featureEnvironments: {
                         readonly type: "array";
+                        readonly description: "Environment-specific configuration for all the features in the `features` list. Includes data such as whether the feature is enabled in the selected export environment, whether there are any variants assigned, etc.";
+                        readonly example: readonly [{
+                            readonly enabled: true;
+                            readonly featureName: "my-feature";
+                            readonly environment: "development";
+                            readonly variants: readonly [{
+                                readonly name: "a";
+                                readonly weight: 500;
+                                readonly overrides: readonly [];
+                                readonly stickiness: "random";
+                                readonly weightType: "variable";
+                            }, {
+                                readonly name: "b";
+                                readonly weight: 500;
+                                readonly overrides: readonly [];
+                                readonly stickiness: "random";
+                                readonly weightType: "variable";
+                            }];
+                            readonly name: "variant-testing";
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/featureEnvironmentSchema";
                         };
                     };
                     readonly contextFields: {
                         readonly type: "array";
+                        readonly description: "A list of all the context fields that are in use by any of the strategies in the `featureStrategies` list.";
+                        readonly example: readonly [{
+                            readonly name: "appName";
+                            readonly description: "Allows you to constrain on application name";
+                            readonly stickiness: false;
+                            readonly sortOrder: 2;
+                            readonly legalValues: readonly [];
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/contextFieldSchema";
                         };
                     };
                     readonly featureTags: {
                         readonly type: "array";
+                        readonly description: "A list of all the tags that have been applied to any of the features in the `features` list.";
+                        readonly example: readonly [{
+                            readonly featureName: "my-feature";
+                            readonly tagType: "simple";
+                            readonly tagValue: "user-facing";
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/featureTagSchema";
                         };
                     };
                     readonly segments: {
                         readonly type: "array";
+                        readonly description: "A list of all the segments that are used by the strategies in the `featureStrategies` list.";
+                        readonly example: readonly [{
+                            readonly id: 1;
+                            readonly name: "new-segment-name";
+                        }];
                         readonly items: {
                             readonly type: "object";
                             readonly additionalProperties: false;
@@ -71,6 +141,12 @@ export declare const importTogglesSchema: {
                     };
                     readonly tagTypes: {
                         readonly type: "array";
+                        readonly description: "A list of all of the tag types that are used in the `featureTags` list.";
+                        readonly example: readonly [{
+                            readonly name: "simple";
+                            readonly description: "Used to simplify filtering of features";
+                            readonly icon: "#";
+                        }];
                         readonly items: {
                             readonly $ref: "#/components/schemas/tagTypeSchema";
                         };
@@ -83,6 +159,7 @@ export declare const importTogglesSchema: {
                             readonly type: "object";
                             readonly additionalProperties: false;
                             readonly required: readonly ["name"];
+                            readonly description: "A feature toggle definition";
                             readonly properties: {
                                 readonly name: {
                                     readonly type: "string";
@@ -113,6 +190,7 @@ export declare const importTogglesSchema: {
                                 readonly enabled: {
                                     readonly type: "boolean";
                                     readonly example: true;
+                                    readonly description: "`true` if the feature is enabled, otherwise `false`.";
                                 };
                                 readonly stale: {
                                     readonly type: "boolean";
@@ -134,18 +212,21 @@ export declare const importTogglesSchema: {
                                     readonly format: "date-time";
                                     readonly nullable: true;
                                     readonly example: "2023-01-28T15:21:39.975Z";
+                                    readonly description: "The date the feature was created";
                                 };
                                 readonly archivedAt: {
                                     readonly type: "string";
                                     readonly format: "date-time";
                                     readonly nullable: true;
                                     readonly example: "2023-01-29T15:21:39.975Z";
+                                    readonly description: "The date the feature was archived";
                                 };
                                 readonly lastSeenAt: {
                                     readonly type: "string";
                                     readonly format: "date-time";
                                     readonly nullable: true;
                                     readonly example: "2023-01-28T16:21:39.975Z";
+                                    readonly description: "The date when metrics where last collected for the feature";
                                 };
                                 readonly environments: {
                                     readonly type: "array";
@@ -240,9 +321,12 @@ export declare const importTogglesSchema: {
                                             readonly featureName: {
                                                 readonly type: "string";
                                                 readonly example: "disable-comments";
+                                                readonly description: "The name of the feature";
                                             };
                                             readonly environment: {
                                                 readonly type: "string";
+                                                readonly example: "development";
+                                                readonly description: "The name of the environment";
                                             };
                                             readonly type: {
                                                 readonly type: "string";
@@ -261,6 +345,7 @@ export declare const importTogglesSchema: {
                                             };
                                             readonly variantCount: {
                                                 readonly type: "number";
+                                                readonly description: "The number of defined variants";
                                             };
                                             readonly strategies: {
                                                 readonly type: "array";
@@ -326,6 +411,7 @@ export declare const importTogglesSchema: {
                                                 readonly parametersSchema: {
                                                     readonly $id: "#/components/schemas/parametersSchema";
                                                     readonly type: "object";
+                                                    readonly description: "A list of parameters for a strategy";
                                                     readonly additionalProperties: {
                                                         readonly type: "string";
                                                     };
@@ -380,11 +466,18 @@ export declare const importTogglesSchema: {
                                                         };
                                                         readonly constraints: {
                                                             readonly type: "array";
-                                                            readonly description: "A list of the constraints attached to the strategy";
+                                                            readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                                             readonly items: {
                                                                 readonly $ref: "#/components/schemas/constraintSchema";
                                                             };
                                                         };
+                                                        readonly variants: {
+                                                            readonly type: "array";
+                                                            readonly description: "Strategy level variants";
+                                                            readonly items: {
+                                                                readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                                            };
+                                                        };
                                                         readonly parameters: {
                                                             readonly $ref: "#/components/schemas/parametersSchema";
                                                         };
@@ -438,13 +531,118 @@ export declare const importTogglesSchema: {
                                                             readonly parametersSchema: {
                                                                 readonly $id: "#/components/schemas/parametersSchema";
                                                                 readonly type: "object";
+                                                                readonly description: "A list of parameters for a strategy";
                                                                 readonly additionalProperties: {
                                                                     readonly type: "string";
                                                                 };
                                                                 readonly components: {};
                                                             };
+                                                            readonly strategyVariantSchema: {
+                                                                readonly $id: "#/components/schemas/strategyVariantSchema";
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                                                readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                                                readonly properties: {
+                                                                    readonly name: {
+                                                                        readonly type: "string";
+                                                                        readonly description: "The variant name. Must be unique for this feature toggle";
+                                                                        readonly example: "blue_group";
+                                                                    };
+                                                                    readonly weight: {
+                                                                        readonly type: "integer";
+                                                                        readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                                        readonly minimum: 0;
+                                                                        readonly maximum: 1000;
+                                                                    };
+                                                                    readonly weightType: {
+                                                                        readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                                        readonly type: "string";
+                                                                        readonly example: "fix";
+                                                                        readonly enum: readonly ["variable", "fix"];
+                                                                    };
+                                                                    readonly stickiness: {
+                                                                        readonly type: "string";
+                                                                        readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                                        readonly example: "custom.context.field";
+                                                                    };
+                                                                    readonly payload: {
+                                                                        readonly type: "object";
+                                                                        readonly required: readonly ["type", "value"];
+                                                                        readonly description: "Extra data configured for this variant";
+                                                                        readonly properties: {
+                                                                            readonly type: {
+                                                                                readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["json", "csv", "string"];
+                                                                            };
+                                                                            readonly value: {
+                                                                                readonly description: "The actual value of payload";
+                                                                                readonly type: "string";
+                                                                            };
+                                                                        };
+                                                                        readonly example: {
+                                                                            readonly type: "json";
+                                                                            readonly value: "{\"color\": \"red\"}";
+                                                                        };
+                                                                    };
+                                                                };
+                                                                readonly components: {};
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly strategyVariantSchema: {
+                                                    readonly $id: "#/components/schemas/strategyVariantSchema";
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                                    readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly description: "The variant name. Must be unique for this feature toggle";
+                                                            readonly example: "blue_group";
+                                                        };
+                                                        readonly weight: {
+                                                            readonly type: "integer";
+                                                            readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                            readonly minimum: 0;
+                                                            readonly maximum: 1000;
+                                                        };
+                                                        readonly weightType: {
+                                                            readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                            readonly type: "string";
+                                                            readonly example: "fix";
+                                                            readonly enum: readonly ["variable", "fix"];
+                                                        };
+                                                        readonly stickiness: {
+                                                            readonly type: "string";
+                                                            readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                            readonly example: "custom.context.field";
+                                                        };
+                                                        readonly payload: {
+                                                            readonly type: "object";
+                                                            readonly required: readonly ["type", "value"];
+                                                            readonly description: "Extra data configured for this variant";
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["json", "csv", "string"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly description: "The actual value of payload";
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly example: {
+                                                                readonly type: "json";
+                                                                readonly value: "{\"color\": \"red\"}";
+                                                            };
                                                         };
                                                     };
+                                                    readonly components: {};
                                                 };
                                                 readonly variantSchema: {
                                                     readonly $id: "#/components/schemas/variantSchema";
@@ -467,7 +665,8 @@ export declare const importTogglesSchema: {
                                                         readonly weightType: {
                                                             readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                                             readonly type: "string";
-                                                            readonly example: "fix";
+                                                            readonly example: "variable";
+                                                            readonly enum: readonly ["variable", "fix"];
                                                         };
                                                         readonly stickiness: {
                                                             readonly type: "string";
@@ -478,17 +677,21 @@ export declare const importTogglesSchema: {
                                                             readonly type: "object";
                                                             readonly required: readonly ["type", "value"];
                                                             readonly description: "Extra data configured for this variant";
+                                                            readonly additionalProperties: false;
                                                             readonly properties: {
                                                                 readonly type: {
+                                                                    readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                                                     readonly type: "string";
+                                                                    readonly enum: readonly ["json", "csv", "string"];
                                                                 };
                                                                 readonly value: {
+                                                                    readonly description: "The actual value of payload";
                                                                     readonly type: "string";
                                                                 };
                                                             };
                                                             readonly example: {
                                                                 readonly type: "json";
-                                                                readonly value: "{color: red}";
+                                                                readonly value: "{\"color\": \"red\"}";
                                                             };
                                                         };
                                                         readonly overrides: {
@@ -579,11 +782,18 @@ export declare const importTogglesSchema: {
                                             };
                                             readonly constraints: {
                                                 readonly type: "array";
-                                                readonly description: "A list of the constraints attached to the strategy";
+                                                readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                                 readonly items: {
                                                     readonly $ref: "#/components/schemas/constraintSchema";
                                                 };
                                             };
+                                            readonly variants: {
+                                                readonly type: "array";
+                                                readonly description: "Strategy level variants";
+                                                readonly items: {
+                                                    readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                                };
+                                            };
                                             readonly parameters: {
                                                 readonly $ref: "#/components/schemas/parametersSchema";
                                             };
@@ -637,13 +847,118 @@ export declare const importTogglesSchema: {
                                                 readonly parametersSchema: {
                                                     readonly $id: "#/components/schemas/parametersSchema";
                                                     readonly type: "object";
+                                                    readonly description: "A list of parameters for a strategy";
                                                     readonly additionalProperties: {
                                                         readonly type: "string";
                                                     };
                                                     readonly components: {};
                                                 };
+                                                readonly strategyVariantSchema: {
+                                                    readonly $id: "#/components/schemas/strategyVariantSchema";
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                                    readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly description: "The variant name. Must be unique for this feature toggle";
+                                                            readonly example: "blue_group";
+                                                        };
+                                                        readonly weight: {
+                                                            readonly type: "integer";
+                                                            readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                            readonly minimum: 0;
+                                                            readonly maximum: 1000;
+                                                        };
+                                                        readonly weightType: {
+                                                            readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                            readonly type: "string";
+                                                            readonly example: "fix";
+                                                            readonly enum: readonly ["variable", "fix"];
+                                                        };
+                                                        readonly stickiness: {
+                                                            readonly type: "string";
+                                                            readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                            readonly example: "custom.context.field";
+                                                        };
+                                                        readonly payload: {
+                                                            readonly type: "object";
+                                                            readonly required: readonly ["type", "value"];
+                                                            readonly description: "Extra data configured for this variant";
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["json", "csv", "string"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly description: "The actual value of payload";
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly example: {
+                                                                readonly type: "json";
+                                                                readonly value: "{\"color\": \"red\"}";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly components: {};
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
                                             };
                                         };
+                                        readonly components: {};
                                     };
                                     readonly overrideSchema: {
                                         readonly $id: "#/components/schemas/overrideSchema";
@@ -671,6 +986,7 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
@@ -697,7 +1013,8 @@ export declare const importTogglesSchema: {
                                             readonly weightType: {
                                                 readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                                 readonly type: "string";
-                                                readonly example: "fix";
+                                                readonly example: "variable";
+                                                readonly enum: readonly ["variable", "fix"];
                                             };
                                             readonly stickiness: {
                                                 readonly type: "string";
@@ -708,17 +1025,21 @@ export declare const importTogglesSchema: {
                                                 readonly type: "object";
                                                 readonly required: readonly ["type", "value"];
                                                 readonly description: "Extra data configured for this variant";
+                                                readonly additionalProperties: false;
                                                 readonly properties: {
                                                     readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                                         readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
                                                     };
                                                     readonly value: {
+                                                        readonly description: "The actual value of payload";
                                                         readonly type: "string";
                                                     };
                                                 };
                                                 readonly example: {
                                                     readonly type: "json";
-                                                    readonly value: "{color: red}";
+                                                    readonly value: "{\"color\": \"red\"}";
                                                 };
                                             };
                                             readonly overrides: {
@@ -834,11 +1155,18 @@ export declare const importTogglesSchema: {
                                 };
                                 readonly constraints: {
                                     readonly type: "array";
-                                    readonly description: "A list of the constraints attached to the strategy";
+                                    readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                     readonly items: {
                                         readonly $ref: "#/components/schemas/constraintSchema";
                                     };
                                 };
+                                readonly variants: {
+                                    readonly type: "array";
+                                    readonly description: "Strategy level variants";
+                                    readonly items: {
+                                        readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                    };
+                                };
                                 readonly parameters: {
                                     readonly $ref: "#/components/schemas/parametersSchema";
                                 };
@@ -892,13 +1220,118 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
                                         readonly components: {};
                                     };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
+                                };
+                            };
+                        };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
                                 };
                             };
+                            readonly components: {};
                         };
                         readonly featureEnvironmentSchema: {
                             readonly $id: "#/components/schemas/featureEnvironmentSchema";
@@ -915,9 +1348,12 @@ export declare const importTogglesSchema: {
                                 readonly featureName: {
                                     readonly type: "string";
                                     readonly example: "disable-comments";
+                                    readonly description: "The name of the feature";
                                 };
                                 readonly environment: {
                                     readonly type: "string";
+                                    readonly example: "development";
+                                    readonly description: "The name of the environment";
                                 };
                                 readonly type: {
                                     readonly type: "string";
@@ -936,6 +1372,7 @@ export declare const importTogglesSchema: {
                                 };
                                 readonly variantCount: {
                                     readonly type: "number";
+                                    readonly description: "The number of defined variants";
                                 };
                                 readonly strategies: {
                                     readonly type: "array";
@@ -1001,6 +1438,7 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
@@ -1055,11 +1493,18 @@ export declare const importTogglesSchema: {
                                             };
                                             readonly constraints: {
                                                 readonly type: "array";
-                                                readonly description: "A list of the constraints attached to the strategy";
+                                                readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                                 readonly items: {
                                                     readonly $ref: "#/components/schemas/constraintSchema";
                                                 };
                                             };
+                                            readonly variants: {
+                                                readonly type: "array";
+                                                readonly description: "Strategy level variants";
+                                                readonly items: {
+                                                    readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                                };
+                                            };
                                             readonly parameters: {
                                                 readonly $ref: "#/components/schemas/parametersSchema";
                                             };
@@ -1113,36 +1558,142 @@ export declare const importTogglesSchema: {
                                                 readonly parametersSchema: {
                                                     readonly $id: "#/components/schemas/parametersSchema";
                                                     readonly type: "object";
+                                                    readonly description: "A list of parameters for a strategy";
                                                     readonly additionalProperties: {
                                                         readonly type: "string";
                                                     };
                                                     readonly components: {};
                                                 };
-                                            };
-                                        };
-                                    };
-                                    readonly variantSchema: {
-                                        readonly $id: "#/components/schemas/variantSchema";
-                                        readonly type: "object";
-                                        readonly additionalProperties: false;
-                                        readonly description: "A variant allows for further separation of users into segments. See [our excellent documentation](https://docs.getunleash.io/reference/feature-toggle-variants#what-are-variants) for a more detailed description";
-                                        readonly required: readonly ["name", "weight"];
-                                        readonly properties: {
-                                            readonly name: {
-                                                readonly type: "string";
-                                                readonly description: "The variants name. Is unique for this feature toggle";
-                                                readonly example: "blue_group";
-                                            };
-                                            readonly weight: {
-                                                readonly type: "number";
-                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is a number between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
-                                                readonly minimum: 0;
-                                                readonly maximum: 1000;
-                                            };
-                                            readonly weightType: {
-                                                readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
-                                                readonly type: "string";
+                                                readonly strategyVariantSchema: {
+                                                    readonly $id: "#/components/schemas/strategyVariantSchema";
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                                    readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly description: "The variant name. Must be unique for this feature toggle";
+                                                            readonly example: "blue_group";
+                                                        };
+                                                        readonly weight: {
+                                                            readonly type: "integer";
+                                                            readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                            readonly minimum: 0;
+                                                            readonly maximum: 1000;
+                                                        };
+                                                        readonly weightType: {
+                                                            readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                            readonly type: "string";
+                                                            readonly example: "fix";
+                                                            readonly enum: readonly ["variable", "fix"];
+                                                        };
+                                                        readonly stickiness: {
+                                                            readonly type: "string";
+                                                            readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                            readonly example: "custom.context.field";
+                                                        };
+                                                        readonly payload: {
+                                                            readonly type: "object";
+                                                            readonly required: readonly ["type", "value"];
+                                                            readonly description: "Extra data configured for this variant";
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["json", "csv", "string"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly description: "The actual value of payload";
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly example: {
+                                                                readonly type: "json";
+                                                                readonly value: "{\"color\": \"red\"}";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly components: {};
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
                                                 readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
+                                    readonly variantSchema: {
+                                        readonly $id: "#/components/schemas/variantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "A variant allows for further separation of users into segments. See [our excellent documentation](https://docs.getunleash.io/reference/feature-toggle-variants#what-are-variants) for a more detailed description";
+                                        readonly required: readonly ["name", "weight"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variants name. Is unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "number";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is a number between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
+                                                readonly type: "string";
+                                                readonly example: "variable";
+                                                readonly enum: readonly ["variable", "fix"];
                                             };
                                             readonly stickiness: {
                                                 readonly type: "string";
@@ -1153,17 +1704,21 @@ export declare const importTogglesSchema: {
                                                 readonly type: "object";
                                                 readonly required: readonly ["type", "value"];
                                                 readonly description: "Extra data configured for this variant";
+                                                readonly additionalProperties: false;
                                                 readonly properties: {
                                                     readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                                         readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
                                                     };
                                                     readonly value: {
+                                                        readonly description: "The actual value of payload";
                                                         readonly type: "string";
                                                     };
                                                 };
                                                 readonly example: {
                                                     readonly type: "json";
-                                                    readonly value: "{color: red}";
+                                                    readonly value: "{\"color\": \"red\"}";
                                                 };
                                             };
                                             readonly overrides: {
@@ -1209,39 +1764,53 @@ export declare const importTogglesSchema: {
                             readonly $id: "#/components/schemas/contextFieldSchema";
                             readonly type: "object";
                             readonly additionalProperties: false;
+                            readonly description: "A representation of a [context field](https://docs.getunleash.io/reference/unleash-context).";
                             readonly required: readonly ["name"];
                             readonly properties: {
                                 readonly name: {
+                                    readonly description: "The name of the context field";
                                     readonly type: "string";
+                                    readonly example: "userId";
                                 };
                                 readonly description: {
+                                    readonly description: "The description of the context field.";
                                     readonly type: "string";
                                     readonly nullable: true;
+                                    readonly example: "Used to uniquely identify users";
                                 };
                                 readonly stickiness: {
+                                    readonly description: "Does this context field support being used for [stickiness](https://docs.getunleash.io/reference/stickiness) calculations";
                                     readonly type: "boolean";
+                                    readonly example: true;
                                 };
                                 readonly sortOrder: {
-                                    readonly type: "number";
+                                    readonly description: "Used when sorting a list of context fields. Is also used as a tiebreaker if a list of context fields is sorted alphabetically.";
+                                    readonly type: "integer";
+                                    readonly example: 900;
                                 };
                                 readonly createdAt: {
+                                    readonly description: "When this context field was created";
                                     readonly type: "string";
                                     readonly format: "date-time";
                                     readonly nullable: true;
+                                    readonly example: "2023-06-29T10:19:00.000Z";
                                 };
                                 readonly usedInFeatures: {
-                                    readonly type: "number";
+                                    readonly type: "integer";
                                     readonly description: "Number of projects where this context field is used in";
                                     readonly example: 3;
                                     readonly nullable: true;
+                                    readonly minimum: 0;
                                 };
                                 readonly usedInProjects: {
-                                    readonly type: "number";
+                                    readonly type: "integer";
                                     readonly description: "Number of projects where this context field is used in";
                                     readonly example: 2;
                                     readonly nullable: true;
+                                    readonly minimum: 0;
                                 };
                                 readonly legalValues: {
+                                    readonly description: "Allowed values for this context field schema. Can be used to narrow down accepted input";
                                     readonly type: "array";
                                     readonly items: {
                                         readonly $ref: "#/components/schemas/legalValueSchema";
@@ -1254,13 +1823,18 @@ export declare const importTogglesSchema: {
                                         readonly $id: "#/components/schemas/legalValueSchema";
                                         readonly type: "object";
                                         readonly additionalProperties: false;
+                                        readonly description: "Describes a legal value. Typically used to limit possible values for contextFields or strategy properties";
                                         readonly required: readonly ["value"];
                                         readonly properties: {
                                             readonly value: {
+                                                readonly description: "The valid value";
                                                 readonly type: "string";
+                                                readonly example: "#c154c1";
                                             };
                                             readonly description: {
+                                                readonly description: "Describes this specific legal value";
                                                 readonly type: "string";
+                                                readonly example: "Deep fuchsia";
                                             };
                                         };
                                         readonly components: {};
@@ -1332,7 +1906,8 @@ export declare const importTogglesSchema: {
                                             readonly weightType: {
                                                 readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                                 readonly type: "string";
-                                                readonly example: "fix";
+                                                readonly example: "variable";
+                                                readonly enum: readonly ["variable", "fix"];
                                             };
                                             readonly stickiness: {
                                                 readonly type: "string";
@@ -1343,17 +1918,21 @@ export declare const importTogglesSchema: {
                                                 readonly type: "object";
                                                 readonly required: readonly ["type", "value"];
                                                 readonly description: "Extra data configured for this variant";
+                                                readonly additionalProperties: false;
                                                 readonly properties: {
                                                     readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                                         readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
                                                     };
                                                     readonly value: {
+                                                        readonly description: "The actual value of payload";
                                                         readonly type: "string";
                                                     };
                                                 };
                                                 readonly example: {
                                                     readonly type: "json";
-                                                    readonly value: "{color: red}";
+                                                    readonly value: "{\"color\": \"red\"}";
                                                 };
                                             };
                                             readonly overrides: {
@@ -1439,7 +2018,8 @@ export declare const importTogglesSchema: {
                                 readonly weightType: {
                                     readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                     readonly type: "string";
-                                    readonly example: "fix";
+                                    readonly example: "variable";
+                                    readonly enum: readonly ["variable", "fix"];
                                 };
                                 readonly stickiness: {
                                     readonly type: "string";
@@ -1450,17 +2030,21 @@ export declare const importTogglesSchema: {
                                     readonly type: "object";
                                     readonly required: readonly ["type", "value"];
                                     readonly description: "Extra data configured for this variant";
+                                    readonly additionalProperties: false;
                                     readonly properties: {
                                         readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                             readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
                                         };
                                         readonly value: {
+                                            readonly description: "The actual value of payload";
                                             readonly type: "string";
                                         };
                                     };
                                     readonly example: {
                                         readonly type: "json";
-                                        readonly value: "{color: red}";
+                                        readonly value: "{\"color\": \"red\"}";
                                     };
                                 };
                                 readonly overrides: {
@@ -1569,6 +2153,7 @@ export declare const importTogglesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
@@ -1578,13 +2163,18 @@ export declare const importTogglesSchema: {
                             readonly $id: "#/components/schemas/legalValueSchema";
                             readonly type: "object";
                             readonly additionalProperties: false;
+                            readonly description: "Describes a legal value. Typically used to limit possible values for contextFields or strategy properties";
                             readonly required: readonly ["value"];
                             readonly properties: {
                                 readonly value: {
+                                    readonly description: "The valid value";
                                     readonly type: "string";
+                                    readonly example: "#c154c1";
                                 };
                                 readonly description: {
+                                    readonly description: "Describes this specific legal value";
                                     readonly type: "string";
+                                    readonly example: "Deep fuchsia";
                                 };
                             };
                             readonly components: {};
@@ -1593,17 +2183,24 @@ export declare const importTogglesSchema: {
                             readonly $id: "#/components/schemas/tagTypeSchema";
                             readonly type: "object";
                             readonly additionalProperties: false;
+                            readonly description: "A tag type.";
                             readonly required: readonly ["name"];
                             readonly properties: {
                                 readonly name: {
                                     readonly type: "string";
+                                    readonly description: "The name of the tag type.";
+                                    readonly example: "color";
                                 };
                                 readonly description: {
                                     readonly type: "string";
+                                    readonly description: "The description of the tag type.";
+                                    readonly example: "A tag type for describing the color of a tag.";
                                 };
                                 readonly icon: {
                                     readonly type: "string";
                                     readonly nullable: true;
+                                    readonly description: "The icon of the tag type.";
+                                    readonly example: "not-really-used";
                                 };
                             };
                             readonly components: {};
@@ -1616,6 +2213,7 @@ export declare const importTogglesSchema: {
                 readonly type: "object";
                 readonly additionalProperties: false;
                 readonly required: readonly ["name"];
+                readonly description: "A feature toggle definition";
                 readonly properties: {
                     readonly name: {
                         readonly type: "string";
@@ -1646,6 +2244,7 @@ export declare const importTogglesSchema: {
                     readonly enabled: {
                         readonly type: "boolean";
                         readonly example: true;
+                        readonly description: "`true` if the feature is enabled, otherwise `false`.";
                     };
                     readonly stale: {
                         readonly type: "boolean";
@@ -1667,18 +2266,21 @@ export declare const importTogglesSchema: {
                         readonly format: "date-time";
                         readonly nullable: true;
                         readonly example: "2023-01-28T15:21:39.975Z";
+                        readonly description: "The date the feature was created";
                     };
                     readonly archivedAt: {
                         readonly type: "string";
                         readonly format: "date-time";
                         readonly nullable: true;
                         readonly example: "2023-01-29T15:21:39.975Z";
+                        readonly description: "The date the feature was archived";
                     };
                     readonly lastSeenAt: {
                         readonly type: "string";
                         readonly format: "date-time";
                         readonly nullable: true;
                         readonly example: "2023-01-28T16:21:39.975Z";
+                        readonly description: "The date when metrics where last collected for the feature";
                     };
                     readonly environments: {
                         readonly type: "array";
@@ -1773,9 +2375,12 @@ export declare const importTogglesSchema: {
                                 readonly featureName: {
                                     readonly type: "string";
                                     readonly example: "disable-comments";
+                                    readonly description: "The name of the feature";
                                 };
                                 readonly environment: {
                                     readonly type: "string";
+                                    readonly example: "development";
+                                    readonly description: "The name of the environment";
                                 };
                                 readonly type: {
                                     readonly type: "string";
@@ -1794,6 +2399,7 @@ export declare const importTogglesSchema: {
                                 };
                                 readonly variantCount: {
                                     readonly type: "number";
+                                    readonly description: "The number of defined variants";
                                 };
                                 readonly strategies: {
                                     readonly type: "array";
@@ -1859,6 +2465,7 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
@@ -1913,11 +2520,18 @@ export declare const importTogglesSchema: {
                                             };
                                             readonly constraints: {
                                                 readonly type: "array";
-                                                readonly description: "A list of the constraints attached to the strategy";
+                                                readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                                 readonly items: {
                                                     readonly $ref: "#/components/schemas/constraintSchema";
                                                 };
                                             };
+                                            readonly variants: {
+                                                readonly type: "array";
+                                                readonly description: "Strategy level variants";
+                                                readonly items: {
+                                                    readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                                };
+                                            };
                                             readonly parameters: {
                                                 readonly $ref: "#/components/schemas/parametersSchema";
                                             };
@@ -1971,14 +2585,119 @@ export declare const importTogglesSchema: {
                                                 readonly parametersSchema: {
                                                     readonly $id: "#/components/schemas/parametersSchema";
                                                     readonly type: "object";
+                                                    readonly description: "A list of parameters for a strategy";
                                                     readonly additionalProperties: {
                                                         readonly type: "string";
                                                     };
                                                     readonly components: {};
                                                 };
+                                                readonly strategyVariantSchema: {
+                                                    readonly $id: "#/components/schemas/strategyVariantSchema";
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                                    readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly description: "The variant name. Must be unique for this feature toggle";
+                                                            readonly example: "blue_group";
+                                                        };
+                                                        readonly weight: {
+                                                            readonly type: "integer";
+                                                            readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                            readonly minimum: 0;
+                                                            readonly maximum: 1000;
+                                                        };
+                                                        readonly weightType: {
+                                                            readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                            readonly type: "string";
+                                                            readonly example: "fix";
+                                                            readonly enum: readonly ["variable", "fix"];
+                                                        };
+                                                        readonly stickiness: {
+                                                            readonly type: "string";
+                                                            readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                            readonly example: "custom.context.field";
+                                                        };
+                                                        readonly payload: {
+                                                            readonly type: "object";
+                                                            readonly required: readonly ["type", "value"];
+                                                            readonly description: "Extra data configured for this variant";
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["json", "csv", "string"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly description: "The actual value of payload";
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly example: {
+                                                                readonly type: "json";
+                                                                readonly value: "{\"color\": \"red\"}";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly components: {};
+                                                };
                                             };
                                         };
                                     };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
                                     readonly variantSchema: {
                                         readonly $id: "#/components/schemas/variantSchema";
                                         readonly type: "object";
@@ -2000,7 +2719,8 @@ export declare const importTogglesSchema: {
                                             readonly weightType: {
                                                 readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                                 readonly type: "string";
-                                                readonly example: "fix";
+                                                readonly example: "variable";
+                                                readonly enum: readonly ["variable", "fix"];
                                             };
                                             readonly stickiness: {
                                                 readonly type: "string";
@@ -2011,17 +2731,21 @@ export declare const importTogglesSchema: {
                                                 readonly type: "object";
                                                 readonly required: readonly ["type", "value"];
                                                 readonly description: "Extra data configured for this variant";
+                                                readonly additionalProperties: false;
                                                 readonly properties: {
                                                     readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                                         readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
                                                     };
                                                     readonly value: {
+                                                        readonly description: "The actual value of payload";
                                                         readonly type: "string";
                                                     };
                                                 };
                                                 readonly example: {
                                                     readonly type: "json";
-                                                    readonly value: "{color: red}";
+                                                    readonly value: "{\"color\": \"red\"}";
                                                 };
                                             };
                                             readonly overrides: {
@@ -2112,11 +2836,18 @@ export declare const importTogglesSchema: {
                                 };
                                 readonly constraints: {
                                     readonly type: "array";
-                                    readonly description: "A list of the constraints attached to the strategy";
+                                    readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                     readonly items: {
                                         readonly $ref: "#/components/schemas/constraintSchema";
                                     };
                                 };
+                                readonly variants: {
+                                    readonly type: "array";
+                                    readonly description: "Strategy level variants";
+                                    readonly items: {
+                                        readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                    };
+                                };
                                 readonly parameters: {
                                     readonly $ref: "#/components/schemas/parametersSchema";
                                 };
@@ -2170,14 +2901,119 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
                                         readonly components: {};
                                     };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
                                 };
                             };
                         };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
                         readonly overrideSchema: {
                             readonly $id: "#/components/schemas/overrideSchema";
                             readonly type: "object";
@@ -2204,6 +3040,7 @@ export declare const importTogglesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
@@ -2230,7 +3067,8 @@ export declare const importTogglesSchema: {
                                 readonly weightType: {
                                     readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                     readonly type: "string";
-                                    readonly example: "fix";
+                                    readonly example: "variable";
+                                    readonly enum: readonly ["variable", "fix"];
                                 };
                                 readonly stickiness: {
                                     readonly type: "string";
@@ -2241,17 +3079,21 @@ export declare const importTogglesSchema: {
                                     readonly type: "object";
                                     readonly required: readonly ["type", "value"];
                                     readonly description: "Extra data configured for this variant";
+                                    readonly additionalProperties: false;
                                     readonly properties: {
                                         readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                             readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
                                         };
                                         readonly value: {
+                                            readonly description: "The actual value of payload";
                                             readonly type: "string";
                                         };
                                     };
                                     readonly example: {
                                         readonly type: "json";
-                                        readonly value: "{color: red}";
+                                        readonly value: "{\"color\": \"red\"}";
                                     };
                                 };
                                 readonly overrides: {
@@ -2367,11 +3209,18 @@ export declare const importTogglesSchema: {
                     };
                     readonly constraints: {
                         readonly type: "array";
-                        readonly description: "A list of the constraints attached to the strategy";
+                        readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                         readonly items: {
                             readonly $ref: "#/components/schemas/constraintSchema";
                         };
                     };
+                    readonly variants: {
+                        readonly type: "array";
+                        readonly description: "Strategy level variants";
+                        readonly items: {
+                            readonly $ref: "#/components/schemas/strategyVariantSchema";
+                        };
+                    };
                     readonly parameters: {
                         readonly $ref: "#/components/schemas/parametersSchema";
                     };
@@ -2425,14 +3274,119 @@ export declare const importTogglesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
                             readonly components: {};
                         };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
                     };
                 };
             };
+            readonly strategyVariantSchema: {
+                readonly $id: "#/components/schemas/strategyVariantSchema";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly description: "The variant name. Must be unique for this feature toggle";
+                        readonly example: "blue_group";
+                    };
+                    readonly weight: {
+                        readonly type: "integer";
+                        readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                        readonly minimum: 0;
+                        readonly maximum: 1000;
+                    };
+                    readonly weightType: {
+                        readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                        readonly type: "string";
+                        readonly example: "fix";
+                        readonly enum: readonly ["variable", "fix"];
+                    };
+                    readonly stickiness: {
+                        readonly type: "string";
+                        readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                        readonly example: "custom.context.field";
+                    };
+                    readonly payload: {
+                        readonly type: "object";
+                        readonly required: readonly ["type", "value"];
+                        readonly description: "Extra data configured for this variant";
+                        readonly properties: {
+                            readonly type: {
+                                readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                readonly type: "string";
+                                readonly enum: readonly ["json", "csv", "string"];
+                            };
+                            readonly value: {
+                                readonly description: "The actual value of payload";
+                                readonly type: "string";
+                            };
+                        };
+                        readonly example: {
+                            readonly type: "json";
+                            readonly value: "{\"color\": \"red\"}";
+                        };
+                    };
+                };
+                readonly components: {};
+            };
             readonly featureEnvironmentSchema: {
                 readonly $id: "#/components/schemas/featureEnvironmentSchema";
                 readonly type: "object";
@@ -2448,9 +3402,12 @@ export declare const importTogglesSchema: {
                     readonly featureName: {
                         readonly type: "string";
                         readonly example: "disable-comments";
+                        readonly description: "The name of the feature";
                     };
                     readonly environment: {
                         readonly type: "string";
+                        readonly example: "development";
+                        readonly description: "The name of the environment";
                     };
                     readonly type: {
                         readonly type: "string";
@@ -2469,6 +3426,7 @@ export declare const importTogglesSchema: {
                     };
                     readonly variantCount: {
                         readonly type: "number";
+                        readonly description: "The number of defined variants";
                     };
                     readonly strategies: {
                         readonly type: "array";
@@ -2534,6 +3492,7 @@ export declare const importTogglesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
@@ -2588,11 +3547,18 @@ export declare const importTogglesSchema: {
                                 };
                                 readonly constraints: {
                                     readonly type: "array";
-                                    readonly description: "A list of the constraints attached to the strategy";
+                                    readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                     readonly items: {
                                         readonly $ref: "#/components/schemas/constraintSchema";
                                     };
                                 };
+                                readonly variants: {
+                                    readonly type: "array";
+                                    readonly description: "Strategy level variants";
+                                    readonly items: {
+                                        readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                    };
+                                };
                                 readonly parameters: {
                                     readonly $ref: "#/components/schemas/parametersSchema";
                                 };
@@ -2646,14 +3612,119 @@ export declare const importTogglesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
                                         readonly components: {};
                                     };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
                                 };
                             };
                         };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
                         readonly variantSchema: {
                             readonly $id: "#/components/schemas/variantSchema";
                             readonly type: "object";
@@ -2675,7 +3746,8 @@ export declare const importTogglesSchema: {
                                 readonly weightType: {
                                     readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                     readonly type: "string";
-                                    readonly example: "fix";
+                                    readonly example: "variable";
+                                    readonly enum: readonly ["variable", "fix"];
                                 };
                                 readonly stickiness: {
                                     readonly type: "string";
@@ -2686,17 +3758,21 @@ export declare const importTogglesSchema: {
                                     readonly type: "object";
                                     readonly required: readonly ["type", "value"];
                                     readonly description: "Extra data configured for this variant";
+                                    readonly additionalProperties: false;
                                     readonly properties: {
                                         readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                             readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
                                         };
                                         readonly value: {
+                                            readonly description: "The actual value of payload";
                                             readonly type: "string";
                                         };
                                     };
                                     readonly example: {
                                         readonly type: "json";
-                                        readonly value: "{color: red}";
+                                        readonly value: "{\"color\": \"red\"}";
                                     };
                                 };
                                 readonly overrides: {
@@ -2742,39 +3818,53 @@ export declare const importTogglesSchema: {
                 readonly $id: "#/components/schemas/contextFieldSchema";
                 readonly type: "object";
                 readonly additionalProperties: false;
+                readonly description: "A representation of a [context field](https://docs.getunleash.io/reference/unleash-context).";
                 readonly required: readonly ["name"];
                 readonly properties: {
                     readonly name: {
+                        readonly description: "The name of the context field";
                         readonly type: "string";
+                        readonly example: "userId";
                     };
                     readonly description: {
+                        readonly description: "The description of the context field.";
                         readonly type: "string";
                         readonly nullable: true;
+                        readonly example: "Used to uniquely identify users";
                     };
                     readonly stickiness: {
+                        readonly description: "Does this context field support being used for [stickiness](https://docs.getunleash.io/reference/stickiness) calculations";
                         readonly type: "boolean";
+                        readonly example: true;
                     };
                     readonly sortOrder: {
-                        readonly type: "number";
+                        readonly description: "Used when sorting a list of context fields. Is also used as a tiebreaker if a list of context fields is sorted alphabetically.";
+                        readonly type: "integer";
+                        readonly example: 900;
                     };
                     readonly createdAt: {
+                        readonly description: "When this context field was created";
                         readonly type: "string";
                         readonly format: "date-time";
                         readonly nullable: true;
+                        readonly example: "2023-06-29T10:19:00.000Z";
                     };
                     readonly usedInFeatures: {
-                        readonly type: "number";
+                        readonly type: "integer";
                         readonly description: "Number of projects where this context field is used in";
                         readonly example: 3;
                         readonly nullable: true;
+                        readonly minimum: 0;
                     };
                     readonly usedInProjects: {
-                        readonly type: "number";
+                        readonly type: "integer";
                         readonly description: "Number of projects where this context field is used in";
                         readonly example: 2;
                         readonly nullable: true;
+                        readonly minimum: 0;
                     };
                     readonly legalValues: {
+                        readonly description: "Allowed values for this context field schema. Can be used to narrow down accepted input";
                         readonly type: "array";
                         readonly items: {
                             readonly $ref: "#/components/schemas/legalValueSchema";
@@ -2787,13 +3877,18 @@ export declare const importTogglesSchema: {
                             readonly $id: "#/components/schemas/legalValueSchema";
                             readonly type: "object";
                             readonly additionalProperties: false;
+                            readonly description: "Describes a legal value. Typically used to limit possible values for contextFields or strategy properties";
                             readonly required: readonly ["value"];
                             readonly properties: {
                                 readonly value: {
+                                    readonly description: "The valid value";
                                     readonly type: "string";
+                                    readonly example: "#c154c1";
                                 };
                                 readonly description: {
+                                    readonly description: "Describes this specific legal value";
                                     readonly type: "string";
+                                    readonly example: "Deep fuchsia";
                                 };
                             };
                             readonly components: {};
@@ -2843,6 +3938,29 @@ export declare const importTogglesSchema: {
                 readonly additionalProperties: false;
                 readonly required: readonly ["id", "constraints"];
                 readonly properties: {
+                    readonly description: {
+                        readonly type: "string";
+                        readonly nullable: true;
+                        readonly description: "The description of the segment.";
+                        readonly example: "Segment A description";
+                    };
+                    readonly createdAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "The time the segment was created as a RFC 3339-conformant timestamp.";
+                        readonly example: "2023-07-05T12:56:00.000Z";
+                    };
+                    readonly createdBy: {
+                        readonly type: "string";
+                        readonly description: "Which user created this segment";
+                        readonly example: "johndoe";
+                    };
+                    readonly project: {
+                        readonly type: "string";
+                        readonly nullable: true;
+                        readonly description: "The project the segment relates to, if applicable.";
+                        readonly example: "default";
+                    };
                     readonly id: {
                         readonly type: "number";
                         readonly description: "The segment's id.";
@@ -2852,12 +3970,6 @@ export declare const importTogglesSchema: {
                         readonly description: "The name of the segment.";
                         readonly example: "segment A";
                     };
-                    readonly description: {
-                        readonly type: "string";
-                        readonly nullable: true;
-                        readonly description: "The description of the segment.";
-                        readonly example: "Segment A description";
-                    };
                     readonly constraints: {
                         readonly type: "array";
                         readonly description: "List of constraints that determine which users are part of the segment";
@@ -2944,7 +4056,8 @@ export declare const importTogglesSchema: {
                                 readonly weightType: {
                                     readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                     readonly type: "string";
-                                    readonly example: "fix";
+                                    readonly example: "variable";
+                                    readonly enum: readonly ["variable", "fix"];
                                 };
                                 readonly stickiness: {
                                     readonly type: "string";
@@ -2955,17 +4068,21 @@ export declare const importTogglesSchema: {
                                     readonly type: "object";
                                     readonly required: readonly ["type", "value"];
                                     readonly description: "Extra data configured for this variant";
+                                    readonly additionalProperties: false;
                                     readonly properties: {
                                         readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                             readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
                                         };
                                         readonly value: {
+                                            readonly description: "The actual value of payload";
                                             readonly type: "string";
                                         };
                                     };
                                     readonly example: {
                                         readonly type: "json";
-                                        readonly value: "{color: red}";
+                                        readonly value: "{\"color\": \"red\"}";
                                     };
                                 };
                                 readonly overrides: {
@@ -3051,7 +4168,8 @@ export declare const importTogglesSchema: {
                     readonly weightType: {
                         readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                         readonly type: "string";
-                        readonly example: "fix";
+                        readonly example: "variable";
+                        readonly enum: readonly ["variable", "fix"];
                     };
                     readonly stickiness: {
                         readonly type: "string";
@@ -3062,17 +4180,21 @@ export declare const importTogglesSchema: {
                         readonly type: "object";
                         readonly required: readonly ["type", "value"];
                         readonly description: "Extra data configured for this variant";
+                        readonly additionalProperties: false;
                         readonly properties: {
                             readonly type: {
+                                readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                 readonly type: "string";
+                                readonly enum: readonly ["json", "csv", "string"];
                             };
                             readonly value: {
+                                readonly description: "The actual value of payload";
                                 readonly type: "string";
                             };
                         };
                         readonly example: {
                             readonly type: "json";
-                            readonly value: "{color: red}";
+                            readonly value: "{\"color\": \"red\"}";
                         };
                     };
                     readonly overrides: {
@@ -3181,6 +4303,7 @@ export declare const importTogglesSchema: {
             readonly parametersSchema: {
                 readonly $id: "#/components/schemas/parametersSchema";
                 readonly type: "object";
+                readonly description: "A list of parameters for a strategy";
                 readonly additionalProperties: {
                     readonly type: "string";
                 };
@@ -3190,13 +4313,18 @@ export declare const importTogglesSchema: {
                 readonly $id: "#/components/schemas/legalValueSchema";
                 readonly type: "object";
                 readonly additionalProperties: false;
+                readonly description: "Describes a legal value. Typically used to limit possible values for contextFields or strategy properties";
                 readonly required: readonly ["value"];
                 readonly properties: {
                     readonly value: {
+                        readonly description: "The valid value";
                         readonly type: "string";
+                        readonly example: "#c154c1";
                     };
                     readonly description: {
+                        readonly description: "Describes this specific legal value";
                         readonly type: "string";
+                        readonly example: "Deep fuchsia";
                     };
                 };
                 readonly components: {};
@@ -3205,17 +4333,24 @@ export declare const importTogglesSchema: {
                 readonly $id: "#/components/schemas/tagTypeSchema";
                 readonly type: "object";
                 readonly additionalProperties: false;
+                readonly description: "A tag type.";
                 readonly required: readonly ["name"];
                 readonly properties: {
                     readonly name: {
                         readonly type: "string";
+                        readonly description: "The name of the tag type.";
+                        readonly example: "color";
                     };
                     readonly description: {
                         readonly type: "string";
+                        readonly description: "The description of the tag type.";
+                        readonly example: "A tag type for describing the color of a tag.";
                     };
                     readonly icon: {
                         readonly type: "string";
                         readonly nullable: true;
+                        readonly description: "The icon of the tag type.";
+                        readonly example: "not-really-used";
                     };
                 };
                 readonly components: {};