@contentchef/contentchef-types 11.0.0-alpha.4 → 11.0.0-alpha.5

package/dist/api/{Segment.d.ts → Audience.d.ts}

@@ -2,21 +2,21 @@ import { AuthorResponse } from './Author';
 import { PagedListResponse } from './common';
 import { ContentDefinitionId } from './ContentDefinition';
 /**
- * The segment unique id
+ * The audience unique id
  */
-export type SegmentId = number;
+export type AudienceId = number;
 /**
- * A segment's mnemonicId and every one of its keys must match this pattern: lowercase, digits,
+ * An audience's mnemonicId and every one of its keys must match this pattern: lowercase, digits,
  * underscore and hyphen. Stricter than the other authoring mnemonicIds on purpose, because both halves
- * travel in the delivery `segments` query param and are compared against strings a client supplies
+ * travel in the delivery `audiences` query param and are compared against strings a client supplies
  */
-export declare const SEGMENT_NAME_PATTERN: RegExp;
+export declare const AUDIENCE_NAME_PATTERN: RegExp;
 /**
- * This type represent one key of a segment, that is one of the values a visitor can have for it
+ * This type represent one key of an audience, that is one of the values a visitor can have for it
  */
-export type SegmentKey = {
+export type AudienceKey = {
     /**
-     * The key, matching [[SEGMENT_NAME_PATTERN]]
+     * The key, matching [[AUDIENCE_NAME_PATTERN]]
      */
     key: string;
     /**
@@ -26,97 +26,97 @@ export type SegmentKey = {
     deprecated?: boolean;
 };
 /**
- * This type represent the model of a segment, that is a dimension a content can vary by - `gender`,
+ * This type represent the model of an audience, that is a dimension a content can vary by - `gender`,
  * `loyalty`, `auth_status` - holding the fixed set of keys a visitor can have for it
  *
- * Contents reference a segment by mnemonicId and key inside their rules, and definitions by
- * mnemonicId, so segments are archived and never deleted, and a key can only be removed or renamed
+ * Contents reference an audience by mnemonicId and key inside their rules, and definitions by
+ * mnemonicId, so audiences are archived and never deleted, and a key can only be removed or renamed
  * while no content references it
  */
-export type SegmentResponse = {
+export type AudienceResponse = {
     /**
-     * The segment unique id
+     * The audience unique id
      */
-    id: SegmentId;
+    id: AudienceId;
     /**
-     * The segment name
+     * The audience name
      */
     name: string;
     /**
-     * The segment mnemonic id, matching [[SEGMENT_NAME_PATTERN]]
+     * The audience mnemonic id, matching [[AUDIENCE_NAME_PATTERN]]
      */
     mnemonicId: string;
     /**
-     * The keys a visitor can hold for this segment, each carrying its own deprecation state
+     * The keys a visitor can hold for this audience, each carrying its own deprecation state
      */
-    keys: SegmentKey[];
+    keys: AudienceKey[];
     /**
-     * The archived status of the segment
+     * The archived status of the audience
      */
     archived: boolean;
     /**
-     * The archive date of the segment
+     * The archive date of the audience
      */
     archivedDate: Date | null;
     /**
-     * The segment creation date
+     * The audience creation date
      */
     createdDate: Date;
     /**
-     * The segment last modified date
+     * The audience last modified date
      */
     lastModifiedDate: Date;
     /**
-     * The segment author, resolved by `list` only
+     * The audience author, resolved by `list` only
      */
     author?: AuthorResponse;
     /**
-     * The segment last modified author, resolved by every endpoint but `get`
+     * The audience last modified author, resolved by every endpoint but `get`
      */
     latestContributor?: AuthorResponse;
 };
 /**
- * This type represent all possible filters used to retrieve a list of segment
+ * This type represent all possible filters used to retrieve a list of audience
  */
-export type ListSegmentsFilters = {
+export type ListAudiencesFilters = {
     /**
-     * This filter is used to retrieve archived or not archived segments. Defaults to not archived
+     * This filter is used to retrieve archived or not archived audiences. Defaults to not archived
      */
     archived?: boolean;
 };
 /**
- * This type represent the data needed to make a list segments API request
+ * This type represent the data needed to make a list audiences API request
  */
-export type ListSegmentsRequest = {
+export type ListAudiencesRequest = {
     /**
-     * The number of segments to skip (this value is used for pagination)
+     * The number of audiences to skip (this value is used for pagination)
      */
     skip?: number;
     /**
-     * The number of segments to take (this value is used for pagination), at most 100
+     * The number of audiences to take (this value is used for pagination), at most 100
      */
     take?: number;
     /**
-     * The data used to filter the list of segments
+     * The data used to filter the list of audiences
      */
-    filters?: ListSegmentsFilters;
+    filters?: ListAudiencesFilters;
 };
 /**
- * This type represent the item of a list segments API request
+ * This type represent the item of a list audiences API request
  */
-export type ListSegmentsItem = SegmentResponse;
+export type ListAudiencesItem = AudienceResponse;
 /**
- * This type represent the response of a list segments API request
+ * This type represent the response of a list audiences API request
  */
-export type ListSegmentsResponse = PagedListResponse<ListSegmentsItem>;
+export type ListAudiencesResponse = PagedListResponse<ListAudiencesItem>;
 /**
- * This type represent the usage of one key of a segment. A key with no entry is used by no content,
+ * This type represent the usage of one key of an audience. A key with no entry is used by no content,
  * and is therefore the only kind of key that can be removed or renamed
  */
-export type SegmentKeyUsage = {
+export type AudienceKeyUsage = {
     /**
-     * The key, or null for the rules that constrain the segment without naming any key - that is the
-     * ones that only fire when the segment is unknown
+     * The key, or null for the rules that constrain the audience without naming any key - that is the
+     * ones that only fire when the audience is unknown
      */
     key: string | null;
     /**
@@ -125,9 +125,9 @@ export type SegmentKeyUsage = {
     contents: number;
 };
 /**
- * This type represent a content definition that declares a segment
+ * This type represent a content definition that declares an audience
  */
-export type DefinitionUsingSegment = {
+export type DefinitionUsingAudience = {
     /**
      * The content definition unique id
      */
@@ -142,113 +142,113 @@ export type DefinitionUsingSegment = {
     name: string;
 };
 /**
- * This type represent the data needed to make a get segment API request
+ * This type represent the data needed to make a get audience API request
  */
-export type GetSegmentRequest = {
+export type GetAudienceRequest = {
     /**
-     * The unique segment id to retrieve
+     * The unique audience id to retrieve
      */
-    id: SegmentId;
+    id: AudienceId;
 };
 /**
- * This type represent the response of a get segment API request: the segment, plus the two things the
- * editor cannot decide without, which keys are in use and which definitions vary by this segment
+ * This type represent the response of a get audience API request: the audience, plus the two things the
+ * editor cannot decide without, which keys are in use and which definitions vary by this audience
  */
-export type GetSegmentResponse = SegmentResponse & {
+export type GetAudienceResponse = AudienceResponse & {
     /**
      * One entry per key at least one content references. A key absent from this list is unused
      */
-    keyUsage: SegmentKeyUsage[];
+    keyUsage: AudienceKeyUsage[];
     /**
-     * The content definitions declaring this segment
+     * The content definitions declaring this audience
      */
-    definitions: DefinitionUsingSegment[];
+    definitions: DefinitionUsingAudience[];
 };
 /**
- * This type represent the data needed to make a create segment API request
+ * This type represent the data needed to make a create audience API request
  */
-export type CreateSegmentRequest = {
+export type CreateAudienceRequest = {
     /**
-     * The segment name
+     * The audience name
      */
     name: string;
     /**
-     * The segment mnemonic id, matching [[SEGMENT_NAME_PATTERN]]
+     * The audience mnemonic id, matching [[AUDIENCE_NAME_PATTERN]]
      */
     mnemonicId: string;
     /**
-     * The keys a visitor can hold for this segment, at least one, each key unique
+     * The keys a visitor can hold for this audience, at least one, each key unique
      */
-    keys: SegmentKey[];
+    keys: AudienceKey[];
 };
 /**
- * This type represent the response of a create segment API request
+ * This type represent the response of a create audience API request
  */
-export type CreateSegmentResponse = SegmentResponse;
+export type CreateAudienceResponse = AudienceResponse;
 /**
- * This type represent the data needed to make an update segment API request
+ * This type represent the data needed to make an update audience API request
  *
  * `keys` replaces the whole stored list, deprecation flags included. Adding keys and toggling
  * deprecation are always allowed, while removing or renaming a key is refused while a content still
  * references it. `mnemonicId` cannot be changed
  */
-export type UpdateSegmentRequest = {
+export type UpdateAudienceRequest = {
     /**
-     * The segment unique id
+     * The audience unique id
      */
-    id: SegmentId;
+    id: AudienceId;
     /**
-     * The segment name to update
+     * The audience name to update
      */
     name: string;
     /**
-     * The segment mnemonic id, which must be the stored one
+     * The audience mnemonic id, which must be the stored one
      */
     mnemonicId: string;
     /**
      * The whole key list, replacing what is stored
      */
-    keys: SegmentKey[];
+    keys: AudienceKey[];
 };
 /**
- * This type represent the response of an update segment API request
+ * This type represent the response of an update audience API request
  */
-export type UpdateSegmentResponse = SegmentResponse;
+export type UpdateAudienceResponse = AudienceResponse;
 /**
- * This type represent the data needed to make a toggle archived segment API request
+ * This type represent the data needed to make a toggle archived audience API request
  */
-export type ToggleArchivedSegmentRequest = {
+export type ToggleArchivedAudienceRequest = {
     /**
-     * The segment unique id
+     * The audience unique id
      */
-    id: SegmentId;
+    id: AudienceId;
     /**
-     * This value represent the archive status to set in the specified segment
+     * This value represent the archive status to set in the specified audience
      */
     archived: boolean;
 };
 /**
- * This type represent the response of a toggle archived segment API request
+ * This type represent the response of a toggle archived audience API request
  */
-export type ToggleArchivedSegmentResponse = SegmentResponse;
+export type ToggleArchivedAudienceResponse = AudienceResponse;
 /**
- * This type represent the condition of one rule on a single segment: the visitor's value for
- * [[segment]] has to be one of [[in]]
+ * This type represent the condition of one rule on a single audience: the visitor's value for
+ * [[audience]] has to be one of [[in]]
  */
-export type SegmentPredicate = {
+export type AudiencePredicate = {
     /**
-     * The mnemonic id of the segment this predicate constrains, which the field must declare
+     * The mnemonic id of the audience this predicate constrains, which the field must declare
      */
-    segment: string;
+    audience: string;
     /**
-     * The keys of the segment that satisfy this predicate
+     * The keys of the audience that satisfy this predicate
      */
     in: string[];
     /**
-     * Set this value to also satisfy the predicate when the segment was not provided at all
+     * Set this value to also satisfy the predicate when the audience was not provided at all
      *
      * Not-provided is not a key, so no list of keys can express it, and an enumeration would silently
-     * narrow the moment a key is added to the segment. A key that was provided but is not listed does
+     * narrow the moment a key is added to the audience. A key that was provided but is not listed does
      * not satisfy this flag: it falls through to the field's fallback
      */
     orUnset?: boolean;
@@ -256,29 +256,29 @@ export type SegmentPredicate = {
 /**
  * This type represent a condition satisfied when every child condition is satisfied
  */
-export type AllSegmentPredicate = {
-    all: SegmentRuleCondition[];
+export type AllAudiencePredicate = {
+    all: AudienceRuleCondition[];
 };
 /**
  * This type represent a condition satisfied when at least one child condition is satisfied
  */
-export type AnySegmentPredicate = {
-    any: SegmentRuleCondition[];
+export type AnyAudiencePredicate = {
+    any: AudienceRuleCondition[];
 };
 /**
  * This type represent the condition of a rule
  *
  * The stored form is a tree so that new kinds of condition stay additive, but an editor only needs to
- * build an [[AllSegmentPredicate]] of one [[SegmentPredicate]] per segment: or within a segment, and
- * between segments. A segment the condition does not mention is unconstrained, which is a different
- * thing from one listed with [[SegmentPredicate.orUnset]]
+ * build an [[AllAudiencePredicate]] of one [[AudiencePredicate]] per audience: or within an audience, and
+ * between audiences. An audience the condition does not mention is unconstrained, which is a different
+ * thing from one listed with [[AudiencePredicate.orUnset]]
  */
-export type SegmentRuleCondition = SegmentPredicate | AllSegmentPredicate | AnySegmentPredicate;
+export type AudienceRuleCondition = AudiencePredicate | AllAudiencePredicate | AnyAudiencePredicate;
 /**
- * This type represent one rule of a segmented field: the condition, and the value to serve when it wins
+ * This type represent one rule of a personalized field: the condition, and the value to serve when it wins
  * @template T The type of the value served by the rule, which conforms to the field's `variantType`
  */
-export type SegmentRule<T = any> = {
+export type PersonalizedRule<T = any> = {
     /**
      * The rule id, unique in the field. Used for diagnostics only, matching never reads it
      */
@@ -286,42 +286,42 @@ export type SegmentRule<T = any> = {
     /**
      * The condition under which this rule wins
      */
-    when: SegmentRuleCondition;
+    when: AudienceRuleCondition;
     /**
      * The value served when this rule wins
      */
     value: T;
 };
 /**
- * This type represent the value a segmented field holds in a content payload: an ordered list of
+ * This type represent the value a personalized field holds in a content payload: an ordered list of
  * rules, first match wins, and the fallback served when no rule matches
  *
  * The fallback is mandatory exactly when the field is required, which keeps the delivery contract of a
- * segmented field the same as any other field. Zero rules is legal: the field is then just its fallback
+ * personalized field the same as any other field. Zero rules is legal: the field is then just its fallback
  * @template T The type of the served values, which conform to the field's `variantType`
  */
-export type SegmentedFieldPayload<T = any> = {
+export type PersonalizedFieldPayload<T = any> = {
     /**
      * The rules, in the order they are evaluated in
      */
-    rules?: SegmentRule<T>[];
+    rules?: PersonalizedRule<T>[];
     /**
      * The value served when no rule matches
      */
     fallback?: T;
 };
 /**
- * This type represent the visitor's value per segment, as the rule engine reads it. A segment missing
+ * This type represent the visitor's value per audience, as the rule engine reads it. An audience missing
  * from the map, or set to `undefined`, means "not provided" - which is what
- * [[SegmentPredicate.orUnset]] answers
+ * [[AudiencePredicate.orUnset]] answers
  */
-export type SegmentAssignment = {
-    [segmentMnemonicId: string]: string | undefined;
+export type AudienceAssignment = {
+    [audienceMnemonicId: string]: string | undefined;
 };
 /**
  * The stand-in a coverage report uses for "a key none of the rules mention"
  *
- * Not a real key - it cannot be one, since keys match [[SEGMENT_NAME_PATTERN]]. A rule only ever tests
+ * Not a real key - it cannot be one, since keys match [[AUDIENCE_NAME_PATTERN]]. A rule only ever tests
  * membership in its own list, so every unmentioned key behaves identically and one case covers them
  * all, which is what keeps the analysis exact and small. [[CoverageReport.otherKeys]] says which real
  * keys it stood for
@@ -349,7 +349,7 @@ export type RuleCoverage = {
     wins: number;
 };
 /**
- * This type represent what an ordered rule list covers, worked out from the rules and the segments'
+ * This type represent what an ordered rule list covers, worked out from the rules and the audiences'
  * keys alone - no request traffic is involved
  *
  * The findings are advisory and never validation violations: a gap is usually deliberate, that being
@@ -372,28 +372,28 @@ export type CoverageReport = {
      * The assignments no rule claims, so they reach the fallback. Capped at 25 entries, while
      * [[fallbackCount]] is the real total
      */
-    fallbackAssignments: SegmentAssignment[];
+    fallbackAssignments: AudienceAssignment[];
     /**
      * How many assignments reach the fallback, of [[combinations]]
      */
     fallbackCount: number;
     /**
-     * The segments declared by the field but constrained by no rule, so they change nothing about what
+     * The audiences declared by the field but constrained by no rule, so they change nothing about what
      * it serves
      */
-    unusedSegments: string[];
+    unusedAudiences: string[];
     /**
-     * What [[OTHER_KEY]] stood for, per segment: the real unmentioned keys, capped at 10, with their
-     * total. Only the segments that needed the stand-in appear
+     * What [[OTHER_KEY]] stood for, per audience: the real unmentioned keys, capped at 10, with their
+     * total. Only the audiences that needed the stand-in appear
      */
     otherKeys: {
-        [segment: string]: {
+        [audience: string]: {
             keys: string[];
             total: number;
         };
     };
     /**
-     * Set when the rules and their segments were too large to enumerate. Everything else is then
+     * Set when the rules and their audiences were too large to enumerate. Everything else is then
      * unpopulated rather than guessed, because a sampled "no gaps" is not a fact
      */
     notAnalysed?: {
@@ -407,7 +407,7 @@ export type CoverageReport = {
  * request - and a half written rule with no condition is analysed as one that matches nothing rather
  * than refused
  */
-export type SegmentRuleDraft = {
+export type PersonalizedRuleDraft = {
     /**
      * The rule id, when it carries one. Reported back on the finding, so a client can match a finding
      * to the rule on screen without relying on the index
@@ -416,28 +416,28 @@ export type SegmentRuleDraft = {
     /**
      * The condition under which this rule wins
      */
-    when?: SegmentRuleCondition;
+    when?: AudienceRuleCondition;
 };
 /**
  * This type represent the data needed to make an analyse rules API request, which is what a field's
  * rule editor asks about the rules on screen, before anything is saved
  *
- * The keys of every segment are read from the space rather than taken from the request, so a client
+ * The keys of every audience are read from the space rather than taken from the request, so a client
  * never has to hold them or keep them current
  */
-export type AnalyseSegmentRulesRequest = {
+export type AnalyseAudienceRulesRequest = {
     /**
-     * The mnemonic ids of the segments the field varies by, at most 20. The analysis is bounded by
+     * The mnemonic ids of the audiences the field varies by, at most 20. The analysis is bounded by
      * these, as the field's rules are
      */
-    segments: string[];
+    audiences: string[];
     /**
      * The rules in author order, at most 200. The order is the whole point: first match wins, so a rule
      * being unreachable is a consequence of what precedes it
      */
-    rules: SegmentRuleDraft[];
+    rules: PersonalizedRuleDraft[];
 };
 /**
  * This type represent the response of an analyse rules API request
  */
-export type AnalyseSegmentRulesResponse = CoverageReport;
+export type AnalyseAudienceRulesResponse = CoverageReport;

package/dist/api/{Segment.js → Audience.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OTHER_KEY = exports.SEGMENT_NAME_PATTERN = void 0;
+exports.OTHER_KEY = exports.AUDIENCE_NAME_PATTERN = void 0;
 /**
- * A segment's mnemonicId and every one of its keys must match this pattern: lowercase, digits,
+ * An audience's mnemonicId and every one of its keys must match this pattern: lowercase, digits,
  * underscore and hyphen. Stricter than the other authoring mnemonicIds on purpose, because both halves
- * travel in the delivery `segments` query param and are compared against strings a client supplies
+ * travel in the delivery `audiences` query param and are compared against strings a client supplies
  */
-exports.SEGMENT_NAME_PATTERN = /^[a-z0-9_-]+$/;
+exports.AUDIENCE_NAME_PATTERN = /^[a-z0-9_-]+$/;
 /**
  * The stand-in a coverage report uses for "a key none of the rules mention"
  *
- * Not a real key - it cannot be one, since keys match [[SEGMENT_NAME_PATTERN]]. A rule only ever tests
+ * Not a real key - it cannot be one, since keys match [[AUDIENCE_NAME_PATTERN]]. A rule only ever tests
  * membership in its own list, so every unmentioned key behaves identically and one case covers them
  * all, which is what keeps the analysis exact and small. [[CoverageReport.otherKeys]] says which real
  * keys it stood for

package/dist/api/Content.d.ts

@@ -5,7 +5,7 @@ import { ContentDefinitionId, ContentDefinitionResponse } from "./ContentDefinit
 import { SchemaTypeIds } from "./ContentDefinitionSchema";
 import { ContentRepositoryId, ContentRepositoryResponse } from "./ContentRepository";
 import { ContentTranslation, ContentTranslationStatus } from "./ContentTranslation";
-import { CoverageReport } from "./Segment";
+import { CoverageReport } from "./Audience";
 /**
  * This type represent the content unique id type
  */
@@ -369,11 +369,11 @@ export type ListContentsFilters = {
      */
     translationStatus?: ContentTranslationStatus;
     /**
-     * This filter is used to search contents whose segmented fields have rules referencing the segments
-     * inserted, as `segment` or `segment:key` tokens. A bare `segment` matches whichever key a content
+     * This filter is used to search contents whose personalized fields have rules referencing the audiences
+     * inserted, as `audience` or `audience:key` tokens. A bare `audience` matches whichever key a content
      * uses it with, and several tokens narrow the result like `tags` do
      */
-    segments?: string[];
+    audiences?: string[];
 };
 /**
  * This type represent the data needed to make a list content API request
@@ -777,17 +777,17 @@ export declare enum ContentFieldViolationCodes {
     textFieldValueMissingInListOfValue = "textField.valueMissingInListOfValue",
     textFieldValueIsNotAString = "textField.valueIsNotAString",
     textFieldBlankValueNotAllowed = "textField.blankValueNotAllowed",
-    segmentedFieldValueIsNotSegmented = "segmentedField.valueIsNotSegmented",
-    segmentedFieldRulesIsNotAnArray = "segmentedField.rulesIsNotAnArray",
-    segmentedFieldRuleIsNotAnObject = "segmentedField.ruleIsNotAnObject",
-    segmentedFieldRuleConditionMissing = "segmentedField.ruleConditionMissing",
-    segmentedFieldDuplicateRuleId = "segmentedField.duplicateRuleId",
-    segmentedFieldSegmentNotDeclared = "segmentedField.segmentNotDeclared",
-    segmentedFieldFallbackRequired = "segmentedField.fallbackRequired",
-    segmentedFieldSegmentNotFound = "segmentedField.segmentNotFound",
-    segmentedFieldSegmentArchived = "segmentedField.segmentArchived",
-    segmentedFieldSegmentKeyNotFound = "segmentedField.segmentKeyNotFound",
-    segmentedFieldSegmentKeyDeprecated = "segmentedField.segmentKeyDeprecated"
+    personalizedFieldValueIsNotPersonalized = "personalizedField.valueIsNotPersonalized",
+    personalizedFieldRulesIsNotAnArray = "personalizedField.rulesIsNotAnArray",
+    personalizedFieldRuleIsNotAnObject = "personalizedField.ruleIsNotAnObject",
+    personalizedFieldRuleConditionMissing = "personalizedField.ruleConditionMissing",
+    personalizedFieldDuplicateRuleId = "personalizedField.duplicateRuleId",
+    personalizedFieldAudienceNotDeclared = "personalizedField.audienceNotDeclared",
+    personalizedFieldFallbackRequired = "personalizedField.fallbackRequired",
+    personalizedFieldAudienceNotFound = "personalizedField.audienceNotFound",
+    personalizedFieldAudienceArchived = "personalizedField.audienceArchived",
+    personalizedFieldAudienceKeyNotFound = "personalizedField.audienceKeyNotFound",
+    personalizedFieldAudienceKeyDeprecated = "personalizedField.audienceKeyDeprecated"
 }
 /**
  * Request type for getContentStatus
@@ -826,18 +826,18 @@ export type ToggleContentTranslationsRequest = {
 };
 export type ToggleContentTranslationsResponse = ContentResponse;
 /**
- * This type represent the data needed to make an analyse segmented rules API request
+ * This type represent the data needed to make an analyse personalized rules API request
  */
-export type AnalyseSegmentedRulesRequest = {
+export type AnalysePersonalizedRulesRequest = {
     /**
-     * Id of the content whose segmented fields have to be analysed
+     * Id of the content whose personalized fields have to be analysed
      */
     contentId: ContentId;
 };
 /**
- * This type represent the coverage of one segmented field of a content
+ * This type represent the coverage of one personalized field of a content
  */
-export type SegmentedFieldCoverage = CoverageReport & {
+export type PersonalizedFieldCoverage = CoverageReport & {
     /**
      * Where the field sits in the payload
      */
@@ -849,12 +849,12 @@ export type SegmentedFieldCoverage = CoverageReport & {
     hasFallback: boolean;
 };
 /**
- * This type represent the response of an analyse segmented rules API request: one report per
- * segmented field of the content, empty when it has none
+ * This type represent the response of an analyse personalized rules API request: one report per
+ * personalized field of the content, empty when it has none
  */
-export type AnalyseSegmentedRulesResponse = {
+export type AnalysePersonalizedRulesResponse = {
     /**
-     * One entry per segmented field found in the content payload
+     * One entry per personalized field found in the content payload
      */
-    fields: SegmentedFieldCoverage[];
+    fields: PersonalizedFieldCoverage[];
 };