@featurevisor/types 2.0.1 → 2.0.3

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.0.3](https://github.com/featurevisor/featurevisor/compare/v2.0.2...v2.0.3) (2025-07-20)
+
+**Note:** Version bump only for package @featurevisor/types
+
+
+
+
+
+## [2.0.2](https://github.com/featurevisor/featurevisor/compare/v2.0.1...v2.0.2) (2025-07-19)
+
+**Note:** Version bump only for package @featurevisor/types
+
+
+
+
+
 ## [2.0.1](https://github.com/featurevisor/featurevisor/compare/v2.0.0...v2.0.1) (2025-07-19)
 
 **Note:** Version bump only for package @featurevisor/types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/types",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Common Typescript types for Featurevisor",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -15,7 +15,7 @@
   "scripts": {
     "transpile": "echo 'Nothing to transpile'",
     "dist": "echo 'Nothing to dist'",
-    "build": "echo 'Nothing to build'",
+    "build": "tsc ./src/index.d.ts",
     "test": "echo 'Nothing to test in types package'"
   },
   "author": {
@@ -47,5 +47,5 @@
     "url": "https://github.com/featurevisor/featurevisor/issues"
   },
   "license": "MIT",
-  "gitHead": "f5d883e1d6f8ba1b0c14fbbd79329b98f66b46e8"
+  "gitHead": "5522c5cb67b648aac05c100733390e92a42f694b"
 }

package/src/attribute.d.ts

@@ -0,0 +1,46 @@
+export type AttributeKey = string;
+
+export interface AttributeObjectValue {
+  [key: AttributeKey]: AttributeValue;
+}
+
+export type AttributeValue =
+  | string
+  | number
+  | boolean
+  | Date
+  | null
+  | undefined
+  | string[]
+  | AttributeObjectValue;
+
+export type AttributeType =
+  | "boolean"
+  | "string"
+  | "integer"
+  | "double"
+  | "date"
+  | "semver"
+  | "object"
+  | "array";
+
+export interface Attribute {
+  archived?: boolean; // only available in YAML files
+  key?: AttributeKey; // needed for supporting v1 datafile generation
+  type: AttributeType;
+  description?: string; // only available in YAML files
+  properties?: {
+    [key: AttributeKey]: {
+      type:
+        | "boolean"
+        | "string"
+        | "integer"
+        | "double"
+        | "date"
+        | "semver"
+        // | "object" // NOTE: avoid nesting for now
+        | "array";
+      description?: string;
+    };
+  };
+}

package/src/bucket.d.ts

@@ -0,0 +1,8 @@
+import type { AttributeKey } from "./attribute";
+
+export type PlainBucketBy = AttributeKey;
+export type AndBucketBy = AttributeKey[];
+export interface OrBucketBy {
+  or: AttributeKey[];
+}
+export type BucketBy = PlainBucketBy | AndBucketBy | OrBucketBy;

package/src/condition.d.ts

@@ -0,0 +1,68 @@
+import type { AttributeKey } from "./attribute";
+
+export type Operator =
+  | "equals"
+  | "notEquals"
+  | "exists"
+  | "notExists"
+
+  // numeric
+  | "greaterThan"
+  | "greaterThanOrEquals"
+  | "lessThan"
+  | "lessThanOrEquals"
+
+  // string
+  | "contains"
+  | "notContains"
+  | "startsWith"
+  | "endsWith"
+
+  // semver (string)
+  | "semverEquals"
+  | "semverNotEquals"
+  | "semverGreaterThan"
+  | "semverGreaterThanOrEquals"
+  | "semverLessThan"
+  | "semverLessThanOrEquals"
+
+  // date comparisons
+  | "before"
+  | "after"
+
+  // array of strings
+  | "includes"
+  | "notIncludes"
+
+  // regex
+  | "matches"
+  | "notMatches"
+
+  // array of strings
+  | "in"
+  | "notIn";
+
+export type ConditionValue = string | number | boolean | Date | null | undefined | string[];
+
+export interface PlainCondition {
+  attribute: AttributeKey;
+  operator: Operator;
+  value?: ConditionValue; // for all operators, except for "exists" and "notExists"
+  regexFlags?: string; // for regex operators only (matches, notMatches)
+}
+
+export interface AndCondition {
+  and: Condition[];
+}
+
+export interface OrCondition {
+  or: Condition[];
+}
+
+export interface NotCondition {
+  not: Condition[];
+}
+
+export type AndOrNotCondition = AndCondition | OrCondition | NotCondition;
+
+export type Condition = PlainCondition | AndOrNotCondition | string;

package/src/context.d.ts

@@ -0,0 +1,5 @@
+import type { AttributeKey, AttributeValue } from "./attribute";
+
+export interface Context {
+  [key: AttributeKey]: AttributeValue;
+}

package/src/datafile.d.ts

@@ -0,0 +1,89 @@
+import type { Attribute } from "./attribute";
+import type { BucketBy } from "./bucket";
+import type {
+  VariationValue,
+  RuleKey,
+  VariableValue,
+  Weight,
+  FeatureKey,
+  Required,
+  VariableKey,
+  VariableSchema,
+  Variation,
+  Force,
+  VariationV1,
+} from "./feature";
+import type { GroupSegment, Segment, SegmentKey } from "./segment";
+
+export type Percentage = number; // 0 to 100,000 (100% * 1000 to include three decimal places in same integer)
+
+export type Range = [Percentage, Percentage]; // 0 to 100k
+
+export interface Allocation {
+  variation: VariationValue;
+  range: Range;
+}
+
+export interface Traffic {
+  key: RuleKey;
+  segments: GroupSegment | GroupSegment[] | "*";
+  percentage: Percentage;
+
+  enabled?: boolean;
+  variation?: VariationValue;
+  variables?: {
+    [key: string]: VariableValue;
+  };
+  variationWeights?: {
+    [key: string]: Weight;
+  };
+
+  allocation?: Allocation[];
+}
+
+export interface Feature {
+  key?: FeatureKey; // needed for supporting v1 datafile generation
+  hash?: string;
+  deprecated?: boolean;
+  required?: Required[];
+  variablesSchema?: Record<VariableKey, VariableSchema>;
+  disabledVariationValue?: VariationValue;
+  variations?: Variation[];
+  bucketBy: BucketBy;
+  traffic: Traffic[];
+  force?: Force[];
+  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
+}
+
+export interface FeatureV1 {
+  key?: FeatureKey;
+  hash?: string;
+  deprecated?: boolean;
+  required?: Required[];
+  bucketBy: BucketBy;
+  traffic: Traffic[];
+  force?: Force[];
+  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
+
+  variablesSchema?: VariableSchema[];
+  variations?: VariationV1[];
+}
+
+export interface DatafileContentV1 {
+  schemaVersion: string;
+  revision: string;
+  attributes: Attribute[];
+  segments: Segment[];
+  features: FeatureV1[];
+}
+
+export interface DatafileContent {
+  schemaVersion: string;
+  revision: string;
+  segments: {
+    [key: SegmentKey]: Segment;
+  };
+  features: {
+    [key: FeatureKey]: Feature;
+  };
+}

package/src/feature.d.ts

@@ -0,0 +1,181 @@
+import type { BucketBy } from "./bucket";
+import type { Condition } from "./condition";
+import type { GroupSegment } from "./segment";
+
+export type VariationValue = string;
+
+export type VariableKey = string;
+export type VariableType =
+  | "boolean"
+  | "string"
+  | "integer"
+  | "double"
+  | "array"
+  | "object"
+  | "json";
+export interface VariableObjectValue {
+  [key: string]: VariableValue;
+}
+export type VariableValue =
+  | boolean
+  | string
+  | number
+  | string[]
+  | VariableObjectValue
+  | null
+  | undefined;
+
+export interface VariableOverrideSegments {
+  segments: GroupSegment | GroupSegment[];
+}
+
+export interface VariableOverrideConditions {
+  conditions: Condition | Condition[];
+}
+
+export type VariableOverrideSegmentsOrConditions =
+  | VariableOverrideSegments
+  | VariableOverrideConditions;
+
+export interface VariableOverride {
+  value: VariableValue;
+
+  // one of the below must be present in YAML files
+  conditions?: Condition | Condition[];
+  segments?: GroupSegment | GroupSegment[];
+}
+
+export interface VariableV1 {
+  key: VariableKey;
+  value: VariableValue;
+  description?: string; // only available in YAML files
+  overrides?: VariableOverride[];
+}
+
+export interface VariationV1 {
+  description?: string; // only available in YAML files
+  value: VariationValue;
+  weight?: Weight; // 0 to 100 (available from parsed YAML, but not in datafile)
+  variables?: VariableV1[];
+}
+
+export interface Variation {
+  description?: string; // only available in YAML files
+  value: VariationValue;
+  weight?: Weight; // 0 to 100 (available from parsed YAML, but not in datafile)
+  variables?: {
+    [key: VariableKey]: VariableValue;
+  };
+  variableOverrides?: {
+    [key: VariableKey]: VariableOverride[];
+  };
+}
+
+export interface VariableSchema {
+  deprecated?: boolean;
+  key?: VariableKey; // @NOTE: remove
+  type: VariableType;
+  defaultValue: VariableValue;
+  description?: string; // only available in YAML files
+  useDefaultWhenDisabled?: boolean;
+  disabledValue?: VariableValue;
+}
+
+export type FeatureKey = string;
+
+export interface RequiredWithVariation {
+  key: FeatureKey;
+  variation: VariationValue;
+}
+
+export type Required = FeatureKey | RequiredWithVariation;
+
+export type Weight = number; // 0 to 100
+
+export type EnvironmentKey = string; // ideally "production", "staging", "testing", or "development" only
+
+export type Tag = string;
+
+export type RuleKey = string;
+
+export interface Rule {
+  key: RuleKey;
+  description?: string; // only available in YAML
+  segments: GroupSegment | GroupSegment[];
+  percentage: Weight;
+
+  enabled?: boolean;
+  variation?: VariationValue;
+  variables?: {
+    [key: string]: VariableValue;
+  };
+  variationWeights?: {
+    [key: string]: Weight;
+  };
+}
+
+export interface RulesByEnvironment {
+  [key: EnvironmentKey]: Rule[];
+}
+
+export interface Force {
+  // one of the below must be present in YAML
+  conditions?: Condition | Condition[];
+  segments?: GroupSegment | GroupSegment[];
+
+  enabled?: boolean;
+  variation?: VariationValue;
+  variables?: {
+    [key: string]: VariableValue;
+  };
+}
+
+export interface ForceByEnvironment {
+  [key: EnvironmentKey]: Force[];
+}
+
+export type Expose = boolean | Tag[];
+
+export interface ExposeByEnvironment {
+  [key: EnvironmentKey]: Expose;
+}
+
+export interface ParsedFeature {
+  key: FeatureKey;
+
+  archived?: boolean;
+  deprecated?: boolean;
+
+  description: string;
+  tags: Tag[];
+
+  required?: Required[];
+
+  bucketBy: BucketBy;
+
+  disabledVariationValue?: VariationValue;
+
+  variablesSchema?: Record<VariableKey, VariableSchema>;
+  variations?: Variation[];
+
+  expose?: ExposeByEnvironment | Expose;
+  force?: ForceByEnvironment | Force[];
+  rules?: RulesByEnvironment | Rule[];
+}
+
+/**
+ * Used by SDK
+ */
+export interface EvaluatedFeature {
+  enabled: boolean;
+  variation?: VariationValue;
+  variables?: {
+    [key: VariableKey]: VariableValue;
+  };
+}
+
+export interface EvaluatedFeatures {
+  [key: FeatureKey]: EvaluatedFeature;
+}
+
+export type StickyFeatures = EvaluatedFeatures;

package/src/group.d.ts

@@ -0,0 +1,12 @@
+import type { FeatureKey, Weight } from "./feature";
+
+export interface Slot {
+  feature: FeatureKey | false;
+  percentage: Weight; // 0 to 100
+}
+
+export interface Group {
+  key: string;
+  description: string;
+  slots: Slot[];
+}

package/src/index.d.ts

@@ -1,621 +1,11 @@
-export type AttributeKey = string;
-
-export interface AttributeObjectValue {
-  [key: AttributeKey]: AttributeValue;
-}
-
-export type AttributeValue =
-  | string
-  | number
-  | boolean
-  | Date
-  | null
-  | undefined
-  | string[]
-  | AttributeObjectValue;
-
-export interface Context {
-  [key: AttributeKey]: AttributeValue;
-}
-
-export type AttributeType =
-  | "boolean"
-  | "string"
-  | "integer"
-  | "double"
-  | "date"
-  | "semver"
-  | "object"
-  | "array";
-
-export interface Attribute {
-  archived?: boolean; // only available in YAML files
-  key?: AttributeKey; // needed for supporting v1 datafile generation
-  type: AttributeType;
-  description?: string; // only available in YAML files
-  properties?: {
-    [key: AttributeKey]: {
-      type:
-        | "boolean"
-        | "string"
-        | "integer"
-        | "double"
-        | "date"
-        | "semver"
-        // | "object" // NOTE: avoid nesting for now
-        | "array";
-      description?: string;
-    };
-  };
-}
-
-export type Operator =
-  | "equals"
-  | "notEquals"
-  | "exists"
-  | "notExists"
-
-  // numeric
-  | "greaterThan"
-  | "greaterThanOrEquals"
-  | "lessThan"
-  | "lessThanOrEquals"
-
-  // string
-  | "contains"
-  | "notContains"
-  | "startsWith"
-  | "endsWith"
-
-  // semver (string)
-  | "semverEquals"
-  | "semverNotEquals"
-  | "semverGreaterThan"
-  | "semverGreaterThanOrEquals"
-  | "semverLessThan"
-  | "semverLessThanOrEquals"
-
-  // date comparisons
-  | "before"
-  | "after"
-
-  // array of strings
-  | "includes"
-  | "notIncludes"
-
-  // regex
-  | "matches"
-  | "notMatches"
-
-  // array of strings
-  | "in"
-  | "notIn";
-
-export type ConditionValue = string | number | boolean | Date | null | undefined | string[];
-
-export interface PlainCondition {
-  attribute: AttributeKey;
-  operator: Operator;
-  value?: ConditionValue; // for all operators, except for "exists" and "notExists"
-  regexFlags?: string; // for regex operators only (matches, notMatches)
-}
-
-export interface AndCondition {
-  and: Condition[];
-}
-
-export interface OrCondition {
-  or: Condition[];
-}
-
-export interface NotCondition {
-  not: Condition[];
-}
-
-export type AndOrNotCondition = AndCondition | OrCondition | NotCondition;
-
-export type Condition = PlainCondition | AndOrNotCondition | string;
-
-export type SegmentKey = string;
-
-export interface Segment {
-  archived?: boolean; // only available in YAML files
-  key?: SegmentKey; // needed for supporting v1 datafile generation
-  conditions: Condition | Condition[]; // string only when stringified for datafile
-  description?: string; // only available in YAML files
-}
-
-export type PlainGroupSegment = SegmentKey;
-
-export interface AndGroupSegment {
-  and: GroupSegment[];
-}
-
-export interface OrGroupSegment {
-  or: GroupSegment[];
-}
-
-export interface NotGroupSegment {
-  not: GroupSegment[];
-}
-
-export type AndOrNotGroupSegment = AndGroupSegment | OrGroupSegment | NotGroupSegment;
-
-// group of segment keys with and/or conditions, or just string
-export type GroupSegment = PlainGroupSegment | AndOrNotGroupSegment;
-
-export type VariationValue = string;
-
-export type VariableKey = string;
-export type VariableType =
-  | "boolean"
-  | "string"
-  | "integer"
-  | "double"
-  | "array"
-  | "object"
-  | "json";
-export interface VariableObjectValue {
-  [key: string]: VariableValue;
-}
-export type VariableValue =
-  | boolean
-  | string
-  | number
-  | string[]
-  | VariableObjectValue
-  | null
-  | undefined;
-
-export interface VariableOverrideSegments {
-  segments: GroupSegment | GroupSegment[];
-}
-
-export interface VariableOverrideConditions {
-  conditions: Condition | Condition[];
-}
-
-export type VariableOverrideSegmentsOrConditions =
-  | VariableOverrideSegments
-  | VariableOverrideConditions;
-
-export interface VariableOverride {
-  value: VariableValue;
-
-  // one of the below must be present in YAML files
-  conditions?: Condition | Condition[];
-  segments?: GroupSegment | GroupSegment[];
-}
-
-export interface VariableV1 {
-  key: VariableKey;
-  value: VariableValue;
-  description?: string; // only available in YAML files
-  overrides?: VariableOverride[];
-}
-
-export interface VariationV1 {
-  description?: string; // only available in YAML files
-  value: VariationValue;
-  weight?: Weight; // 0 to 100 (available from parsed YAML, but not in datafile)
-  variables?: VariableV1[];
-}
-
-export interface Variation {
-  description?: string; // only available in YAML files
-  value: VariationValue;
-  weight?: Weight; // 0 to 100 (available from parsed YAML, but not in datafile)
-  variables?: {
-    [key: VariableKey]: VariableValue;
-  };
-  variableOverrides?: {
-    [key: VariableKey]: VariableOverride[];
-  };
-}
-
-export interface VariableSchema {
-  deprecated?: boolean;
-  key?: VariableKey; // @NOTE: remove
-  type: VariableType;
-  defaultValue: VariableValue;
-  description?: string; // only available in YAML files
-  useDefaultWhenDisabled?: boolean;
-  disabledValue?: VariableValue;
-}
-
-export type FeatureKey = string;
-
-export interface Slot {
-  feature: FeatureKey | false;
-  percentage: Weight; // 0 to 100
-}
-
-export interface Group {
-  key: string;
-  description: string;
-  slots: Slot[];
-}
-
-export type BucketKey = string;
-export type BucketValue = number; // 0 to 100,000 (100% * 1000 to include three decimal places in same integer)
-
-/**
- * Datafile-only types
- */
-export type Percentage = number; // 0 to 100,000 (100% * 1000 to include three decimal places in same integer)
-
-export type Range = [Percentage, Percentage]; // 0 to 100k
-
-export interface Allocation {
-  variation: VariationValue;
-  range: Range;
-}
-
-export interface Traffic {
-  key: RuleKey;
-  segments: GroupSegment | GroupSegment[] | "*";
-  percentage: Percentage;
-
-  enabled?: boolean;
-  variation?: VariationValue;
-  variables?: {
-    [key: string]: VariableValue;
-  };
-  variationWeights?: {
-    [key: string]: Weight;
-  };
-
-  allocation?: Allocation[];
-}
-
-export type PlainBucketBy = AttributeKey;
-export type AndBucketBy = AttributeKey[];
-export interface OrBucketBy {
-  or: AttributeKey[];
-}
-export type BucketBy = PlainBucketBy | AndBucketBy | OrBucketBy;
-
-export interface RequiredWithVariation {
-  key: FeatureKey;
-  variation: VariationValue;
-}
-
-export type Required = FeatureKey | RequiredWithVariation;
-
-export interface Feature {
-  key?: FeatureKey; // needed for supporting v1 datafile generation
-  hash?: string;
-  deprecated?: boolean;
-  required?: Required[];
-  variablesSchema?: Record<VariableKey, VariableSchema>;
-  disabledVariationValue?: VariationValue;
-  variations?: Variation[];
-  bucketBy: BucketBy;
-  traffic: Traffic[];
-  force?: Force[];
-  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
-}
-
-export interface FeatureV1 {
-  key?: FeatureKey;
-  hash?: string;
-  deprecated?: boolean;
-  required?: Required[];
-  bucketBy: BucketBy;
-  traffic: Traffic[];
-  force?: Force[];
-  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
-
-  variablesSchema?: VariableSchema[];
-  variations?: VariationV1[];
-}
-
-export interface DatafileContentV1 {
-  schemaVersion: string;
-  revision: string;
-  attributes: Attribute[];
-  segments: Segment[];
-  features: FeatureV1[];
-}
-
-export interface DatafileContent {
-  schemaVersion: string;
-  revision: string;
-  segments: {
-    [key: SegmentKey]: Segment;
-  };
-  features: {
-    [key: FeatureKey]: Feature;
-  };
-}
-
-export interface EvaluatedFeature {
-  enabled: boolean;
-  variation?: VariationValue;
-  variables?: {
-    [key: VariableKey]: VariableValue;
-  };
-}
-
-export interface EvaluatedFeatures {
-  [key: FeatureKey]: EvaluatedFeature;
-}
-
-export type StickyFeatures = EvaluatedFeatures;
-
-/**
- * YAML-only type
- */
-export type Weight = number; // 0 to 100
-
-export type EnvironmentKey = string; // ideally "production", "staging", "testing", or "development" only
-
-export type Tag = string;
-
-export type RuleKey = string;
-
-export interface Rule {
-  key: RuleKey;
-  description?: string; // only available in YAML
-  segments: GroupSegment | GroupSegment[];
-  percentage: Weight;
-
-  enabled?: boolean;
-  variation?: VariationValue;
-  variables?: {
-    [key: string]: VariableValue;
-  };
-  variationWeights?: {
-    [key: string]: Weight;
-  };
-}
-
-export interface RulesByEnvironment {
-  [key: EnvironmentKey]: Rule[];
-}
-
-export interface Force {
-  // one of the below must be present in YAML
-  conditions?: Condition | Condition[];
-  segments?: GroupSegment | GroupSegment[];
-
-  enabled?: boolean;
-  variation?: VariationValue;
-  variables?: {
-    [key: string]: VariableValue;
-  };
-}
-
-export interface ForceByEnvironment {
-  [key: EnvironmentKey]: Force[];
-}
-
-export type Expose = boolean | Tag[];
-
-export interface ExposeByEnvironment {
-  [key: EnvironmentKey]: Expose;
-}
-
-export interface ParsedFeature {
-  key: FeatureKey;
-
-  archived?: boolean;
-  deprecated?: boolean;
-
-  description: string;
-  tags: Tag[];
-
-  required?: Required[];
-
-  bucketBy: BucketBy;
-
-  disabledVariationValue?: VariationValue;
-
-  variablesSchema?: Record<VariableKey, VariableSchema>;
-  variations?: Variation[];
-
-  expose?: ExposeByEnvironment | Expose;
-  force?: ForceByEnvironment | Force[];
-  rules?: RulesByEnvironment | Rule[];
-}
-
-/**
- * For maintaining old allocations info,
- * allowing for gradual rollout of new allocations
- * with consistent bucketing
- */
-export interface ExistingFeature {
-  hash?: string;
-  variations?: {
-    value: VariationValue;
-    weight: Weight;
-  }[];
-  traffic: {
-    key: RuleKey;
-    percentage: Percentage;
-    allocation?: Allocation[];
-  }[];
-  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
-}
-
-export interface ExistingFeatures {
-  [key: FeatureKey]: ExistingFeature;
-}
-
-export interface ExistingState {
-  features: ExistingFeatures;
-}
-
-/**
- * Tests
- */
-export interface AssertionMatrix {
-  [key: string]: AttributeValue[];
-}
-
-export interface ExpectedEvaluations {
-  flag?: Record<string, any>;
-  variation?: Record<string, any>;
-  variables?: {
-    [key: VariableKey]: Record<string, any>;
-  };
-}
-
-export interface FeatureChildAssertion {
-  sticky?: StickyFeatures;
-  context?: Context;
-
-  defaultVariationValue?: VariationValue;
-  defaultVariableValues?: {
-    [key: string]: VariableValue;
-  };
-
-  expectedToBeEnabled?: boolean;
-  expectedVariation?: VariationValue;
-  expectedVariables?: {
-    [key: VariableKey]: VariableValue;
-  };
-  expectedEvaluations?: ExpectedEvaluations;
-}
-
-export interface FeatureAssertion {
-  matrix?: AssertionMatrix;
-  description?: string;
-  environment: EnvironmentKey;
-  at?: Weight; // bucket weight: 0 to 100
-
-  sticky?: StickyFeatures;
-  context?: Context;
-
-  defaultVariationValue?: VariationValue;
-  defaultVariableValues?: {
-    [key: string]: VariableValue;
-  };
-
-  expectedToBeEnabled?: boolean;
-  expectedVariation?: VariationValue;
-  expectedVariables?: {
-    [key: VariableKey]: VariableValue;
-  };
-  expectedEvaluations?: ExpectedEvaluations;
-
-  children?: FeatureChildAssertion[];
-}
-
-export interface TestFeature {
-  key?: string; // file path
-  feature: FeatureKey;
-  assertions: FeatureAssertion[];
-}
-
-export interface SegmentAssertion {
-  matrix?: AssertionMatrix;
-  description?: string;
-  context: Context;
-  expectedToMatch: boolean;
-}
-
-export interface TestSegment {
-  key?: string; // file path
-  segment: SegmentKey;
-  assertions: SegmentAssertion[];
-}
-
-export type Test = TestSegment | TestFeature;
-
-export interface TestResultAssertionError {
-  type: "flag" | "variation" | "variable" | "segment" | "evaluation";
-  expected: string | number | boolean | Date | null | undefined;
-  actual: string | number | boolean | Date | null | undefined;
-  message?: string;
-  details?: {
-    evaluationType?: string; // e.g., "flag", "variation", "variable"
-    evaluationKey?: string; // e.g., "myFeatureKey", "myVariableKey"
-    childIndex?: number; // for children assertions
-    [key: string]: any;
-  };
-}
-
-export interface TestResultAssertion {
-  description: string;
-  duration: number;
-  passed: boolean;
-  errors?: TestResultAssertionError[];
-}
-
-export interface TestResult {
-  type: "feature" | "segment";
-  key: string;
-  notFound?: boolean;
-  passed: boolean;
-  duration: number;
-  assertions: TestResultAssertion[];
-}
-
-/**
- * Site index and history
- */
-export type EntityType = "attribute" | "segment" | "feature" | "group" | "test";
-
-export type CommitHash = string;
-
-export interface HistoryEntity {
-  type: EntityType;
-  key: string;
-}
-
-export interface HistoryEntry {
-  commit: CommitHash;
-  author: string;
-  timestamp: string;
-  entities: HistoryEntity[];
-}
-
-export interface LastModified {
-  commit: CommitHash;
-  timestamp: string;
-  author: string;
-}
-
-export interface SearchIndex {
-  links?: {
-    feature: string;
-    segment: string;
-    attribute: string;
-    commit: CommitHash;
-  };
-  projectConfig: {
-    tags: Tag[];
-    environments: EnvironmentKey[] | false;
-  };
-  entities: {
-    attributes: (Attribute & {
-      lastModified?: LastModified;
-      usedInSegments: SegmentKey[];
-      usedInFeatures: FeatureKey[];
-    })[];
-    segments: (Segment & {
-      lastModified?: LastModified;
-      usedInFeatures: FeatureKey[];
-    })[];
-    features: (ParsedFeature & {
-      lastModified?: LastModified;
-    })[];
-  };
-}
-
-export interface EntityDiff {
-  type: EntityType;
-  key: string;
-  created?: boolean;
-  deleted?: boolean;
-  updated?: boolean;
-  content?: string;
-}
-
-export interface Commit {
-  hash: CommitHash;
-  author: string;
-  timestamp: string;
-  entities: EntityDiff[];
-}
+export * from "./attribute";
+export * from "./bucket";
+export * from "./condition";
+export * from "./context";
+export * from "./datafile";
+export * from "./feature";
+export * from "./group";
+export * from "./segment";
+export * from "./site";
+export * from "./state";
+export * from "./test";

package/src/segment.d.ts

@@ -0,0 +1,29 @@
+import type { Condition } from "./condition";
+
+export type SegmentKey = string;
+
+export interface Segment {
+  archived?: boolean; // only available in YAML files
+  key?: SegmentKey; // needed for supporting v1 datafile generation
+  conditions: Condition | Condition[]; // string only when stringified for datafile
+  description?: string; // only available in YAML files
+}
+
+export type PlainGroupSegment = SegmentKey;
+
+export interface AndGroupSegment {
+  and: GroupSegment[];
+}
+
+export interface OrGroupSegment {
+  or: GroupSegment[];
+}
+
+export interface NotGroupSegment {
+  not: GroupSegment[];
+}
+
+export type AndOrNotGroupSegment = AndGroupSegment | OrGroupSegment | NotGroupSegment;
+
+// group of segment keys with and/or conditions, or just string
+export type GroupSegment = PlainGroupSegment | AndOrNotGroupSegment;

package/src/site.d.ts

@@ -0,0 +1,68 @@
+import type { Attribute } from "./attribute";
+import type { Segment, SegmentKey } from "./segment";
+import type { Tag, EnvironmentKey, FeatureKey, ParsedFeature } from "./feature";
+
+export type EntityType = "attribute" | "segment" | "feature" | "group" | "test";
+
+export type CommitHash = string;
+
+export interface HistoryEntity {
+  type: EntityType;
+  key: string;
+}
+
+export interface HistoryEntry {
+  commit: CommitHash;
+  author: string;
+  timestamp: string;
+  entities: HistoryEntity[];
+}
+
+export interface LastModified {
+  commit: CommitHash;
+  timestamp: string;
+  author: string;
+}
+
+export interface SearchIndex {
+  links?: {
+    feature: string;
+    segment: string;
+    attribute: string;
+    commit: CommitHash;
+  };
+  projectConfig: {
+    tags: Tag[];
+    environments: EnvironmentKey[] | false;
+  };
+  entities: {
+    attributes: (Attribute & {
+      lastModified?: LastModified;
+      usedInSegments: SegmentKey[];
+      usedInFeatures: FeatureKey[];
+    })[];
+    segments: (Segment & {
+      lastModified?: LastModified;
+      usedInFeatures: FeatureKey[];
+    })[];
+    features: (ParsedFeature & {
+      lastModified?: LastModified;
+    })[];
+  };
+}
+
+export interface EntityDiff {
+  type: EntityType;
+  key: string;
+  created?: boolean;
+  deleted?: boolean;
+  updated?: boolean;
+  content?: string;
+}
+
+export interface Commit {
+  hash: CommitHash;
+  author: string;
+  timestamp: string;
+  entities: EntityDiff[];
+}

package/src/state.d.ts

@@ -0,0 +1,24 @@
+import type { FeatureKey, RuleKey, VariationValue, Weight } from "./feature";
+import type { Percentage, Allocation, Range } from "./datafile";
+
+export interface ExistingFeature {
+  hash?: string;
+  variations?: {
+    value: VariationValue;
+    weight: Weight;
+  }[];
+  traffic: {
+    key: RuleKey;
+    percentage: Percentage;
+    allocation?: Allocation[];
+  }[];
+  ranges?: Range[]; // if in a Group (mutex), these are the available slot ranges
+}
+
+export interface ExistingFeatures {
+  [key: FeatureKey]: ExistingFeature;
+}
+
+export interface ExistingState {
+  features: ExistingFeatures;
+}

package/src/test.d.ts

@@ -0,0 +1,118 @@
+import type { AttributeValue } from "./attribute";
+import type { Context } from "./context";
+import type {
+  VariableKey,
+  FeatureKey,
+  VariationValue,
+  StickyFeatures,
+  VariableValue,
+  EnvironmentKey,
+  Weight,
+} from "./feature";
+import type { SegmentKey } from "./segment";
+
+export interface AssertionMatrix {
+  [key: string]: AttributeValue[];
+}
+
+export interface ExpectedEvaluations {
+  flag?: Record<string, any>;
+  variation?: Record<string, any>;
+  variables?: {
+    [key: VariableKey]: Record<string, any>;
+  };
+}
+
+export interface FeatureChildAssertion {
+  sticky?: StickyFeatures;
+  context?: Context;
+
+  defaultVariationValue?: VariationValue;
+  defaultVariableValues?: {
+    [key: string]: VariableValue;
+  };
+
+  expectedToBeEnabled?: boolean;
+  expectedVariation?: VariationValue;
+  expectedVariables?: {
+    [key: VariableKey]: VariableValue;
+  };
+  expectedEvaluations?: ExpectedEvaluations;
+}
+
+export interface FeatureAssertion {
+  matrix?: AssertionMatrix;
+  description?: string;
+  environment: EnvironmentKey;
+  at?: Weight; // bucket weight: 0 to 100
+
+  sticky?: StickyFeatures;
+  context?: Context;
+
+  defaultVariationValue?: VariationValue;
+  defaultVariableValues?: {
+    [key: string]: VariableValue;
+  };
+
+  expectedToBeEnabled?: boolean;
+  expectedVariation?: VariationValue;
+  expectedVariables?: {
+    [key: VariableKey]: VariableValue;
+  };
+  expectedEvaluations?: ExpectedEvaluations;
+
+  children?: FeatureChildAssertion[];
+}
+
+export interface TestFeature {
+  key?: string; // file path
+  feature: FeatureKey;
+  assertions: FeatureAssertion[];
+}
+
+export interface SegmentAssertion {
+  matrix?: AssertionMatrix;
+  description?: string;
+  context: Context;
+  expectedToMatch: boolean;
+}
+
+export interface TestSegment {
+  key?: string; // file path
+  segment: SegmentKey;
+  assertions: SegmentAssertion[];
+}
+
+export type Test = TestSegment | TestFeature;
+
+/**
+ * Used by test runner
+ */
+export interface TestResultAssertionError {
+  type: "flag" | "variation" | "variable" | "segment" | "evaluation";
+  expected: string | number | boolean | Date | null | undefined;
+  actual: string | number | boolean | Date | null | undefined;
+  message?: string;
+  details?: {
+    evaluationType?: string; // e.g., "flag", "variation", "variable"
+    evaluationKey?: string; // e.g., "myFeatureKey", "myVariableKey"
+    childIndex?: number; // for children assertions
+    [key: string]: any;
+  };
+}
+
+export interface TestResultAssertion {
+  description: string;
+  duration: number;
+  passed: boolean;
+  errors?: TestResultAssertionError[];
+}
+
+export interface TestResult {
+  type: "feature" | "segment";
+  key: string;
+  notFound?: boolean;
+  passed: boolean;
+  duration: number;
+  assertions: TestResultAssertion[];
+}

package/{tsconfig.esm.json → tsconfig.json}

@@ -3,5 +3,5 @@
   "compilerOptions": {
     "outDir": "./lib"
   },
-  "include": ["./src/**/*.ts"]
+  "include": ["./src/**/*.ts", "./src/**/*.d.ts"]
 }

package/tsconfig.cjs.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.cjs.json",
-  "compilerOptions": {
-    "outDir": "./lib"
-  },
-  "include": ["./src/**/*.ts"]
-}