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

package/dist/api/Content.js

@@ -87,16 +87,13 @@ var ContentFieldViolationCodes;
     ContentFieldViolationCodes["textFieldValueIsNotAString"] = "textField.valueIsNotAString";
     ContentFieldViolationCodes["textFieldBlankValueNotAllowed"] = "textField.blankValueNotAllowed";
     ContentFieldViolationCodes["personalizedFieldValueIsNotPersonalized"] = "personalizedField.valueIsNotPersonalized";
-    ContentFieldViolationCodes["personalizedFieldRulesIsNotAnArray"] = "personalizedField.rulesIsNotAnArray";
-    ContentFieldViolationCodes["personalizedFieldRuleIsNotAnObject"] = "personalizedField.ruleIsNotAnObject";
-    ContentFieldViolationCodes["personalizedFieldRuleConditionMissing"] = "personalizedField.ruleConditionMissing";
-    ContentFieldViolationCodes["personalizedFieldDuplicateRuleId"] = "personalizedField.duplicateRuleId";
-    ContentFieldViolationCodes["personalizedFieldAudienceNotDeclared"] = "personalizedField.audienceNotDeclared";
-    ContentFieldViolationCodes["personalizedFieldFallbackRequired"] = "personalizedField.fallbackRequired";
+    ContentFieldViolationCodes["personalizedFieldVariantsIsNotAnArray"] = "personalizedField.variantsIsNotAnArray";
+    ContentFieldViolationCodes["personalizedFieldVariantIsNotAnObject"] = "personalizedField.variantIsNotAnObject";
+    ContentFieldViolationCodes["personalizedFieldAudienceMissing"] = "personalizedField.audienceMissing";
     ContentFieldViolationCodes["personalizedFieldAudienceNotFound"] = "personalizedField.audienceNotFound";
     ContentFieldViolationCodes["personalizedFieldAudienceArchived"] = "personalizedField.audienceArchived";
-    ContentFieldViolationCodes["personalizedFieldAudienceKeyNotFound"] = "personalizedField.audienceKeyNotFound";
-    ContentFieldViolationCodes["personalizedFieldAudienceKeyDeprecated"] = "personalizedField.audienceKeyDeprecated";
+    ContentFieldViolationCodes["personalizedFieldDuplicateAudience"] = "personalizedField.duplicateAudience";
+    ContentFieldViolationCodes["personalizedFieldFallbackRequired"] = "personalizedField.fallbackRequired";
 })(ContentFieldViolationCodes || (exports.ContentFieldViolationCodes = ContentFieldViolationCodes = {}));
 var LocalizationSettings;
 (function (LocalizationSettings) {

package/dist/api/ContentDefinition.d.ts

@@ -175,11 +175,6 @@ export type ContentDefinitionResponse = {
      * Valued with paths to each array or null if definition is legacy
      */
     trackableArrayFields?: ArrayField[] | null;
-    /**
-     * The mnemonic ids of the audiences this definition's personalized fields vary by
-     * Derived from the schema on every save, never assigned by the client
-     */
-    audiences?: string[];
 };
 /**
  * This type represent the response of a create content definition API request
@@ -266,15 +261,6 @@ export type ContentDefinitionSchemaErrors = {
      * This attribute represents an error if the language of the schema is not a valid string
      */
     lang?: string;
-    /**
-     * This attribute represents all the error that occurs inside the audiences declaration of the
-     * definition schema object
-     *
-     * - The value is a string if the audiences value is not in the expected format
-     * - The value is a list of AttributeViolation, one per declared audience that does not exist in the
-     *   space or is archived
-     */
-    audiences?: string | AttributeViolation[];
 };
 /**
  * This type represent the model for the schema fragment errors
@@ -403,9 +389,5 @@ export declare enum SchemaFieldViolationCodes {
     translatableNotAllowed = "translatableNotAllowed",
     invalidEnumValue = "invalidEnumValue",
     compactCannotBeNested = "compactCannotBeNested",
-    audienceTypeNotAllowed = "audienceTypeNotAllowed",
-    audienceNameNotFound = "audienceNameNotFound",
-    audienceArchived = "audienceArchived",
-    audienceNotDeclaredByDefinition = "audienceNotDeclaredByDefinition",
-    duplicateAudienceName = "duplicateAudienceName"
+    variantTypeNotAllowed = "variantTypeNotAllowed"
 }

package/dist/api/ContentDefinition.js

@@ -45,9 +45,5 @@ var SchemaFieldViolationCodes;
     SchemaFieldViolationCodes["translatableNotAllowed"] = "translatableNotAllowed";
     SchemaFieldViolationCodes["invalidEnumValue"] = "invalidEnumValue";
     SchemaFieldViolationCodes["compactCannotBeNested"] = "compactCannotBeNested";
-    SchemaFieldViolationCodes["audienceTypeNotAllowed"] = "audienceTypeNotAllowed";
-    SchemaFieldViolationCodes["audienceNameNotFound"] = "audienceNameNotFound";
-    SchemaFieldViolationCodes["audienceArchived"] = "audienceArchived";
-    SchemaFieldViolationCodes["audienceNotDeclaredByDefinition"] = "audienceNotDeclaredByDefinition";
-    SchemaFieldViolationCodes["duplicateAudienceName"] = "duplicateAudienceName";
+    SchemaFieldViolationCodes["variantTypeNotAllowed"] = "variantTypeNotAllowed";
 })(SchemaFieldViolationCodes || (exports.SchemaFieldViolationCodes = SchemaFieldViolationCodes = {}));

package/dist/api/ContentDefinitionSchema.d.ts

@@ -48,14 +48,6 @@ export type ContentDefinitionSchema = {
      * A Fragment is a custom field defined by the user and can be used internally in the definition
      */
     fragments: FragmentsTable;
-    /**
-     * The audiences this definition depends on, chosen by the author. Every one has to exist in the
-     * space and not be archived, and a personalized field may only vary by audiences named here, so this
-     * is what scopes a definition and gives the field editor a short list to offer
-     *
-     * Optional: a definition that declares none simply cannot hold a personalized field
-     */
-    audiences?: string[];
 };
 /**
  * This type represent the model of the attribute fragments in a content definition schema
@@ -304,7 +296,7 @@ export type OneLinkedContentOfConstraints = {
 };
 /**
  * This type represent what every value of a personalized field holds: one descriptor for the whole field,
- * so the rules and the fallback cannot differ in type
+ * so the variants and the fallback cannot differ in type
  *
  * Only the two `one...Of` forms are admitted: `fragment` and `linked-content` are each the
  * single-target special case of one of them, carrying an identical payload value
@@ -319,24 +311,14 @@ export type PersonalizedVariantType = {
 /**
  * This type represent the model of a personalized field constraints
  *
- * A personalized field declares only *what varies* and *what shape the values have*. Which conditions
- * exist and what each of them serves is authored per content, as an ordered list of rules plus a
- * fallback - see [[PersonalizedFieldPayload]] - so no combination has to be pre-declared here and two
- * contents of the same definition may carry entirely different rule sets
+ * A personalized field says only *what shape the values have*. Which audiences it serves is authored
+ * per content, as an ordered list of variants plus a fallback - see [[PersonalizedFieldPayload]] - so
+ * nothing has to be pre-declared here and two contents of the same definition may target entirely
+ * different audiences
  */
 export type PersonalizedFieldConstraints = {
     /**
-     * The mnemonic ids of the audiences this field varies by, which must be among the ones the
-     * definition declares in [[ContentDefinitionSchema.audiences]]. Only the declaration is checked
-     * against the space, so an audience that does not exist is one error on the definition rather than
-     * one on every field that reached for it
-     *
-     * Declaration order carries no meaning: a rule wins by being first in the content, not by which
-     * audience it constrains
-     */
-    audiences: string[];
-    /**
-     * The shape every rule value and the fallback conform to
+     * The shape every variant value and the fallback conform to
      */
     variantType: PersonalizedVariantType;
 };

package/dist/api/Dimension.d.ts

@@ -0,0 +1,249 @@
+import { AuthorResponse } from './Author';
+import { PagedListResponse } from './common';
+/**
+ * The dimension unique id
+ */
+export type DimensionId = number;
+/**
+ * A dimension'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 `audiences` query param and are compared against strings a client supplies
+ */
+export declare const DIMENSION_NAME_PATTERN: RegExp;
+/**
+ * This type represent one key of a dimension, that is one of the values a visitor can have for it
+ */
+export type DimensionKey = {
+    /**
+     * The key, matching [[DIMENSION_NAME_PATTERN]]
+     */
+    key: string;
+    /**
+     * A deprecated key cannot be referenced by new audience rules, while every rule already written
+     * keeps resolving. The flag toggles both ways
+     */
+    deprecated?: boolean;
+};
+/**
+ * This type represent the model of a dimension, that is something a visitor can be described by -
+ * `gender`, `loyalty`, `auth_status` - holding the fixed set of keys they can have for it
+ *
+ * Dimensions are what audience rules are written over, and a visitor's values for them are what the
+ * delivery request carries. Audiences reference a dimension by mnemonicId and key, so dimensions are
+ * archived and never deleted, and a key can only be removed or renamed while no audience uses it
+ */
+export type DimensionResponse = {
+    /**
+     * The dimension unique id
+     */
+    id: DimensionId;
+    /**
+     * The dimension name
+     */
+    name: string;
+    /**
+     * The dimension mnemonic id, matching [[DIMENSION_NAME_PATTERN]]
+     */
+    mnemonicId: string;
+    /**
+     * The keys a visitor can hold for this dimension, each carrying its own deprecation state
+     */
+    keys: DimensionKey[];
+    /**
+     * The archived status of the dimension
+     */
+    archived: boolean;
+    /**
+     * The archive date of the dimension
+     */
+    archivedDate: Date | null;
+    /**
+     * The dimension creation date
+     */
+    createdDate: Date;
+    /**
+     * The dimension last modified date
+     */
+    lastModifiedDate: Date;
+    /**
+     * The dimension author, resolved by `list` only
+     */
+    author?: AuthorResponse;
+    /**
+     * The dimension last modified author, resolved by every endpoint but `get`
+     */
+    latestContributor?: AuthorResponse;
+};
+/**
+ * This type represent all possible filters used to retrieve a list of dimension
+ */
+export type ListDimensionsFilters = {
+    /**
+     * This filter is used to retrieve archived or not archived dimensions. Defaults to not archived
+     */
+    archived?: boolean;
+};
+/**
+ * This type represent the data needed to make a list dimensions API request
+ */
+export type ListDimensionsRequest = {
+    /**
+     * The number of dimensions to skip (this value is used for pagination)
+     */
+    skip?: number;
+    /**
+     * The number of dimensions to take (this value is used for pagination), at most 100
+     */
+    take?: number;
+    /**
+     * The data used to filter the list of dimensions
+     */
+    filters?: ListDimensionsFilters;
+};
+/**
+ * This type represent the item of a list dimensions API request
+ */
+export type ListDimensionsItem = DimensionResponse;
+/**
+ * This type represent the response of a list dimensions API request
+ */
+export type ListDimensionsResponse = PagedListResponse<ListDimensionsItem>;
+/**
+ * This type represent the usage of one key of a dimension. A key with no entry is named by no audience
+ * rule, and is therefore the only kind of key that can be removed or renamed
+ */
+export type DimensionKeyUsage = {
+    /**
+     * The key, or null for the rules that constrain the dimension without naming any key - that is the
+     * ones that only fire when the dimension is unknown
+     */
+    key: string | null;
+    /**
+     * How many audiences reference this key
+     */
+    audiences: number;
+};
+/**
+ * This type represent an audience whose rule names a dimension
+ */
+export type AudienceUsingDimension = {
+    /**
+     * The audience unique id
+     */
+    id: number;
+    /**
+     * The audience mnemonic id
+     */
+    mnemonicId: string;
+    /**
+     * The audience name
+     */
+    name: string;
+};
+/**
+ * This type represent the data needed to make a get dimension API request
+ */
+export type GetDimensionRequest = {
+    /**
+     * The unique dimension id to retrieve
+     */
+    id: DimensionId;
+};
+/**
+ * This type represent the response of a get dimension API request: the dimension, plus the two things
+ * the editor cannot decide without, which keys are in use and which audiences are written against it
+ */
+export type GetDimensionResponse = DimensionResponse & {
+    /**
+     * One entry per key at least one audience rule names. A key absent from this list is unused
+     */
+    keyUsage: DimensionKeyUsage[];
+    /**
+     * The audiences whose rule names this dimension
+     */
+    audiences: AudienceUsingDimension[];
+};
+/**
+ * This type represent the data needed to make a create dimension API request
+ */
+export type CreateDimensionRequest = {
+    /**
+     * The dimension name
+     */
+    name: string;
+    /**
+     * The dimension mnemonic id, matching [[DIMENSION_NAME_PATTERN]]
+     */
+    mnemonicId: string;
+    /**
+     * The keys a visitor can hold for this dimension, at least one, each key unique
+     */
+    keys: DimensionKey[];
+};
+/**
+ * This type represent the response of a create dimension API request
+ */
+export type CreateDimensionResponse = DimensionResponse;
+/**
+ * This type represent the data needed to make an update dimension 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 an audience rule
+ * still names it. `mnemonicId` cannot be changed
+ */
+export type UpdateDimensionRequest = {
+    /**
+     * The dimension unique id
+     */
+    id: DimensionId;
+    /**
+     * The dimension name to update
+     */
+    name: string;
+    /**
+     * The dimension mnemonic id, which must be the stored one
+     */
+    mnemonicId: string;
+    /**
+     * The whole key list, replacing what is stored
+     */
+    keys: DimensionKey[];
+};
+/**
+ * This type represent the response of an update dimension API request
+ */
+export type UpdateDimensionResponse = DimensionResponse;
+/**
+ * This type represent the data needed to make a toggle archived dimension API request
+ */
+export type ToggleArchivedDimensionRequest = {
+    /**
+     * The dimension unique id
+     */
+    id: DimensionId;
+    /**
+     * This value represent the archive status to set in the specified dimension
+     */
+    archived: boolean;
+};
+/**
+ * This type represent the response of a toggle archived dimension API request
+ */
+export type ToggleArchivedDimensionResponse = DimensionResponse;
+/**
+ * This type represent a visitor's value per dimension, as the rule engine reads it. A dimension missing
+ * from the map, or set to `undefined`, means "not provided" - which is what
+ * [[DimensionPredicate.orUnset]] answers
+ */
+export type DimensionAssignment = {
+    [dimensionMnemonicId: string]: string | undefined;
+};
+/**
+ * The stand-in a coverage report uses for "a key none of the analysed rules mention"
+ *
+ * Not a real key - it cannot be one, since keys match [[DIMENSION_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
+ */
+export declare const OTHER_KEY = "<any other key>";

package/dist/api/Dimension.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTHER_KEY = exports.DIMENSION_NAME_PATTERN = void 0;
+/**
+ * A dimension'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 `audiences` query param and are compared against strings a client supplies
+ */
+exports.DIMENSION_NAME_PATTERN = /^[a-z0-9_-]+$/;
+/**
+ * The stand-in a coverage report uses for "a key none of the analysed rules mention"
+ *
+ * Not a real key - it cannot be one, since keys match [[DIMENSION_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
+ */
+exports.OTHER_KEY = '<any other key>';

package/dist/api/index.d.ts

@@ -8,6 +8,7 @@ export * from './ContentDefinitionSchema';
 export * from './ContentExportImport';
 export * from './ContentRepository';
 export * from './ContentTag';
+export * from './Dimension';
 export * from './Invites';
 export * from './MediaGallery';
 export * from './PublishedContent';

package/dist/api/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./ContentDefinitionSchema"), exports);
 __exportStar(require("./ContentExportImport"), exports);
 __exportStar(require("./ContentRepository"), exports);
 __exportStar(require("./ContentTag"), exports);
+__exportStar(require("./Dimension"), exports);
 __exportStar(require("./Invites"), exports);
 __exportStar(require("./MediaGallery"), exports);
 __exportStar(require("./PublishedContent"), exports);