Skip to content

Api reference

components.guarantee_catalog.public.commands

sync_guarantee_catalog

guarantee_catalog module-attribute 

guarantee_catalog = AppGroup(
    name="guarantee_catalog",
    help="Main command group for the Guarantee Catalog component",
)

sync_guarantee_catalog 

sync_guarantee_catalog(
    dry_run=False, product_type_override=None
)

Synchronize guarantee catalog from YAML configuration to database.

This command: 1. Reads the guarantee catalog configuration from guarantees.yaml 2. Validates the structure and relationships of the configuration 3. Clears existing guarantee catalog entries from the database 4. Stores the new configuration in the database

The --dry-run flag can be used to validate and test the sync without committing changes. Use --product-type to sync a specific product type (e.g. fr_prevoyance).

Source code in components/guarantee_catalog/public/commands/sync_guarantee_catalog.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@guarantee_catalog.command()
@click.option(
    "--product-type",
    "product_type_override",
    type=click.Choice([pt.value for pt in ProductType]),
    default=None,
    help="Override the product type to sync. Defaults to the app's registered product type.",
)
@command_with_dry_run
def sync_guarantee_catalog(
    dry_run: bool = False,
    product_type_override: str | None = None,
) -> None:
    """Synchronize guarantee catalog from YAML configuration to database.

    This command:
    1. Reads the guarantee catalog configuration from guarantees.yaml
    2. Validates the structure and relationships of the configuration
    3. Clears existing guarantee catalog entries from the database
    4. Stores the new configuration in the database

    The --dry-run flag can be used to validate and test the sync without committing changes.
    Use --product-type to sync a specific product type (e.g. fr_prevoyance).
    """
    from components.guarantee_catalog.internal.business_logic.actions.guarantee_definitions_import.sync_guarantee_catalog import (
        load_guarantee_catalog_from_yaml,
    )
    from components.guarantee_catalog.public.dependencies import (
        get_app_dependency,
        get_dependency_for_product_type,
    )

    if product_type_override:
        app_dependency = get_dependency_for_product_type(
            ProductType(product_type_override)
        )
    else:
        app_dependency = get_app_dependency()

    country = app_dependency.get_country_code()
    product_type = app_dependency.get_product_type()
    catalog_file_path = app_dependency.get_guarantee_yaml_file_path()

    if not catalog_file_path.exists():
        raise click.BadParameter(
            f"Catalog file not found for product_type '{product_type.value}': {catalog_file_path}"
        )

    click.echo(
        f"Syncing guarantee catalog for product_type '{product_type.value}' "
        f"from '{catalog_file_path}' with dry_run={dry_run}"
    )

    load_guarantee_catalog_from_yaml(
        file_path=catalog_file_path,
        country=country.value,
        product_type=product_type.value,
        commit=not dry_run,
    )

    click.echo("Syncing completed")

components.guarantee_catalog.public.dependencies

COMPONENT_NAME module-attribute 

COMPONENT_NAME = 'guarantee_catalog'

GuaranteeCatalogDependency

Bases: ABC

get_country_code abstractmethod 

get_country_code()

Return the country code for the current country.

Source code in components/guarantee_catalog/public/dependencies.py 
21
22
23
@abstractmethod
def get_country_code(self) -> Country:
    """Return the country code for the current country."""

get_guarantee_yaml_file_path abstractmethod 

get_guarantee_yaml_file_path()

Implement get_guarantee_yaml_file_path

Source code in components/guarantee_catalog/public/dependencies.py 
25
26
27
@abstractmethod
def get_guarantee_yaml_file_path(self) -> Path:
    """Implement get_guarantee_yaml_file_path"""

get_product_type abstractmethod 

get_product_type()

Return the product type for this dependency.

Source code in components/guarantee_catalog/public/dependencies.py 
17
18
19
@abstractmethod
def get_product_type(self) -> ProductType:
    """Return the product type for this dependency."""

validate_coverage_rules 

validate_coverage_rules(request)

Validates country-specific coverage rules for a given coverage against guarantee definitions.

Source code in components/guarantee_catalog/public/dependencies.py 
29
30
31
32
33
34
def validate_coverage_rules(
    self,
    request: ValidateCoverageRulesRequest,  # noqa: ARG002
) -> list[GuaranteeCatalogError]:
    """Validates country-specific coverage rules for a given coverage against guarantee definitions."""
    return []

get_app_dependency 

get_app_dependency()
Source code in components/guarantee_catalog/public/dependencies.py 
51
52
53
54
def get_app_dependency() -> GuaranteeCatalogDependency:  # noqa: D103
    from flask import current_app

    return cast("CustomFlask", current_app).get_component_dependency(COMPONENT_NAME)  # type: ignore[no-any-return]

get_dependency_for_product_type 

get_dependency_for_product_type(product_type)

Get the registered dependency for a specific product type.

Source code in components/guarantee_catalog/public/dependencies.py 
57
58
59
60
61
62
63
64
65
def get_dependency_for_product_type(
    product_type: ProductType,
) -> GuaranteeCatalogDependency:
    """Get the registered dependency for a specific product type."""
    from flask import current_app

    return cast("CustomFlask", current_app).get_component_dependency(  # type: ignore[no-any-return]
        _dependency_key(product_type)
    )

set_app_dependency 

set_app_dependency(dependency)
Source code in components/guarantee_catalog/public/dependencies.py 
41
42
43
44
45
46
47
48
def set_app_dependency(dependency: GuaranteeCatalogDependency) -> None:  # noqa: D103
    from flask import current_app

    app = cast("CustomFlask", current_app)
    app.add_component_dependency(COMPONENT_NAME, dependency)
    app.add_component_dependency(
        _dependency_key(dependency.get_product_type()), dependency
    )

components.guarantee_catalog.public.entities

coverage_rules

AggregatedLimitParameter module-attribute 

AggregatedLimitParameter = (
    InstantiatedBundleChoiceParameter
    | InstantiatedCategoryParameter
)

CoverageRule

Bases: CoverageRuleBaseModel

Model representing an instantiated guarantee (coverage rule) with its chosen expression type, parameters and optional eligibility items.

bundle_choice_business_id instance-attribute 
bundle_choice_business_id
eligibility_items class-attribute instance-attribute 
eligibility_items = None
expression_type instance-attribute 
expression_type
guarantee_business_id instance-attribute 
guarantee_business_id
parameters instance-attribute 
parameters

CoverageRuleBaseModel

Bases: BaseModel

Base Pydantic model for all coverage-rule-related models.

Config

Pydantic model configuration.

Attributes:

Name Type Description
frozen

Makes all models immutable after creation
frozen class-attribute instance-attribute 
frozen = True

CoverageRuleParameter

Bases: CoverageRuleBaseModel

Model representing a parameter value for a coverage rule.

type instance-attribute 
type
value instance-attribute 
value

CoverageRuleValidationContext dataclass 

CoverageRuleValidationContext(
    guarantee_business_id=None,
    bundle_choice_business_id=None,
    category_business_id=None,
    parameter_type=None,
)

Bases: DataClassJsonMixin

Context information for a coverage rule validation error.

bundle_choice_business_id class-attribute instance-attribute 
bundle_choice_business_id = None
category_business_id class-attribute instance-attribute 
category_business_id = None
guarantee_business_id class-attribute instance-attribute 
guarantee_business_id = None
parameter_type class-attribute instance-attribute 
parameter_type = None

InstantiatedBundleChoiceParameter

Bases: CoverageRuleParameter

Model representing a parameter value for a bundle choice.

bundle_choice_business_id instance-attribute 
bundle_choice_business_id

InstantiatedCategoryParameter

Bases: CoverageRuleParameter

Model representing a parameter value for a category.

category_business_id instance-attribute 
category_business_id

PropagatedParameter module-attribute 

PropagatedParameter = (
    InstantiatedBundleChoiceParameter
    | InstantiatedCategoryParameter
)

ValidateCoverageRulesRequest

Bases: CoverageRuleBaseModel

Model representing a request to validate a set of coverage rules.

Includes: - List of coverage rules - Propagated parameters for bundle choices and categories - Aggregated limit parameters for bundle choices and categories - Selected category IDs to validate required coverage rules

aggregated_limit_parameters instance-attribute 
aggregated_limit_parameters
coverage_rules instance-attribute 
coverage_rules
propagated_parameters instance-attribute 
propagated_parameters
selected_categories instance-attribute 
selected_categories

errors

GuaranteeCatalogError 

GuaranteeCatalogError(
    error_type,
    description,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
    param_type=None,
    **kwargs
)

Bases: BaseErrorCode

Error class for guarantee catalog validation failures.

Initialize a guarantee catalog error with type and description.

Source code in components/guarantee_catalog/public/entities/errors.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def __init__(
    self,
    error_type: GuaranteeCatalogErrorType,
    description: str,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
    param_type: GuaranteeParameterType | None = None,
    **kwargs: Any,
) -> None:
    """Initialize a guarantee catalog error with type and description."""
    super().__init__(
        99999, error_type.value, description, **kwargs
    )  # TODO: remove code when it becomes optional after a PR that will be opened soon.
    self.guarantee_id = guarantee_id
    self.bundle_choice_id = bundle_choice_id
    self.category_id = category_id
    self.param_type = param_type
builder_coverage_lower_level_than_source classmethod 
builder_coverage_lower_level_than_source(
    guarantee_id,
    bundle_choice_id,
    description,
    missing_eligibility_items=None,
    param_type=None,
)

Create error for target coverage less premium than source.

Source code in components/guarantee_catalog/public/entities/errors.py 
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def builder_coverage_lower_level_than_source(
    cls,
    guarantee_id: str,
    bundle_choice_id: str,
    description: str,
    missing_eligibility_items: list[str] | None = None,
    param_type: GuaranteeParameterType | None = None,
) -> GuaranteeCatalogError:
    """Create error for target coverage less premium than source."""
    return cls(
        error_type=GuaranteeCatalogErrorType.builder_coverage_lower_level_than_source,
        description=description,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        missing_eligibility_items=missing_eligibility_items,
        param_type=param_type,
    )
bundle_choice_id instance-attribute 
bundle_choice_id = bundle_choice_id
bundle_choice_not_found classmethod 
bundle_choice_not_found(
    bundle_choice_id, guarantee_id=None
)

Create error for non-existent bundle choice.

Source code in components/guarantee_catalog/public/entities/errors.py 
71
72
73
74
75
76
77
78
79
80
81
@classmethod
def bundle_choice_not_found(
    cls, bundle_choice_id: str, guarantee_id: str | None = None
) -> GuaranteeCatalogError:
    """Create error for non-existent bundle choice."""
    return cls(
        error_type=GuaranteeCatalogErrorType.bundle_choice_not_found,
        description="Bundle choice does not exist in catalog",
        bundle_choice_id=bundle_choice_id,
        guarantee_id=guarantee_id,
    )
category_id instance-attribute 
category_id = category_id
duplicate_guarantee classmethod 
duplicate_guarantee(guarantee_id, bundle_choice_id)

Create error for duplicate guarantee in bundle choice.

Source code in components/guarantee_catalog/public/entities/errors.py 
83
84
85
86
87
88
89
90
91
92
93
@classmethod
def duplicate_guarantee(
    cls, guarantee_id: str, bundle_choice_id: str
) -> GuaranteeCatalogError:
    """Create error for duplicate guarantee in bundle choice."""
    return cls(
        error_type=GuaranteeCatalogErrorType.duplicate_guarantee,
        description="Duplicate guarantee and bundle choice combination",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )
duplicate_parameter classmethod 
duplicate_parameter(
    param_type,
    level_name,
    identifier,
    is_limit=False,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for duplicate parameters within the same level.

Source code in components/guarantee_catalog/public/entities/errors.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
@classmethod
def duplicate_parameter(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    is_limit: bool = False,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for duplicate parameters within the same level."""
    param_type_name = "limit" if is_limit else "propagated parameter"
    return cls(
        error_type=GuaranteeCatalogErrorType.duplicate_parameter,
        description=f"Duplicate {param_type_name} type {param_type} for {level_name} {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        category_id=category_id,
    )
exactly_one_bundle_choice_required classmethod 
exactly_one_bundle_choice_required(
    bundle_choice_id, other_bundle_choice_id
)

Create error for incompatible bundle choice.

Source code in components/guarantee_catalog/public/entities/errors.py 
119
120
121
122
123
124
125
126
127
128
129
130
@classmethod
def exactly_one_bundle_choice_required(
    cls,
    bundle_choice_id: str,
    other_bundle_choice_id: str,
) -> GuaranteeCatalogError:
    """Create error for incompatible bundle choice."""
    return cls(
        error_type=GuaranteeCatalogErrorType.exactly_one_bundle_choice_required,
        description=f"Exactly one of '{bundle_choice_id}' or '{other_bundle_choice_id}' must be selected",
        bundle_choice_id=bundle_choice_id,
    )
guarantee_from_unselected_category classmethod 
guarantee_from_unselected_category(
    guarantee_id, bundle_choice_id, category_id
)

Create error for guarantee from unselected category.

Source code in components/guarantee_catalog/public/entities/errors.py 
132
133
134
135
136
137
138
139
140
141
142
143
@classmethod
def guarantee_from_unselected_category(
    cls, guarantee_id: str, bundle_choice_id: str, category_id: str
) -> GuaranteeCatalogError:
    """Create error for guarantee from unselected category."""
    return cls(
        error_type=GuaranteeCatalogErrorType.guarantee_from_unselected_category,
        description=f"Guarantee '{guarantee_id}' belongs to unselected category '{category_id}'",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        category_id=category_id,
    )
guarantee_id instance-attribute 
guarantee_id = guarantee_id
guarantee_not_found classmethod 
guarantee_not_found(guarantee_id, bundle_choice_id)

Create error for non-existent guarantee.

Source code in components/guarantee_catalog/public/entities/errors.py 
145
146
147
148
149
150
151
152
153
154
155
@classmethod
def guarantee_not_found(
    cls, guarantee_id: str, bundle_choice_id: str | None
) -> GuaranteeCatalogError:
    """Create error for non-existent guarantee."""
    return cls(
        error_type=GuaranteeCatalogErrorType.guarantee_not_found,
        description=f"Guarantee {guarantee_id} does not exist",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )
guarantee_not_in_bundle_choice classmethod 
guarantee_not_in_bundle_choice(
    guarantee_id, bundle_choice_id
)

Create error for guarantee that doesn't belong to the specified bundle choice.

Source code in components/guarantee_catalog/public/entities/errors.py 
157
158
159
160
161
162
163
164
165
166
167
@classmethod
def guarantee_not_in_bundle_choice(
    cls, guarantee_id: str, bundle_choice_id: str
) -> GuaranteeCatalogError:
    """Create error for guarantee that doesn't belong to the specified bundle choice."""
    return cls(
        error_type=GuaranteeCatalogErrorType.guarantee_not_in_bundle_choice,
        description=f"Guarantee '{guarantee_id}' is not part of bundle choice '{bundle_choice_id}'",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )
invalid_parameter_format classmethod 
invalid_parameter_format(
    param_type,
    level_name,
    identifier,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for invalid parameter format.

Source code in components/guarantee_catalog/public/entities/errors.py 
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
@classmethod
def invalid_parameter_format(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for invalid parameter format."""
    return cls(
        error_type=GuaranteeCatalogErrorType.invalid_parameter_format,
        description=f"Invalid parameter value of {param_type}  format at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        category_id=category_id,
    )
mandatory_bundle_missing classmethod 
mandatory_bundle_missing(category_id, bundle_id)

Create error for missing mandatory bundle.

Source code in components/guarantee_catalog/public/entities/errors.py 
191
192
193
194
195
196
197
198
199
200
201
@classmethod
def mandatory_bundle_missing(
    cls, category_id: str, bundle_id: str
) -> GuaranteeCatalogError:
    """Create error for missing mandatory bundle."""
    return cls(
        error_type=GuaranteeCatalogErrorType.mandatory_bundle_missing,
        description="Mandatory bundle not selected",
        category_id=category_id,
        bundle_id=bundle_id,
    )
missing_bundle_choice_guarantee classmethod 
missing_bundle_choice_guarantee(
    guarantee_id, bundle_choice_id
)

Create error for missing guarantee from bundle choice.

Source code in components/guarantee_catalog/public/entities/errors.py 
222
223
224
225
226
227
228
229
230
231
232
@classmethod
def missing_bundle_choice_guarantee(
    cls, guarantee_id: str, bundle_choice_id: str
) -> GuaranteeCatalogError:
    """Create error for missing guarantee from bundle choice."""
    return cls(
        error_type=GuaranteeCatalogErrorType.missing_bundle_choice_guarantee,
        description="Required guarantee from selected bundle choice is missing",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )
missing_mandatory_eligibility_item classmethod 
missing_mandatory_eligibility_item(
    guarantee_id,
    bundle_choice_id,
    missing_eligibility_items,
)

Create error for missing mandatory eligibility items.

Source code in components/guarantee_catalog/public/entities/errors.py 
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
@classmethod
def missing_mandatory_eligibility_item(
    cls,
    guarantee_id: str,
    bundle_choice_id: str,
    missing_eligibility_items: set[str],
) -> GuaranteeCatalogError:
    """Create error for missing mandatory eligibility items."""
    return cls(
        error_type=GuaranteeCatalogErrorType.missing_mandatory_eligibility_item,
        description="Missing mandatory eligibility items",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        missing_eligibility_items=missing_eligibility_items,
    )
missing_parameter classmethod 
missing_parameter(
    missing_types,
    level_name,
    identifier,
    param_type,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for missing required parameters.

Source code in components/guarantee_catalog/public/entities/errors.py 
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
@classmethod
def missing_parameter(
    cls,
    missing_types: set[str],
    level_name: str,
    identifier: str,
    param_type: GuaranteeParameterType,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for missing required parameters."""
    return cls(
        error_type=GuaranteeCatalogErrorType.missing_parameter,
        description=f"Missing parameters of types: {', '.join(missing_types)} at {level_name} for ID {identifier}",
        missing_types=list(missing_types),
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        param_type=param_type,
        category_id=category_id,
    )
missing_propagated_limit classmethod 
missing_propagated_limit(
    level_name, identifier, param_type
)

Create error for missing propagated limit parameter.

Source code in components/guarantee_catalog/public/entities/errors.py 
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
@classmethod
def missing_propagated_limit(
    cls,
    level_name: str,
    identifier: str,
    param_type: GuaranteeParameterType,
) -> GuaranteeCatalogError:
    """Create error for missing propagated limit parameter."""
    return cls(
        error_type=GuaranteeCatalogErrorType.missing_propagated_limit,
        description=f"Propagated limit parameter '{param_type}' is missing for {level_name} '{identifier}'",
        level_name=level_name,
        identifier=identifier,
        param_type=param_type,
    )
multiple_bundle_choices classmethod 
multiple_bundle_choices(bundle_choice_id, guarantee_id)

Create error for multiple bundle choices selected from same bundle.

Source code in components/guarantee_catalog/public/entities/errors.py 
302
303
304
305
306
307
308
309
310
311
312
@classmethod
def multiple_bundle_choices(
    cls, bundle_choice_id: str, guarantee_id: str
) -> GuaranteeCatalogError:
    """Create error for multiple bundle choices selected from same bundle."""
    return cls(
        error_type=GuaranteeCatalogErrorType.multiple_bundle_choices,
        description="Multiple bundle choices selected for the same bundle",
        bundle_choice_id=bundle_choice_id,
        guarantee_id=guarantee_id,
    )
no_eligibility_items_selected classmethod 
no_eligibility_items_selected(
    guarantee_id, bundle_choice_id
)

Create error if no eligibility items are selected.

Source code in components/guarantee_catalog/public/entities/errors.py 
290
291
292
293
294
295
296
297
298
299
300
@classmethod
def no_eligibility_items_selected(
    cls, guarantee_id: str, bundle_choice_id: str
) -> GuaranteeCatalogError:
    """Create error if no eligibility items are selected."""
    return cls(
        error_type=GuaranteeCatalogErrorType.no_eligibility_item_selected,
        description="The guarantee requires to pick at least one eligibility item; if none are desired, deactivate the guarantee",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )
param_type instance-attribute 
param_type = param_type
parameter_below_business_min classmethod 
parameter_below_business_min(
    param_type,
    level_name,
    identifier,
    min_value,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for parameter below business minimum.

Source code in components/guarantee_catalog/public/entities/errors.py 
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
@classmethod
def parameter_below_business_min(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    min_value: float,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for parameter below business minimum."""
    return cls(
        error_type=GuaranteeCatalogErrorType.parameter_below_business_min,
        description=f"Parameter value of {param_type} is below business minimum at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        min_value=min_value,
        category_id=category_id,
    )
parameter_below_pricer_min classmethod 
parameter_below_pricer_min(
    param_type,
    level_name,
    identifier,
    min_value,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for parameter below pricer minimum.

Source code in components/guarantee_catalog/public/entities/errors.py 
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
@classmethod
def parameter_below_pricer_min(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    min_value: float,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for parameter below pricer minimum."""
    return cls(
        error_type=GuaranteeCatalogErrorType.parameter_below_pricer_min,
        description=f"Parameter value of {param_type}  is below pricer minimum at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        min_value=min_value,
        category_id=category_id,
    )
parameter_exceeds_business_max classmethod 
parameter_exceeds_business_max(
    param_type,
    level_name,
    identifier,
    max_value,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for parameter exceeding business maximum.

Source code in components/guarantee_catalog/public/entities/errors.py 
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
@classmethod
def parameter_exceeds_business_max(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    max_value: float,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for parameter exceeding business maximum."""
    return cls(
        error_type=GuaranteeCatalogErrorType.parameter_exceeds_business_max,
        description=f"Parameter value of {param_type}  exceeds business maximum at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        max_value=max_value,
        category_id=category_id,
    )
parameter_exceeds_fiscal_max classmethod 
parameter_exceeds_fiscal_max(
    param_type,
    level_name,
    identifier,
    max_value,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for parameter exceeding fiscal maximum.

Source code in components/guarantee_catalog/public/entities/errors.py 
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
@classmethod
def parameter_exceeds_fiscal_max(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    max_value: float,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for parameter exceeding fiscal maximum."""
    return cls(
        error_type=GuaranteeCatalogErrorType.parameter_exceeds_fiscal_max,
        description=f"Parameter value of {param_type} exceeds fiscal max at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        max_value=max_value,
        category_id=category_id,
    )
parameter_exceeds_pricer_max classmethod 
parameter_exceeds_pricer_max(
    param_type,
    level_name,
    identifier,
    max_value,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for parameter exceeding pricer maximum.

Source code in components/guarantee_catalog/public/entities/errors.py 
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
@classmethod
def parameter_exceeds_pricer_max(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    max_value: float,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for parameter exceeding pricer maximum."""
    return cls(
        error_type=GuaranteeCatalogErrorType.parameter_exceeds_pricer_max,
        description=f"Parameter value of {param_type}  exceeds pricer maximum at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        max_value=max_value,
        category_id=category_id,
    )
unexpected_parameter classmethod 
unexpected_parameter(
    param_type,
    level_name,
    identifier,
    guarantee_id=None,
    bundle_choice_id=None,
    category_id=None,
)

Create error for unexpected parameter that wasn't defined.

Source code in components/guarantee_catalog/public/entities/errors.py 
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
@classmethod
def unexpected_parameter(
    cls,
    param_type: GuaranteeParameterType,
    level_name: str,
    identifier: str,
    guarantee_id: str | None = None,
    bundle_choice_id: str | None = None,
    category_id: str | None = None,
) -> GuaranteeCatalogError:
    """Create error for unexpected parameter that wasn't defined."""
    return cls(
        error_type=GuaranteeCatalogErrorType.unexpected_parameter,
        description=f"Unexpected parameter '{param_type}' provided at {level_name} for ID {identifier}",
        param_type=param_type,
        level_name=level_name,
        identifier=identifier,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        category_id=category_id,
    )
unexpected_parameter_source classmethod 
unexpected_parameter_source(
    guarantee_id, bundle_choice_id, param_type
)

Create error for unexpected constant or propagated parameter.

Source code in components/guarantee_catalog/public/entities/errors.py 
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
@classmethod
def unexpected_parameter_source(
    cls,
    guarantee_id: str,
    bundle_choice_id: str,
    param_type: GuaranteeParameterType,
) -> GuaranteeCatalogError:
    """Create error for unexpected constant or propagated parameter."""
    return cls(
        error_type=GuaranteeCatalogErrorType.unexpected_parameter_source,
        description=f"Parameter '{param_type}' for guarantee '{guarantee_id}' is defined as constant or propagated but was provided",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        param_type=param_type,
    )
unknown_eligibility_item classmethod 
unknown_eligibility_item(
    guarantee_id, bundle_choice_id, eligibility_item_id
)

Create error for unknown eligibility item.

Source code in components/guarantee_catalog/public/entities/errors.py 
472
473
474
475
476
477
478
479
480
481
482
483
@classmethod
def unknown_eligibility_item(
    cls, guarantee_id: str, bundle_choice_id: str, eligibility_item_id: str
) -> GuaranteeCatalogError:
    """Create error for unknown eligibility item."""
    return cls(
        error_type=GuaranteeCatalogErrorType.unknown_eligibility_item,
        description=f"Unknown eligibility item '{eligibility_item_id}' for guarantee '{guarantee_id}' in bundle choice '{bundle_choice_id}'",
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
        eligibility_item_id=eligibility_item_id,
    )
unsupported_expression_type classmethod 
unsupported_expression_type(
    expression_type, guarantee_id, bundle_choice_id
)

Create error for unsupported expression type.

Source code in components/guarantee_catalog/public/entities/errors.py 
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
@classmethod
def unsupported_expression_type(
    cls,
    expression_type: str,
    guarantee_id: str,
    bundle_choice_id: str | None,
) -> GuaranteeCatalogError:
    """Create error for unsupported expression type."""
    return cls(
        error_type=GuaranteeCatalogErrorType.unsupported_expression_type,
        description=f"Expression type {expression_type} is not supported for guarantee {guarantee_id}",
        expression_error_type=expression_type,
        guarantee_id=guarantee_id,
        bundle_choice_id=bundle_choice_id,
    )

GuaranteeCatalogErrorType

Bases: AlanBaseEnum

Error types for guarantee catalog validation.

builder_coverage_lower_level_than_source class-attribute instance-attribute 
builder_coverage_lower_level_than_source = (
    "builder_coverage_lower_level_than_source"
)
bundle_choice_not_found class-attribute instance-attribute 
bundle_choice_not_found = 'bundle_choice_not_found'
duplicate_guarantee class-attribute instance-attribute 
duplicate_guarantee = 'duplicate_guarantee'
duplicate_parameter class-attribute instance-attribute 
duplicate_parameter = 'duplicate_parameter'
exactly_one_bundle_choice_required class-attribute instance-attribute 
exactly_one_bundle_choice_required = (
    "exactly_one_bundle_choice_required"
)
guarantee_from_unselected_category class-attribute instance-attribute 
guarantee_from_unselected_category = (
    "guarantee_from_unselected_category"
)
guarantee_not_found class-attribute instance-attribute 
guarantee_not_found = 'guarantee_not_found'
guarantee_not_in_bundle_choice class-attribute instance-attribute 
guarantee_not_in_bundle_choice = (
    "guarantee_not_in_bundle_choice"
)
invalid_parameter_format class-attribute instance-attribute 
invalid_parameter_format = 'invalid_parameter_format'
mandatory_bundle_missing class-attribute instance-attribute 
mandatory_bundle_missing = 'mandatory_bundle_missing'
missing_bundle_choice_guarantee class-attribute instance-attribute 
missing_bundle_choice_guarantee = (
    "missing_bundle_choice_guarantee"
)
missing_mandatory_eligibility_item class-attribute instance-attribute 
missing_mandatory_eligibility_item = (
    "missing_mandatory_eligibility_item"
)
missing_parameter class-attribute instance-attribute 
missing_parameter = 'missing_parameter'
missing_propagated_limit class-attribute instance-attribute 
missing_propagated_limit = 'missing_propagated_limit'
multiple_bundle_choices class-attribute instance-attribute 
multiple_bundle_choices = 'multiple_bundle_choices'
no_eligibility_item_selected class-attribute instance-attribute 
no_eligibility_item_selected = (
    "no_eligibility_item_selected"
)
parameter_below_business_min class-attribute instance-attribute 
parameter_below_business_min = (
    "parameter_below_business_min"
)
parameter_below_pricer_min class-attribute instance-attribute 
parameter_below_pricer_min = 'parameter_below_pricer_min'
parameter_diverges_from_constant_value class-attribute instance-attribute 
parameter_diverges_from_constant_value = (
    "parameter_diverges_from_constant_value"
)
parameter_exceeds_business_max class-attribute instance-attribute 
parameter_exceeds_business_max = (
    "parameter_exceeds_business_max"
)
parameter_exceeds_fiscal_max class-attribute instance-attribute 
parameter_exceeds_fiscal_max = (
    "parameter_exceeds_fiscal_max"
)
parameter_exceeds_pricer_max class-attribute instance-attribute 
parameter_exceeds_pricer_max = (
    "parameter_exceeds_pricer_max"
)
unexpected_parameter class-attribute instance-attribute 
unexpected_parameter = 'unexpected_parameter'
unexpected_parameter_source class-attribute instance-attribute 
unexpected_parameter_source = 'unexpected_parameter_source'
unknown_eligibility_item class-attribute instance-attribute 
unknown_eligibility_item = 'unknown_eligibility_item'
unsupported_expression_type class-attribute instance-attribute 
unsupported_expression_type = 'unsupported_expression_type'

guarantee_definition

Bundle dataclass 

Bundle(
    *,
    business_identifier,
    product_type,
    is_optional,
    bundle_choices,
    display_name=None
)

Bases: DataClassJsonMixin

A guarantee bundle.

Contains multiple bundle choices.

bundle_choices instance-attribute 
bundle_choices
business_identifier instance-attribute 
business_identifier
display_name class-attribute instance-attribute 
display_name = None
is_optional instance-attribute 
is_optional
product_type instance-attribute 
product_type

BundleChoice dataclass 

BundleChoice(
    *,
    business_identifier,
    product_type,
    guarantees,
    display_name=None,
    premiumness=None,
    propagated_parameters=list(),
    aggregated_limit_parameters=list(),
    is_default,
    status
)

Bases: DataClassJsonMixin

A guarantee bundle choice.

Groups guarantees that must be offered together.

aggregated_limit_parameters class-attribute instance-attribute 
aggregated_limit_parameters = field(default_factory=list)
business_identifier instance-attribute 
business_identifier
display_name class-attribute instance-attribute 
display_name = None
guarantees instance-attribute 
guarantees
is_default instance-attribute 
is_default
premiumness class-attribute instance-attribute 
premiumness = None
product_type instance-attribute 
product_type
propagated_parameters class-attribute instance-attribute 
propagated_parameters = field(default_factory=list)
status instance-attribute 
status

Category dataclass 

Category(
    *,
    business_identifier,
    product_type,
    bundles,
    display_name=None,
    propagated_parameters=list(),
    aggregated_limit_parameters=list()
)

Bases: DataClassJsonMixin

A guarantee category.

Groups related bundles together with shared parameters.

aggregated_limit_parameters class-attribute instance-attribute 
aggregated_limit_parameters = field(default_factory=list)
bundles instance-attribute 
bundles
business_identifier instance-attribute 
business_identifier
display_name class-attribute instance-attribute 
display_name = None
product_type instance-attribute 
product_type
propagated_parameters class-attribute instance-attribute 
propagated_parameters = field(default_factory=list)

EligibleBeneficiary dataclass 

EligibleBeneficiary(*, identifier, type, parameters=list())

Bases: DataClassJsonMixin

An eligible beneficiary criterion for a guarantee.

identifier instance-attribute 
identifier
parameters class-attribute instance-attribute 
parameters = field(default_factory=list)
type instance-attribute 
type

EligibleBeneficiaryParameter dataclass 

EligibleBeneficiaryParameter(
    *,
    type,
    source,
    constant_value=None,
    business_min=None,
    business_max=None
)

Bases: DataClassJsonMixin

A parameter for an eligible beneficiary criterion.

business_max class-attribute instance-attribute 
business_max = None
business_min class-attribute instance-attribute 
business_min = None
constant_value class-attribute instance-attribute 
constant_value = None
source instance-attribute 
source
type instance-attribute 
type

EligibleEvent dataclass 

EligibleEvent(
    *, identifier, type, event_user_type, parameters=list()
)

Bases: DataClassJsonMixin

An eligible event for a guarantee.

event_user_type instance-attribute 
event_user_type
identifier instance-attribute 
identifier
parameters class-attribute instance-attribute 
parameters = field(default_factory=list)
type instance-attribute 
type

EligibleEventParameter dataclass 

EligibleEventParameter(
    *, type, source, constant_value=None
)

Bases: DataClassJsonMixin

A parameter for an eligible event.

constant_value class-attribute instance-attribute 
constant_value = None
source instance-attribute 
source
type instance-attribute 
type

EligibleMember dataclass 

EligibleMember(*, identifier, parameters=list())

Bases: DataClassJsonMixin

An eligible member criterion for a guarantee.

identifier instance-attribute 
identifier
parameters class-attribute instance-attribute 
parameters = field(default_factory=list)

EligibleMemberParameter dataclass 

EligibleMemberParameter(
    *, type, source, constant_value=None
)

Bases: DataClassJsonMixin

A parameter for an eligible member criterion.

constant_value class-attribute instance-attribute 
constant_value = None
source instance-attribute 
source
type instance-attribute 
type

Guarantee dataclass 

Guarantee(
    *,
    business_identifier,
    product_type,
    expressions,
    display_name=None,
    tax_bracket_tag=None,
    metadata=None,
    eligibility_items=list(),
    eligible_member=None,
    eligible_beneficiaries=list(),
    eligible_events=list()
)

Bases: DataClassJsonMixin

A guarantee, ie a representation of a (Alan-defined) type of care.

Contains all information needed to define a guarantee including its expressions and eligibility items.

__post_init__ 
__post_init__()

Dataclass post-initialization hook.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
165
166
167
168
169
170
171
172
173
def __post_init__(self) -> None:
    """Dataclass post-initialization hook."""
    # NB: Must use object.__setattr__ for assignment in post_init for Frozen
    # dataclass, see doc: https://docs.python.org/3/library/dataclasses.html#frozen-instances
    object.__setattr__(
        self,
        "_expressions_by_type",
        {str(expression.type): expression for expression in self.expressions},
    )
business_identifier instance-attribute 
business_identifier
display_name class-attribute instance-attribute 
display_name = None
eligibility_items class-attribute instance-attribute 
eligibility_items = field(default_factory=list)
eligible_beneficiaries class-attribute instance-attribute 
eligible_beneficiaries = field(default_factory=list)
eligible_events class-attribute instance-attribute 
eligible_events = field(default_factory=list)
eligible_member class-attribute instance-attribute 
eligible_member = None
expressions instance-attribute 
expressions
get_expression 
get_expression(expression_type)

Get an expression by its type.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
175
176
177
178
179
180
181
182
183
184
185
186
def get_expression(
    self, expression_type: GuaranteeExpressionType
) -> GuaranteeExpression:
    """Get an expression by its type."""
    try:
        return self._expressions_by_type[str(expression_type)]
    except KeyError:
        raise GuaranteeCatalogError.unsupported_expression_type(
            expression_type=expression_type,
            guarantee_id=self.business_identifier,
            bundle_choice_id=None,
        )
metadata class-attribute instance-attribute 
metadata = None
product_type instance-attribute 
product_type
tax_bracket_tag class-attribute instance-attribute 
tax_bracket_tag = None

GuaranteeCatalog dataclass 

GuaranteeCatalog(*, country, product_type, categories)

Bases: DataClassJsonMixin

A guarantee catalog.

Contains all guarantees.

  • Guarantees are regrouped into categories->bundles->bundle_choices->guarantees.
  • Each guarantee can be in several bundle_choices. However, a guarantee can be in only one bundle and only one category.
  • By transition:
    • Each bundle_choice is in exactly one bundle.
    • Each bundle is in exactly one category.
__post_init__ 
__post_init__()

Dataclass post-initialization hook.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
def __post_init__(self) -> None:
    """Dataclass post-initialization hook."""
    # NB: Must use object.__setattr__ for assignment in post_init for Frozen
    # dataclass, see doc: https://docs.python.org/3/library/dataclasses.html#frozen-instances

    bundle_choices_by_guarantee: defaultdict[str, list[BundleChoice]] = defaultdict(
        list
    )
    bundle_by_guarantee: dict[str, Bundle] = {}
    category_by_guarantee: dict[str, Category] = {}
    guarantee_by_guarantee_identifier: dict[str, Guarantee] = {}

    for category in self.categories:
        for bundle in category.bundles:
            for bundle_choice in bundle.bundle_choices:
                for guarantee in bundle_choice.guarantees:
                    guarantee_id = guarantee.business_identifier
                    guarantee_by_guarantee_identifier[guarantee_id] = guarantee
                    bundle_choices_by_guarantee[guarantee_id].append(bundle_choice)
                    if (
                        guarantee_id in category_by_guarantee
                        and category_by_guarantee[guarantee_id] != category
                    ) or (
                        guarantee_id in bundle_by_guarantee
                        and bundle_by_guarantee[guarantee_id] != bundle
                    ):
                        raise ValueError(
                            f"A guarantee ({guarantee_id}) may appear in several bundle choices, "
                            "but it belongs to only one category or bundle",
                        )
                    bundle_by_guarantee[guarantee_id] = bundle
                    category_by_guarantee[guarantee_id] = category

    object.__setattr__(self, "_bundle_by_guarantee_identifier", bundle_by_guarantee)
    object.__setattr__(
        self, "_bundle_choices_by_guarantee_identifier", bundle_choices_by_guarantee
    )
    object.__setattr__(
        self, "_category_by_guarantee_identifier", category_by_guarantee
    )
    object.__setattr__(
        self,
        "_guarantee_by_guarantee_identifier",
        guarantee_by_guarantee_identifier,
    )
categories instance-attribute 
categories
country instance-attribute 
country
get_bundle_by_guarantee 
get_bundle_by_guarantee(guarantee_id)

Get the bundle containing a given guarantee.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
346
347
348
349
350
351
352
353
def get_bundle_by_guarantee(self, guarantee_id: str) -> Bundle:
    """Get the bundle containing a given guarantee."""
    try:
        return self._bundle_by_guarantee_identifier[guarantee_id]
    except KeyError:
        raise GuaranteeCatalogError.guarantee_not_found(
            guarantee_id=guarantee_id, bundle_choice_id=None
        )
get_bundle_choices_by_guarantee 
get_bundle_choices_by_guarantee(guarantee_id)

Get all bundle choices for a given guarantee.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
337
338
339
340
341
342
343
344
def get_bundle_choices_by_guarantee(self, guarantee_id: str) -> list[BundleChoice]:
    """Get all bundle choices for a given guarantee."""
    try:
        return self._bundle_choices_by_guarantee_identifier[guarantee_id]
    except KeyError:
        raise GuaranteeCatalogError.guarantee_not_found(
            guarantee_id=guarantee_id, bundle_choice_id=None
        )
get_category_by_guarantee 
get_category_by_guarantee(guarantee_id)

Get the category containing a given guarantee.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
355
356
357
358
359
360
361
362
def get_category_by_guarantee(self, guarantee_id: str) -> Category:
    """Get the category containing a given guarantee."""
    try:
        return self._category_by_guarantee_identifier[guarantee_id]
    except KeyError:
        raise GuaranteeCatalogError.guarantee_not_found(
            guarantee_id=guarantee_id, bundle_choice_id=None
        )
get_guarantee 
get_guarantee(identifier)

Get a guarantee by its identifier.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
324
325
326
327
328
329
330
331
def get_guarantee(self, identifier: str) -> Guarantee:
    """Get a guarantee by its identifier."""
    try:
        return self._guarantee_by_guarantee_identifier[identifier]
    except KeyError:
        raise GuaranteeCatalogError.guarantee_not_found(
            guarantee_id=identifier, bundle_choice_id=None
        )
get_guarantee_or_none 
get_guarantee_or_none(identifier)

Get a guarantee by its identifier if it exists.

Source code in components/guarantee_catalog/public/entities/guarantee_definition.py 
333
334
335
def get_guarantee_or_none(self, identifier: str) -> Guarantee | None:
    """Get a guarantee by its identifier if it exists."""
    return self._guarantee_by_guarantee_identifier.get(identifier)
product_type instance-attribute 
product_type

GuaranteeEligibilityItem dataclass 

GuaranteeEligibilityItem(
    *,
    business_identifier,
    product_type,
    is_optional,
    display_name=None
)

Bases: DataClassJsonMixin

An eligibility item for a guarantee.

Defines what the guarantee applies to.

An eligibility item can be optional (guarantee must cover it) or not (guarantee may or may not cover it).

business_identifier instance-attribute 
business_identifier
display_name class-attribute instance-attribute 
display_name = None
is_optional instance-attribute 
is_optional
product_type instance-attribute 
product_type

GuaranteeExpression dataclass 

GuaranteeExpression(
    *,
    type,
    product_type,
    parameters=list(),
    status,
    is_default
)

Bases: DataClassJsonMixin

A guarantee expression.

Defines how a guarantee is reimbursed using a specific type and optional parameters.

is_default instance-attribute 
is_default
parameters class-attribute instance-attribute 
parameters = field(default_factory=list)
product_type instance-attribute 
product_type
status instance-attribute 
status
type instance-attribute 
type

GuaranteeParameter dataclass 

GuaranteeParameter(
    *,
    type,
    source,
    business_min=None,
    business_max=None,
    fiscal_max=None,
    pricer_min=None,
    pricer_max=None,
    pricer_step=None,
    constant_value=None
)

Bases: DataClassJsonMixin

A parameter for a guarantee expression.

business_max class-attribute instance-attribute 
business_max = None
business_min class-attribute instance-attribute 
business_min = None
constant_value class-attribute instance-attribute 
constant_value = None
fiscal_max class-attribute instance-attribute 
fiscal_max = None
pricer_max class-attribute instance-attribute 
pricer_max = None
pricer_min class-attribute instance-attribute 
pricer_min = None
pricer_step class-attribute instance-attribute 
pricer_step = None
source instance-attribute 
source
type instance-attribute 
type

guarantee_definition_for_display

GetGuaranteesForDisplayResponse dataclass 

GetGuaranteesForDisplayResponse(*, categories)

Bases: DataClassJsonMixin

Model representing the complete response for the guarantees definition endpoint. Contains the full hierarchy of categories, bundles, and guarantees for a given country.

categories instance-attribute 
categories

components.guarantee_catalog.public.enums

es_category_ref

ES category identifiers from catalog_guarantees.yaml.

EsCategoryRef

Bases: AlanBaseEnum

ES category identifiers from catalog_guarantees.yaml.

These identifiers correspond to the identifier field in the categories section of the ES health plan guarantee catalog.

es_complementary_module class-attribute instance-attribute 
es_complementary_module = 'es_complementary_module'
es_core_product class-attribute instance-attribute 
es_core_product = 'es_core_product'
es_other class-attribute instance-attribute 
es_other = 'es_other'

es_guarantee_ref

ES guarantee identifiers from catalog_guarantees.yaml.

ES_ADDONS_REFS module-attribute 

ES_ADDONS_REFS = frozenset(
    {
        es_optical,
        es_pharmacy,
        es_preexisting_conditions,
        es_premium_reimbursement,
        es_physio_nutrition,
    }
)

ES_ALAN_ESSENTIAL_ALLOWED_GUARANTEES module-attribute 

ES_ALAN_ESSENTIAL_ALLOWED_GUARANTEES = frozenset(
    {es_alan_essential, es_assistance}
)

ES_CORE_PRODUCT_REFS module-attribute 

ES_CORE_PRODUCT_REFS = frozenset(
    {es_alan_essential, es_alan_access, es_alan_health}
)

EsGuaranteeRef

Bases: AlanBaseEnum

ES guarantee identifiers from catalog_guarantees.yaml.

These identifiers correspond to the identifier field in the ES health plan guarantee catalog.

es_alan_access class-attribute instance-attribute 
es_alan_access = 'es_alan_access'
es_alan_essential class-attribute instance-attribute 
es_alan_essential = 'es_alan_essential'
es_alan_health class-attribute instance-attribute 
es_alan_health = 'es_alan_health'
es_assistance class-attribute instance-attribute 
es_assistance = 'es_assistance'
es_optical class-attribute instance-attribute 
es_optical = 'es_optical'
es_pharmacy class-attribute instance-attribute 
es_pharmacy = 'es_pharmacy'
es_physio_nutrition class-attribute instance-attribute 
es_physio_nutrition = 'es_physio_nutrition'
es_preexisting_conditions class-attribute instance-attribute 
es_preexisting_conditions = 'es_preexisting_conditions'
es_premium_reimbursement class-attribute instance-attribute 
es_premium_reimbursement = 'es_premium_reimbursement'
es_therapy_session class-attribute instance-attribute 
es_therapy_session = 'es_therapy_session'

guarantee_coverage_expression_enums

DeathBasisType

Bases: AlanBaseEnum

Basis type for death / education annuity coverage rate calculations.

pass_ class-attribute instance-attribute 
pass_ = 'pass'
sr class-attribute instance-attribute 
sr = 'sr'
sr_ta class-attribute instance-attribute 
sr_ta = 'sr_ta'
sr_tb class-attribute instance-attribute 
sr_tb = 'sr_tb'
sr_tc class-attribute instance-attribute 
sr_tc = 'sr_tc'

FixedAmountFrequency

Bases: AlanBaseEnum

Payment frequency for fixed amount expressions.

monthly class-attribute instance-attribute 
monthly = 'monthly'
one_time class-attribute instance-attribute 
one_time = 'one_time'

PermanentDisabilityBasisType

Bases: AlanBaseEnum

Basis type for permanent disability coverage rate calculations.

pass_ class-attribute instance-attribute 
pass_ = 'pass'
snr class-attribute instance-attribute 
snr = 'snr'
snr_invalidity_rate class-attribute instance-attribute 
snr_invalidity_rate = 'snr_invalidity_rate'
sr class-attribute instance-attribute 
sr = 'sr'
sr_above_ta class-attribute instance-attribute 
sr_above_ta = 'sr_above_ta'
sr_invalidity_rate class-attribute instance-attribute 
sr_invalidity_rate = 'sr_invalidity_rate'
sr_ta class-attribute instance-attribute 
sr_ta = 'sr_ta'
sr_tb class-attribute instance-attribute 
sr_tb = 'sr_tb'
sr_tc class-attribute instance-attribute 
sr_tc = 'sr_tc'

SsAmountIncluded

Bases: AlanBaseEnum

How sécu (social security) amounts are included in prevoyance coverage expressions.

brut class-attribute instance-attribute 
brut = 'brut'
net class-attribute instance-attribute 
net = 'net'
not_included class-attribute instance-attribute 
not_included = 'not_included'

WorkStoppageBasisType

Bases: AlanBaseEnum

Basis type for work stoppage coverage rate calculations.

pass_ class-attribute instance-attribute 
pass_ = 'pass'
snr class-attribute instance-attribute 
snr = 'snr'
sr class-attribute instance-attribute 
sr = 'sr'
sr_above_ta class-attribute instance-attribute 
sr_above_ta = 'sr_above_ta'
sr_ta class-attribute instance-attribute 
sr_ta = 'sr_ta'
sr_tb class-attribute instance-attribute 
sr_tb = 'sr_tb'
sr_tc class-attribute instance-attribute 
sr_tc = 'sr_tc'

WorkStoppageDeductibleType

Bases: AlanBaseEnum

Deductible calculation type for work stoppage coverage expressions.

covered_days class-attribute instance-attribute 
covered_days = 'covered_days'
discontinuous class-attribute instance-attribute 
discontinuous = 'discontinuous'
discontinuous_over_12_months class-attribute instance-attribute 
discontinuous_over_12_months = (
    "discontinuous_over_12_months"
)
standard class-attribute instance-attribute 
standard = 'standard'

WorkStoppageMaxLimitAmount

Bases: AlanBaseEnum

Maximum limit amount type for work stoppage coverage expressions.

brut_reference_salary class-attribute instance-attribute 
brut_reference_salary = 'brut_reference_salary'

WorkStoppageSalaryContinuationType

Bases: AlanBaseEnum

Salary continuation type for work stoppage coverage expressions.

supplement_and_replace class-attribute instance-attribute 
supplement_and_replace = 'supplement_and_replace'

guarantee_eligible_beneficiary_enums

GuaranteeCatalogGuaranteeEligibleBeneficiaryParameterType

Bases: AlanBaseEnum

Type of parameter for a guarantee eligible beneficiary.

These parameters define additional eligibility criteria for beneficiaries. This enum is incomplete and will be filled in at a later date as we define more beneficiary parameter types.

is_dependent class-attribute instance-attribute 
is_dependent = 'is_dependent'
max_age class-attribute instance-attribute 
max_age = 'max_age'
max_age_at_status_start_date class-attribute instance-attribute 
max_age_at_status_start_date = (
    "max_age_at_status_start_date"
)
min_age class-attribute instance-attribute 
min_age = 'min_age'
status class-attribute instance-attribute 
status = 'status'

GuaranteeEligibleBeneficiaryType

Bases: AlanBaseEnum

Type of eligible beneficiary for a guarantee.

ascendant class-attribute instance-attribute 
ascendant = 'ascendant'
child class-attribute instance-attribute 
child = 'child'
declared_in_beneficiary_clause class-attribute instance-attribute 
declared_in_beneficiary_clause = (
    "declared_in_beneficiary_clause"
)
expense_payer class-attribute instance-attribute 
expense_payer = 'expense_payer'
heir class-attribute instance-attribute 
heir = 'heir'
partner class-attribute instance-attribute 
partner = 'partner'
primary class-attribute instance-attribute 
primary = 'primary'

guarantee_eligible_event_enums

EventValidReason

Bases: AlanBaseEnum

Valid reasons for eligible events (death, permanent disability, work stoppage).

accident_caused_by_third_party class-attribute instance-attribute 
accident_caused_by_third_party = (
    "accident_caused_by_third_party"
)
accident_not_caused_by_third_party class-attribute instance-attribute 
accident_not_caused_by_third_party = (
    "accident_not_caused_by_third_party"
)
accidental class-attribute instance-attribute 
accidental = 'accidental'
adoption_leave class-attribute instance-attribute 
adoption_leave = 'adoption_leave'
any class-attribute instance-attribute 
any = 'any'
disease class-attribute instance-attribute 
disease = 'disease'
maternity_leave class-attribute instance-attribute 
maternity_leave = 'maternity_leave'
paternity_leave class-attribute instance-attribute 
paternity_leave = 'paternity_leave'
professional_accident class-attribute instance-attribute 
professional_accident = 'professional_accident'
professional_disease class-attribute instance-attribute 
professional_disease = 'professional_disease'
spa_covered_by_ss class-attribute instance-attribute 
spa_covered_by_ss = 'spa_covered_by_ss'

GuaranteeCatalogGuaranteeEligibleEventParameterType

Bases: AlanBaseEnum

Type of parameter for a guarantee eligible event.

These parameters define additional eligibility criteria for events.

event_valid_reason class-attribute instance-attribute 
event_valid_reason = 'event_valid_reason'
is_covered_by_ss class-attribute instance-attribute 
is_covered_by_ss = 'is_covered_by_ss'
is_occupational_disease_or_accident class-attribute instance-attribute 
is_occupational_disease_or_accident = (
    "is_occupational_disease_or_accident"
)
max_age class-attribute instance-attribute 
max_age = 'max_age'
max_delay_months class-attribute instance-attribute 
max_delay_months = 'max_delay_months'
max_disability_category class-attribute instance-attribute 
max_disability_category = 'max_disability_category'
max_disability_rate class-attribute instance-attribute 
max_disability_rate = 'max_disability_rate'
min_disability_category class-attribute instance-attribute 
min_disability_category = 'min_disability_category'
min_disability_rate class-attribute instance-attribute 
min_disability_rate = 'min_disability_rate'
min_duration_days class-attribute instance-attribute 
min_duration_days = 'min_duration_days'
requires_hospitalization class-attribute instance-attribute 
requires_hospitalization = 'requires_hospitalization'
work_stoppage_valid_reasons class-attribute instance-attribute 
work_stoppage_valid_reasons = 'work_stoppage_valid_reasons'

GuaranteeEligibleEventType

Bases: AlanBaseEnum

Type of eligible event for a guarantee.

This is the global enum used for DB storage. Use the per-product-type sets below for validation of which event types are valid for each product.

death class-attribute instance-attribute 
death = 'death'
disabled_worker_first_recognition class-attribute instance-attribute 
disabled_worker_first_recognition = (
    "disabled_worker_first_recognition"
)
health_care class-attribute instance-attribute 
health_care = 'health_care'
permanent_disability class-attribute instance-attribute 
permanent_disability = 'permanent_disability'
work_stoppage class-attribute instance-attribute 
work_stoppage = 'work_stoppage'

GuaranteeEligibleEventUserType

Bases: AlanBaseEnum

Who the event happens to.

ascendant class-attribute instance-attribute 
ascendant = 'ascendant'
child class-attribute instance-attribute 
child = 'child'
partner class-attribute instance-attribute 
partner = 'partner'
primary class-attribute instance-attribute 
primary = 'primary'

WorkStoppageValidReason

Bases: AlanBaseEnum

Valid reasons for work stoppage events.

Synced with InternalizedWorkStoppageReason from prevoyance_claim_management.

accident_caused_by_third_party class-attribute instance-attribute 
accident_caused_by_third_party = (
    "accident_caused_by_third_party"
)
accident_not_caused_by_third_party class-attribute instance-attribute 
accident_not_caused_by_third_party = (
    "accident_not_caused_by_third_party"
)
adoption_leave class-attribute instance-attribute 
adoption_leave = 'adoption_leave'
disease class-attribute instance-attribute 
disease = 'disease'
maternity_leave class-attribute instance-attribute 
maternity_leave = 'maternity_leave'
paternity_leave class-attribute instance-attribute 
paternity_leave = 'paternity_leave'
professional_accident class-attribute instance-attribute 
professional_accident = 'professional_accident'
professional_disease class-attribute instance-attribute 
professional_disease = 'professional_disease'
spa_covered_by_ss class-attribute instance-attribute 
spa_covered_by_ss = 'spa_covered_by_ss'

guarantee_eligible_member_enums

GuaranteeCatalogGuaranteeEligibleMemberParameterType

Bases: AlanBaseEnum

Type of parameter for a guarantee eligible member.

These parameters define additional eligibility criteria for members. This enum is incomplete and will be filled in at a later date as we define more member parameter types.

has_any_dependant class-attribute instance-attribute 
has_any_dependant = 'has_any_dependant'
has_dependant_child class-attribute instance-attribute 
has_dependant_child = 'has_dependant_child'
has_partner class-attribute instance-attribute 
has_partner = 'has_partner'
is_covered_in_parental_leave class-attribute instance-attribute 
is_covered_in_parental_leave = (
    "is_covered_in_parental_leave"
)
max_hours_worked_in_trimester class-attribute instance-attribute 
max_hours_worked_in_trimester = (
    "max_hours_worked_in_trimester"
)
max_tenure_months class-attribute instance-attribute 
max_tenure_months = 'max_tenure_months'
max_tenure_or_less_than_200_hours_per_trimester class-attribute instance-attribute 
max_tenure_or_less_than_200_hours_per_trimester = (
    "max_tenure_or_less_than_200_hours_per_trimester"
)
min_covered_presence_days class-attribute instance-attribute 
min_covered_presence_days = 'min_covered_presence_days'
min_hours_worked_in_trimester class-attribute instance-attribute 
min_hours_worked_in_trimester = (
    "min_hours_worked_in_trimester"
)
min_tenure_months class-attribute instance-attribute 
min_tenure_months = 'min_tenure_months'
number_of_dependant_children class-attribute instance-attribute 
number_of_dependant_children = (
    "number_of_dependant_children"
)

GuaranteeEligibleMemberType

Bases: AlanBaseEnum

Type of eligible member for a guarantee.

partner class-attribute instance-attribute 
partner = 'partner'
primary class-attribute instance-attribute 
primary = 'primary'

guarantee_expression_type

GuaranteeExpressionType

Bases: AlanBaseEnum

Enumeration of all possible guarantee expression types. Defines how a guarantee's reimbursement is calculated.

cumulative_copayment class-attribute instance-attribute 
cumulative_copayment = 'cumulative_copayment'
cumulative_limit class-attribute instance-attribute 
cumulative_limit = 'cumulative_limit'
cumulative_limit_on_percent_reimburement_monthly_social_security_ceiling class-attribute instance-attribute 
cumulative_limit_on_percent_reimburement_monthly_social_security_ceiling = "cumulative_limit_on_percent_reimburement_monthly_social_security_ceiling"
cumulative_limit_per_side class-attribute instance-attribute 
cumulative_limit_per_side = 'cumulative_limit_per_side'
fixed_amount__monthly class-attribute instance-attribute 
fixed_amount__monthly = 'fixed_amount__monthly'
fixed_amount__monthly__x2_orphan class-attribute instance-attribute 
fixed_amount__monthly__x2_orphan = (
    "fixed_amount__monthly__x2_orphan"
)
fixed_amount__one_time class-attribute instance-attribute 
fixed_amount__one_time = 'fixed_amount__one_time'
get_before_and_after_parameter_types classmethod 
get_before_and_after_parameter_types(expression_type)

Returns the before and after parameter types (if any) for a given expression type.

Source code in components/guarantee_catalog/public/enums/guarantee_expression_type.py 
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
@classmethod
def get_before_and_after_parameter_types(
    cls, expression_type: GuaranteeExpressionType
) -> tuple[GuaranteeParameterType, GuaranteeParameterType] | None:
    """Returns the before and after parameter types (if any) for a given expression type."""
    match expression_type:
        case GuaranteeExpressionType.percent_reimbursement_ss_before_after_count_limit:
            before = GuaranteeParameterType.percent_reimbursement_ss
            after = GuaranteeParameterType.percent_reimbursement_ss_after_count_limit_reached
            return before, after
        case GuaranteeExpressionType.max_reimbursement_per_care_before_after_count_limit:
            before = GuaranteeParameterType.max_reimbursement_per_care
            after = GuaranteeParameterType.max_reimbursement_per_care_after_count_limit_reached
            return before, after
        case _:
            return None
get_pricer_main_and_extra_param_types classmethod 
get_pricer_main_and_extra_param_types(expression_type)

Returns the main and extra parameter types used by the pricer for a given expression type.

The pricer uses these parameters as inputs to compute pure premiums for guarantees: - main_parameter_type: The primary parameter that affects the pure premium calculation - extra_parameter_type: An optional secondary parameter that may also influence the calculation

For example, for percent_reimbursement_ss: - main_parameter_type is percent_reimbursement_ss - no extra_parameter_type is needed The pure premium will depend only on the value of percent_reimbursement_ss.

Parameters:

Name Type Description Default
expression_type GuaranteeExpressionType

The type of guarantee expression

 required

Returns:

Type Description
GuaranteeParameterType

A tuple containing:
Optional[GuaranteeParameterType]
  • The main parameter type (GuaranteeParameterType)
tuple[GuaranteeParameterType, Optional[GuaranteeParameterType]]
  • The extra parameter type if any, None otherwise
Source code in components/guarantee_catalog/public/enums/guarantee_expression_type.py 
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
@classmethod
def get_pricer_main_and_extra_param_types(
    cls, expression_type: GuaranteeExpressionType
) -> tuple[GuaranteeParameterType, Optional[GuaranteeParameterType]]:
    """Returns the main and extra parameter types used by the pricer for a given expression type.

    The pricer uses these parameters as inputs to compute pure premiums for guarantees:
    - main_parameter_type: The primary parameter that affects the pure premium calculation
    - extra_parameter_type: An optional secondary parameter that may also influence the calculation

    For example, for percent_reimbursement_ss:
    - main_parameter_type is percent_reimbursement_ss
    - no extra_parameter_type is needed
    The pure premium will depend only on the value of percent_reimbursement_ss.

    Args:
        expression_type: The type of guarantee expression

    Returns:
        A tuple containing:
        - The main parameter type (GuaranteeParameterType)
        - The extra parameter type if any, None otherwise
    """
    pricer_parameters: dict[
        GuaranteeExpressionType,
        tuple[GuaranteeParameterType, Optional[GuaranteeParameterType]],
    ] = {
        cls.cumulative_copayment: (
            GuaranteeParameterType.cumulative_copayment,
            None,
        ),
        cls.cumulative_limit: (GuaranteeParameterType.cumulative_limit, None),
        cls.cumulative_limit_per_side: (
            GuaranteeParameterType.cumulative_limit,
            None,
        ),
        cls.lump_sum: (GuaranteeParameterType.lump_sum, None),
        cls.max_reimbursement_per_care: (
            GuaranteeParameterType.max_reimbursement_per_care,
            None,
        ),
        cls.max_reimbursement_per_care_before_after_count_limit: (
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.max_reimbursement_per_care_after_count_limit_reached,
        ),
        cls.max_reimbursement_per_care_with_count_limit: (
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.count_limit,
        ),
        cls.max_reimbursement_per_care_with_count_limit_and_frame_amount: (
            GuaranteeParameterType.max_reimbursement_per_care,
            None,
        ),
        cls.max_reimbursement_per_care_with_cumulative_limit: (
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.max_reimbursement_per_care,
        ),
        cls.percent_reimbursement_ss: (
            GuaranteeParameterType.percent_reimbursement_ss,
            None,
        ),
        cls.percent_reimbursement_ss_before_after_count_limit: (
            GuaranteeParameterType.percent_reimbursement_ss,
            GuaranteeParameterType.percent_reimbursement_ss_after_count_limit_reached,
        ),
        cls.percent_reimbursement_ss_with_cumulative_limit: (
            GuaranteeParameterType.cumulative_limit,
            None,
        ),
        cls.percent_reimbursement_ss_with_count_limit: (
            GuaranteeParameterType.percent_reimbursement_ss,
            GuaranteeParameterType.count_limit,
        ),
        cls.percent_reimbursement_total_cost: (
            GuaranteeParameterType.percent_reimbursement_total_cost,
            None,
        ),
        cls.percent_reimbursement_total_cost_with_count_limit: (
            GuaranteeParameterType.percent_reimbursement_total_cost,
            None,
        ),
        cls.percent_reimbursement_total_cost_with_cumulative_limit: (
            GuaranteeParameterType.percent_reimbursement_total_cost,
            GuaranteeParameterType.cumulative_limit,
        ),
        cls.percent_reimbursement_with_cumulative_and_count_limit_per_side: (
            GuaranteeParameterType.cumulative_limit,
            None,
        ),
        cls.pre_post: (
            GuaranteeParameterType.pre_duration_in_months,
            GuaranteeParameterType.post_duration_in_months,
        ),
        cls.reimburse_full_cost: (GuaranteeParameterType.reimburse_full_cost, None),
        cls.reimburse_full_cost_with_count_limit: (
            GuaranteeParameterType.count_limit,
            None,
        ),
        cls.reimburse_full_cost_with_count_limit_per_side: (
            GuaranteeParameterType.reimburse_full_cost,
            None,
        ),
        cls.reimburse_full_cost_with_waiting_period: (
            GuaranteeParameterType.waiting_period_in_months,
            None,
        ),
        # Prevoyance expression types
        cls.salary_rate: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate__min_fixed_amount: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate__x2_orphan: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate__min_fixed_amount__x2_orphan: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate_ta: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate_tb: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.salary_rate_tc: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.fixed_amount__monthly: (
            GuaranteeParameterType.fixed_amount,
            None,
        ),
        cls.fixed_amount__one_time: (
            GuaranteeParameterType.fixed_amount,
            None,
        ),
        cls.fixed_amount__monthly__x2_orphan: (
            GuaranteeParameterType.fixed_amount,
            None,
        ),
        cls.pass_rate: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
        cls.pass_rate__x2_orphan: (
            GuaranteeParameterType.coverage_rate,
            None,
        ),
    }
    for expr_type in cls._prevoyance_work_stoppage_expression_types():
        pricer_parameters[expr_type] = (GuaranteeParameterType.coverage_rate, None)
    for expr_type in cls._prevoyance_permanent_disability_expression_types():
        pricer_parameters[expr_type] = (GuaranteeParameterType.coverage_rate, None)
    return pricer_parameters[expression_type]
get_required_parameter_types classmethod 
get_required_parameter_types(expression_type)

Returns set of required parameter types for a given expression type.

Source code in components/guarantee_catalog/public/enums/guarantee_expression_type.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
@classmethod
def get_required_parameter_types(
    cls, expression_type: GuaranteeExpressionType
) -> set[GuaranteeParameterType]:
    """Returns set of required parameter types for a given expression type."""
    required_parameters: dict[
        GuaranteeExpressionType, set[GuaranteeParameterType]
    ] = {
        cls.cumulative_limit: {
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.cumulative_limit_per_side: {
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.percent_reimbursement_ss: {
            GuaranteeParameterType.percent_reimbursement_ss,
        },
        cls.percent_reimbursement_total_cost: {
            GuaranteeParameterType.percent_reimbursement_total_cost,
        },
        cls.percent_reimbursement_total_cost_with_count_limit: {
            GuaranteeParameterType.percent_reimbursement_total_cost,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.percent_reimbursement_total_cost_with_cumulative_limit: {
            GuaranteeParameterType.percent_reimbursement_total_cost,
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.percent_reimbursement_ss_with_count_limit: {
            GuaranteeParameterType.percent_reimbursement_ss,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.reimburse_full_cost_with_count_limit: {
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.reimburse_full_cost,
        },
        cls.percent_reimbursement_ss_with_cumulative_limit: {
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.percent_reimbursement_ss,
        },
        cls.percent_reimbursement_with_cumulative_and_count_limit_per_side: {
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.always_reimburse_100_pct_ss,
        },
        cls.max_reimbursement_per_care: {
            GuaranteeParameterType.max_reimbursement_per_care,
        },
        cls.max_reimbursement_per_care_before_after_count_limit: {
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.max_reimbursement_per_care_after_count_limit_reached,
        },
        cls.max_reimbursement_per_care_with_count_limit: {
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.max_reimbursement_per_care_with_count_limit_and_frame_amount: {
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.frame_amount,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.max_reimbursement_per_care_with_cumulative_limit: {
            GuaranteeParameterType.max_reimbursement_per_care,
            GuaranteeParameterType.cumulative_limit,
            GuaranteeParameterType.limit_window,
        },
        cls.percent_reimbursement_ss_before_after_count_limit: {
            GuaranteeParameterType.percent_reimbursement_ss,
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.percent_reimbursement_ss_after_count_limit_reached,
        },
        cls.pre_post: {
            GuaranteeParameterType.pre_duration_in_months,
            GuaranteeParameterType.post_duration_in_months,
        },
        cls.lump_sum: {
            GuaranteeParameterType.lump_sum,
        },
        cls.cumulative_copayment: {
            GuaranteeParameterType.cumulative_copayment,
            GuaranteeParameterType.limit_window,
        },
        cls.reimburse_full_cost: {
            GuaranteeParameterType.reimburse_full_cost,
        },
        cls.reimburse_full_cost_with_count_limit_per_side: {
            GuaranteeParameterType.count_limit,
            GuaranteeParameterType.limit_window,
            GuaranteeParameterType.reimburse_full_cost,
        },
        cls.reimburse_full_cost_with_waiting_period: {
            GuaranteeParameterType.reimburse_full_cost,
            GuaranteeParameterType.waiting_period_in_months,
        },
        cls.percent_reimbursement_fixed_contribution: {
            GuaranteeParameterType.percent_reimbursement_fixed_contribution,
        },
        cls.percent_reimbursement_coinsurance: {
            GuaranteeParameterType.percent_reimbursement_coinsurance,
        },
        cls.percent_reimbursement_coinsurance_and_ss: {
            GuaranteeParameterType.percent_reimbursement_coinsurance,
            GuaranteeParameterType.percent_reimbursement_ss,
        },
        cls.percent_reimbursement_monthly_social_security_ceiling: {
            GuaranteeParameterType.percent_reimbursement_monthly_social_security_ceiling,
        },
        cls.lump_sum_and_percent_reimbursement_ss: {
            GuaranteeParameterType.lump_sum,
            GuaranteeParameterType.percent_reimbursement_ss,
        },
        cls.cumulative_limit_on_percent_reimburement_monthly_social_security_ceiling: {
            GuaranteeParameterType.percent_reimbursement_monthly_social_security_ceiling,
            GuaranteeParameterType.limit_window,
        },
        # Prevoyance expression types
        cls.salary_rate: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_rate,
            GuaranteeParameterType.min_basis,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
        },
        cls.salary_rate__min_fixed_amount: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_fixed_amount,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
        },
        cls.salary_rate__x2_orphan: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_rate,
            GuaranteeParameterType.min_basis,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
            GuaranteeParameterType.orphan_multiplier,
        },
        cls.salary_rate__min_fixed_amount__x2_orphan: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_fixed_amount,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
            GuaranteeParameterType.orphan_multiplier,
        },
        cls.salary_rate_ta: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_rate,
            GuaranteeParameterType.min_basis,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
        },
        cls.salary_rate_tb: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_rate,
            GuaranteeParameterType.min_basis,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
        },
        cls.salary_rate_tc: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.min_rate,
            GuaranteeParameterType.min_basis,
            GuaranteeParameterType.max_rate,
            GuaranteeParameterType.max_basis,
        },
        cls.fixed_amount__monthly: {
            GuaranteeParameterType.fixed_amount,
            GuaranteeParameterType.fixed_amount_frequency,
        },
        cls.fixed_amount__one_time: {
            GuaranteeParameterType.fixed_amount,
            GuaranteeParameterType.fixed_amount_frequency,
        },
        cls.fixed_amount__monthly__x2_orphan: {
            GuaranteeParameterType.fixed_amount,
            GuaranteeParameterType.fixed_amount_frequency,
            GuaranteeParameterType.orphan_multiplier,
        },
        cls.pass_rate: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
        },
        cls.pass_rate__x2_orphan: {
            GuaranteeParameterType.coverage_rate,
            GuaranteeParameterType.coverage_basis,
            GuaranteeParameterType.orphan_multiplier,
        },
    }
    # Work stoppage expression types require deductible parameters
    work_stoppage_required_parameters = {
        GuaranteeParameterType.coverage_rate,
        GuaranteeParameterType.coverage_basis,
        GuaranteeParameterType.min_rate,
        GuaranteeParameterType.min_basis,
        GuaranteeParameterType.max_rate,
        GuaranteeParameterType.max_basis,
        GuaranteeParameterType.deductible,
        GuaranteeParameterType.deductible_type,
        GuaranteeParameterType.ss_amount_included,
        GuaranteeParameterType.coverage_max_limit_amount,
    }
    for expr_type in cls._prevoyance_work_stoppage_expression_types():
        required_parameters[expr_type] = work_stoppage_required_parameters
    # Work stoppage variants that additionally require salary_continuation_type
    for expr_type in (
        cls.salary_rate__brut_ss_included__supplement_and_replacement_salary_continuation__standard_deductible,
        cls.salary_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible,
        cls.salary_ta_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible,
    ):
        required_parameters[expr_type] = work_stoppage_required_parameters | {
            GuaranteeParameterType.salary_continuation_type
        }
    # Permanent disability expression types (no deductible)
    permanent_disability_required_parameters = {
        GuaranteeParameterType.coverage_rate,
        GuaranteeParameterType.coverage_basis,
        GuaranteeParameterType.min_rate,
        GuaranteeParameterType.min_basis,
        GuaranteeParameterType.max_rate,
        GuaranteeParameterType.max_basis,
        GuaranteeParameterType.ss_amount_included,
        GuaranteeParameterType.coverage_max_limit_amount,
    }
    for expr_type in cls._prevoyance_permanent_disability_expression_types():
        required_parameters[expr_type] = permanent_disability_required_parameters
    return required_parameters[expression_type]
is_prevoyance property 
is_prevoyance

Returns True if the expression type is a prevoyance type (pricer validation skipped).

is_priceable property 
is_priceable

Returns True if the expression type is priceable, False otherwise.

lump_sum class-attribute instance-attribute 
lump_sum = 'lump_sum'
lump_sum_and_percent_reimbursement_ss class-attribute instance-attribute 
lump_sum_and_percent_reimbursement_ss = (
    "lump_sum_and_percent_reimbursement_ss"
)
max_reimbursement_per_care class-attribute instance-attribute 
max_reimbursement_per_care = 'max_reimbursement_per_care'
max_reimbursement_per_care_before_after_count_limit class-attribute instance-attribute 
max_reimbursement_per_care_before_after_count_limit = (
    "max_reimbursement_per_care_before_after_count_limit"
)
max_reimbursement_per_care_with_count_limit class-attribute instance-attribute 
max_reimbursement_per_care_with_count_limit = (
    "max_reimbursement_per_care_with_count_limit"
)
max_reimbursement_per_care_with_count_limit_and_frame_amount class-attribute instance-attribute 
max_reimbursement_per_care_with_count_limit_and_frame_amount = "max_reimbursement_per_care_with_count_limit_and_frame_amount"
max_reimbursement_per_care_with_cumulative_limit class-attribute instance-attribute 
max_reimbursement_per_care_with_cumulative_limit = (
    "max_reimbursement_per_care_with_cumulative_limit"
)
net_salary_rate__brut_ss_included class-attribute instance-attribute 
net_salary_rate__brut_ss_included = (
    "net_salary_rate__brut_ss_included"
)
net_salary_rate__brut_ss_included__discontinuous_deductible class-attribute instance-attribute 
net_salary_rate__brut_ss_included__discontinuous_deductible = "net_salary_rate__brut_ss_included__discontinuous_deductible"
net_salary_rate__brut_ss_included__invalidity_rate class-attribute instance-attribute 
net_salary_rate__brut_ss_included__invalidity_rate = (
    "net_salary_rate__brut_ss_included__invalidity_rate"
)
net_salary_rate__brut_ss_included__standard_deductible class-attribute instance-attribute 
net_salary_rate__brut_ss_included__standard_deductible = (
    "net_salary_rate__brut_ss_included__standard_deductible"
)
net_salary_rate__net_ss_included class-attribute instance-attribute 
net_salary_rate__net_ss_included = (
    "net_salary_rate__net_ss_included"
)
pass_rate class-attribute instance-attribute 
pass_rate = 'pass_rate'
pass_rate__x2_orphan class-attribute instance-attribute 
pass_rate__x2_orphan = 'pass_rate__x2_orphan'
percent_reimbursement_coinsurance class-attribute instance-attribute 
percent_reimbursement_coinsurance = (
    "percent_reimbursement_coinsurance"
)
percent_reimbursement_coinsurance_and_ss class-attribute instance-attribute 
percent_reimbursement_coinsurance_and_ss = (
    "percent_reimbursement_coinsurance_and_ss"
)
percent_reimbursement_fixed_contribution class-attribute instance-attribute 
percent_reimbursement_fixed_contribution = (
    "percent_reimbursement_fixed_contribution"
)
percent_reimbursement_monthly_social_security_ceiling class-attribute instance-attribute 
percent_reimbursement_monthly_social_security_ceiling = (
    "percent_reimbursement_monthly_social_security_ceiling"
)
percent_reimbursement_ss class-attribute instance-attribute 
percent_reimbursement_ss = 'percent_reimbursement_ss'
percent_reimbursement_ss_before_after_count_limit class-attribute instance-attribute 
percent_reimbursement_ss_before_after_count_limit = (
    "percent_reimbursement_ss_before_after_count_limit"
)
percent_reimbursement_ss_with_count_limit class-attribute instance-attribute 
percent_reimbursement_ss_with_count_limit = (
    "percent_reimbursement_ss_with_count_limit"
)
percent_reimbursement_ss_with_cumulative_limit class-attribute instance-attribute 
percent_reimbursement_ss_with_cumulative_limit = (
    "percent_reimbursement_ss_with_cumulative_limit"
)
percent_reimbursement_total_cost class-attribute instance-attribute 
percent_reimbursement_total_cost = (
    "percent_reimbursement_total_cost"
)
percent_reimbursement_total_cost_with_count_limit class-attribute instance-attribute 
percent_reimbursement_total_cost_with_count_limit = (
    "percent_reimbursement_total_cost_with_count_limit"
)
percent_reimbursement_total_cost_with_cumulative_limit class-attribute instance-attribute 
percent_reimbursement_total_cost_with_cumulative_limit = (
    "percent_reimbursement_total_cost_with_cumulative_limit"
)
percent_reimbursement_with_cumulative_and_count_limit_per_side class-attribute instance-attribute 
percent_reimbursement_with_cumulative_and_count_limit_per_side = "percent_reimbursement_with_cumulative_and_count_limit_per_side"
pre_post class-attribute instance-attribute 
pre_post = 'pre_post'
reimburse_full_cost class-attribute instance-attribute 
reimburse_full_cost = 'reimburse_full_cost'
reimburse_full_cost_with_count_limit class-attribute instance-attribute 
reimburse_full_cost_with_count_limit = (
    "reimburse_full_cost_with_count_limit"
)
reimburse_full_cost_with_count_limit_per_side class-attribute instance-attribute 
reimburse_full_cost_with_count_limit_per_side = (
    "reimburse_full_cost_with_count_limit_per_side"
)
reimburse_full_cost_with_waiting_period class-attribute instance-attribute 
reimburse_full_cost_with_waiting_period = (
    "reimburse_full_cost_with_waiting_period"
)
salary_above_ta_rate__ss_not_included class-attribute instance-attribute 
salary_above_ta_rate__ss_not_included = (
    "salary_above_ta_rate__ss_not_included"
)
salary_above_ta_rate__ss_not_included__standard_deductible class-attribute instance-attribute 
salary_above_ta_rate__ss_not_included__standard_deductible = "salary_above_ta_rate__ss_not_included__standard_deductible"
salary_rate class-attribute instance-attribute 
salary_rate = 'salary_rate'
salary_rate__brut_ss_included class-attribute instance-attribute 
salary_rate__brut_ss_included = (
    "salary_rate__brut_ss_included"
)
salary_rate__brut_ss_included__discontinuous_deductible class-attribute instance-attribute 
salary_rate__brut_ss_included__discontinuous_deductible = "salary_rate__brut_ss_included__discontinuous_deductible"
salary_rate__brut_ss_included__invalidity_rate class-attribute instance-attribute 
salary_rate__brut_ss_included__invalidity_rate = (
    "salary_rate__brut_ss_included__invalidity_rate"
)
salary_rate__brut_ss_included__standard_deductible class-attribute instance-attribute 
salary_rate__brut_ss_included__standard_deductible = (
    "salary_rate__brut_ss_included__standard_deductible"
)
salary_rate__brut_ss_included__supplement_and_replacement_salary_continuation__standard_deductible class-attribute instance-attribute 
salary_rate__brut_ss_included__supplement_and_replacement_salary_continuation__standard_deductible = "salary_rate__brut_ss_included__supplement_and_replacement_salary_continuation__standard_deductible"
salary_rate__min_fixed_amount class-attribute instance-attribute 
salary_rate__min_fixed_amount = (
    "salary_rate__min_fixed_amount"
)
salary_rate__min_fixed_amount__x2_orphan class-attribute instance-attribute 
salary_rate__min_fixed_amount__x2_orphan = (
    "salary_rate__min_fixed_amount__x2_orphan"
)
salary_rate__ss_not_included class-attribute instance-attribute 
salary_rate__ss_not_included = (
    "salary_rate__ss_not_included"
)
salary_rate__ss_not_included__invalidity_rate class-attribute instance-attribute 
salary_rate__ss_not_included__invalidity_rate = (
    "salary_rate__ss_not_included__invalidity_rate"
)
salary_rate__ss_not_included__standard_deductible class-attribute instance-attribute 
salary_rate__ss_not_included__standard_deductible = (
    "salary_rate__ss_not_included__standard_deductible"
)
salary_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible class-attribute instance-attribute 
salary_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible = "salary_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible"
salary_rate__x2_orphan class-attribute instance-attribute 
salary_rate__x2_orphan = 'salary_rate__x2_orphan'
salary_rate_ta class-attribute instance-attribute 
salary_rate_ta = 'salary_rate_ta'
salary_rate_ta__brut_ss_included class-attribute instance-attribute 
salary_rate_ta__brut_ss_included = (
    "salary_rate_ta__brut_ss_included"
)
salary_rate_tb class-attribute instance-attribute 
salary_rate_tb = 'salary_rate_tb'
salary_rate_tc class-attribute instance-attribute 
salary_rate_tc = 'salary_rate_tc'
salary_ta_rate__ss_not_included class-attribute instance-attribute 
salary_ta_rate__ss_not_included = (
    "salary_ta_rate__ss_not_included"
)
salary_ta_rate__ss_not_included__standard_deductible class-attribute instance-attribute 
salary_ta_rate__ss_not_included__standard_deductible = (
    "salary_ta_rate__ss_not_included__standard_deductible"
)
salary_ta_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible class-attribute instance-attribute 
salary_ta_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible = "salary_ta_rate__ss_not_included__supplemental_and_replacement_salary_continuation__standard_deductible"

guarantee_parameter_source

GuaranteeParameterSource

Bases: AlanBaseEnum

Enumeration defining the possible sources of a guarantee parameter value.

constant class-attribute instance-attribute 
constant = 'constant'
propagated class-attribute instance-attribute 
propagated = 'propagated'
user class-attribute instance-attribute 
user = 'user'

guarantee_parameter_type

GuaranteeParameterType

Bases: AlanBaseEnum

Enumeration of all possible guarantee parameter types.

always_reimburse_100_pct_ss class-attribute instance-attribute 
always_reimburse_100_pct_ss = 'always_reimburse_100_pct_ss'
count_limit class-attribute instance-attribute 
count_limit = 'count_limit'
coverage_basis class-attribute instance-attribute 
coverage_basis = 'coverage_basis'
coverage_max_limit_amount class-attribute instance-attribute 
coverage_max_limit_amount = 'coverage_max_limit_amount'
coverage_rate class-attribute instance-attribute 
coverage_rate = 'coverage_rate'
cumulative_copayment class-attribute instance-attribute 
cumulative_copayment = 'cumulative_copayment'
cumulative_limit class-attribute instance-attribute 
cumulative_limit = 'cumulative_limit'
deductible class-attribute instance-attribute 
deductible = 'deductible'
deductible_type class-attribute instance-attribute 
deductible_type = 'deductible_type'
fixed_amount class-attribute instance-attribute 
fixed_amount = 'fixed_amount'
fixed_amount_frequency class-attribute instance-attribute 
fixed_amount_frequency = 'fixed_amount_frequency'
format_value 
format_value(value)

Format the provided value of the parameter according to its type.

Source code in components/guarantee_catalog/public/enums/guarantee_parameter_type.py 
149
150
151
152
def format_value(self, value: Any) -> Any:
    """Format the provided value of the parameter according to its type."""
    formatter = self.get_value_formatter(self)
    return formatter(value)
frame_amount class-attribute instance-attribute 
frame_amount = 'frame_amount'
get_limit_types classmethod 
get_limit_types()

Returns set of parameter types that are limits.

Source code in components/guarantee_catalog/public/enums/guarantee_parameter_type.py 
75
76
77
78
79
80
81
82
@classmethod
def get_limit_types(cls) -> set[GuaranteeParameterType]:
    """Returns set of parameter types that are limits."""
    return {
        cls.count_limit,
        cls.limit_window,
        cls.cumulative_limit,
    }
get_valid_constant_values classmethod 
get_valid_constant_values(parameter_type, event_type=None)

Return the expected enum type for constant values, optionally scoped by event type.

Looks up by (parameter_type, event_type) first, then falls back to (parameter_type, None) for types valid across all events. Returns None if the parameter type has no constrained constant value type.

Source code in components/guarantee_catalog/public/enums/guarantee_parameter_type.py 
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
@classmethod
def get_valid_constant_values(
    cls,
    parameter_type: GuaranteeParameterType,
    event_type: GuaranteeEligibleEventType | None = None,
) -> type[Enum] | None:
    """Return the expected enum type for constant values, optionally scoped by event type.

    Looks up by (parameter_type, event_type) first, then falls back to
    (parameter_type, None) for types valid across all events.
    Returns None if the parameter type has no constrained constant value type.
    """
    from components.guarantee_catalog.public.enums.guarantee_coverage_expression_enums import (
        DeathBasisType,
        FixedAmountFrequency,
        PermanentDisabilityBasisType,
        SsAmountIncluded,
        WorkStoppageBasisType,
        WorkStoppageDeductibleType,
        WorkStoppageMaxLimitAmount,
        WorkStoppageSalaryContinuationType,
    )
    from components.guarantee_catalog.public.enums.guarantee_eligible_event_enums import (
        GuaranteeEligibleEventType,
    )

    # (parameter_type, event_type) → expected enum.
    # event_type=None means valid for all event types.
    registry: dict[
        tuple[GuaranteeParameterType, GuaranteeEligibleEventType | None],
        type[Enum],
    ] = {
        # --- work_stoppage ---
        (
            cls.coverage_basis,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageBasisType,
        (
            cls.min_basis,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageBasisType,
        (
            cls.max_basis,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageBasisType,
        (
            cls.ss_amount_included,
            GuaranteeEligibleEventType.work_stoppage,
        ): SsAmountIncluded,
        (
            cls.coverage_max_limit_amount,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageMaxLimitAmount,
        (
            cls.deductible_type,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageDeductibleType,
        (
            cls.salary_continuation_type,
            GuaranteeEligibleEventType.work_stoppage,
        ): WorkStoppageSalaryContinuationType,
        # --- death (education annuity) ---
        (
            cls.coverage_basis,
            GuaranteeEligibleEventType.death,
        ): DeathBasisType,
        (cls.min_basis, GuaranteeEligibleEventType.death): DeathBasisType,
        (cls.max_basis, GuaranteeEligibleEventType.death): DeathBasisType,
        # --- permanent_disability ---
        (
            cls.coverage_basis,
            GuaranteeEligibleEventType.permanent_disability,
        ): PermanentDisabilityBasisType,
        (
            cls.min_basis,
            GuaranteeEligibleEventType.permanent_disability,
        ): PermanentDisabilityBasisType,
        (
            cls.max_basis,
            GuaranteeEligibleEventType.permanent_disability,
        ): PermanentDisabilityBasisType,
        (
            cls.ss_amount_included,
            GuaranteeEligibleEventType.permanent_disability,
        ): SsAmountIncluded,
        (
            cls.coverage_max_limit_amount,
            GuaranteeEligibleEventType.permanent_disability,
        ): WorkStoppageMaxLimitAmount,
        # --- fixed_amount_frequency (valid for all event types) ---
        (cls.fixed_amount_frequency, None): FixedAmountFrequency,
    }

    result = registry.get((parameter_type, event_type))
    if result is not None:
        return result
    return registry.get((parameter_type, None))
get_value_formatter classmethod 
get_value_formatter(parameter_type)

Return the type of the value for the parameter.

Source code in components/guarantee_catalog/public/enums/guarantee_parameter_type.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
@classmethod
def get_value_formatter(
    cls, parameter_type: GuaranteeParameterType
) -> Callable[[Any], Any]:
    """Return the type of the value for the parameter."""
    from shared.blueprints.admin_tools.helpers import parse_bool

    if parameter_type in [
        cls.percent_reimbursement_ss,
        cls.percent_reimbursement_total_cost,
        cls.percent_reimbursement_ss_after_count_limit_reached,
        cls.count_limit,
        cls.pre_duration_in_months,
        cls.post_duration_in_months,
        cls.waiting_period_in_months,
        cls.cumulative_copayment,
        cls.percent_reimbursement_fixed_contribution,
        cls.percent_reimbursement_coinsurance,
        cls.percent_reimbursement_monthly_social_security_ceiling,
    ]:
        # Old builder product versions may store '350.0' instead of '350'
        # in their parameter value. Thus we do not use `int` directly
        return lambda x: int(float(x))
    elif parameter_type in [
        cls.max_reimbursement_per_care,
        cls.max_reimbursement_per_care_after_count_limit_reached,
        cls.frame_amount,
        cls.cumulative_limit,
        cls.lump_sum,
    ]:
        return float
    elif parameter_type in [
        cls.reimburse_full_cost,
        cls.always_reimburse_100_pct_ss,
    ]:
        return parse_bool
    elif parameter_type in [cls.limit_window]:
        return LimitWindow.validate
    elif parameter_type in [
        cls.min_rate,
        cls.max_rate,
        cls.coverage_rate,
        cls.orphan_multiplier,
        cls.deductible,
        cls.max_covered_days,
    ]:
        return lambda x: int(float(x))
    elif parameter_type in [
        cls.fixed_amount,
        cls.min_fixed_amount,
    ]:
        return float
    elif parameter_type in [
        cls.coverage_basis,
        cls.min_basis,
        cls.max_basis,
        cls.deductible_type,
        cls.ss_amount_included,
        cls.coverage_max_limit_amount,
        cls.salary_continuation_type,
        cls.fixed_amount_frequency,
    ]:
        return str
    raise ValueError(f"No value type defined for {parameter_type}")
is_valid_for_event_type classmethod 
is_valid_for_event_type(parameter_type, event_type)

Return True if parameter_type is allowed for the given event type.

A parameter is invalid only if it appears in the registry scoped to a different event type but not to this one (and not universally).

Source code in components/guarantee_catalog/public/enums/guarantee_parameter_type.py 
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
@classmethod
def is_valid_for_event_type(
    cls,
    parameter_type: GuaranteeParameterType,
    event_type: GuaranteeEligibleEventType,
) -> bool:
    """Return True if parameter_type is allowed for the given event type.

    A parameter is invalid only if it appears in the registry scoped to a
    different event type but not to this one (and not universally).
    """
    # Has a universal entry or a matching event-scoped entry → valid
    if cls.get_valid_constant_values(parameter_type, event_type) is not None:
        return True
    # Not in the registry at all → valid (no constraint)
    if cls.get_valid_constant_values(parameter_type, None) is not None:
        return True
    # Check if it's registered for some other event type
    # If so, it's invalid for this event type
    from components.guarantee_catalog.public.enums.guarantee_eligible_event_enums import (
        GuaranteeEligibleEventType as EventType,
    )

    for et in EventType:
        if (
            et != event_type
            and cls.get_valid_constant_values(parameter_type, et) is not None
        ):
            return False
    return True
limit_window class-attribute instance-attribute 
limit_window = 'limit_window'
lump_sum class-attribute instance-attribute 
lump_sum = 'lump_sum'
max_basis class-attribute instance-attribute 
max_basis = 'max_basis'
max_covered_days class-attribute instance-attribute 
max_covered_days = 'max_covered_days'
max_rate class-attribute instance-attribute 
max_rate = 'max_rate'
max_reimbursement_per_care class-attribute instance-attribute 
max_reimbursement_per_care = 'max_reimbursement_per_care'
max_reimbursement_per_care_after_count_limit_reached class-attribute instance-attribute 
max_reimbursement_per_care_after_count_limit_reached = (
    "max_reimbursement_per_care_after_count_limit_reached"
)
min_basis class-attribute instance-attribute 
min_basis = 'min_basis'
min_fixed_amount class-attribute instance-attribute 
min_fixed_amount = 'min_fixed_amount'
min_rate class-attribute instance-attribute 
min_rate = 'min_rate'
orphan_multiplier class-attribute instance-attribute 
orphan_multiplier = 'orphan_multiplier'
percent_reimbursement_coinsurance class-attribute instance-attribute 
percent_reimbursement_coinsurance = (
    "percent_reimbursement_coinsurance"
)
percent_reimbursement_fixed_contribution class-attribute instance-attribute 
percent_reimbursement_fixed_contribution = (
    "percent_reimbursement_fixed_contribution"
)
percent_reimbursement_monthly_social_security_ceiling class-attribute instance-attribute 
percent_reimbursement_monthly_social_security_ceiling = (
    "percent_reimbursement_monthly_social_security_ceiling"
)
percent_reimbursement_ss class-attribute instance-attribute 
percent_reimbursement_ss = 'percent_reimbursement_ss'
percent_reimbursement_ss_after_count_limit_reached class-attribute instance-attribute 
percent_reimbursement_ss_after_count_limit_reached = (
    "percent_reimbursement_ss_after_count_limit_reached"
)
percent_reimbursement_total_cost class-attribute instance-attribute 
percent_reimbursement_total_cost = (
    "percent_reimbursement_total_cost"
)
post_duration_in_months class-attribute instance-attribute 
post_duration_in_months = 'post_duration_in_months'
pre_duration_in_months class-attribute instance-attribute 
pre_duration_in_months = 'pre_duration_in_months'
reimburse_full_cost class-attribute instance-attribute 
reimburse_full_cost = 'reimburse_full_cost'
salary_continuation_type class-attribute instance-attribute 
salary_continuation_type = 'salary_continuation_type'
ss_amount_included class-attribute instance-attribute 
ss_amount_included = 'ss_amount_included'
waiting_period_in_months class-attribute instance-attribute 
waiting_period_in_months = 'waiting_period_in_months'

product_type

ProductType

Bases: AlanBaseEnum

Product type for guarantee catalog entities.

Represents the combination of country and insurance product line.

be_health class-attribute instance-attribute 
be_health = 'be_health'
ca_health class-attribute instance-attribute 
ca_health = 'ca_health'
es_health class-attribute instance-attribute 
es_health = 'es_health'
fr_health class-attribute instance-attribute 
fr_health = 'fr_health'
fr_prevoyance class-attribute instance-attribute 
fr_prevoyance = 'fr_prevoyance'

statuses

BundleChoiceStatus

Bases: AlanBaseEnum

Pending choices are stored in the backend, but will not be returned by the API

active class-attribute instance-attribute 
active = 'active'
deprecated class-attribute instance-attribute 
deprecated = 'deprecated'
expert class-attribute instance-attribute 
expert = 'expert'
pending class-attribute instance-attribute 
pending = 'pending'

GuaranteeExpressionStatus

Bases: AlanBaseEnum

Pending choices are stored in the backend, but will not be returned by the API

active class-attribute instance-attribute 
active = 'active'
deprecated class-attribute instance-attribute 
deprecated = 'deprecated'
expert class-attribute instance-attribute 
expert = 'expert'
pending class-attribute instance-attribute 
pending = 'pending'

components.guarantee_catalog.public.queries

guarantees_definition

get_guarantee_catalog 

get_guarantee_catalog()

Returns all guarantee categories and their complete hierarchy for the current app's product type.

Source code in components/guarantee_catalog/public/queries/guarantees_definition.py 
13
14
15
16
17
18
19
def get_guarantee_catalog() -> GuaranteeCatalog:
    """Returns all guarantee categories and their complete hierarchy for the current app's product type."""
    app_dependency = get_app_dependency()
    return _get_guarantee_catalog(
        country=app_dependency.get_country_code().value,
        product_type=app_dependency.get_product_type().value,
    )

validate_guarantee_catalog_from_yaml 

validate_guarantee_catalog_from_yaml()

Validate the guarantee catalog YAML file for the current app.

This function validates the default guarantee catalog YAML file (as configured in app dependencies) without persisting any changes. Primarily used for testing to ensure the production YAML is well-formed and meets all validation rules.

Raises:

Type Description
YAMLError

If the YAML file is malformed
GuaranteeDefinitionError

If any validation fails (parameter constraints, references, uniqueness checks, etc.)
Source code in components/guarantee_catalog/public/queries/guarantees_definition.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def validate_guarantee_catalog_from_yaml() -> None:
    """Validate the guarantee catalog YAML file for the current app.

    This function validates the default guarantee catalog YAML file (as configured in app dependencies)
    without persisting any changes. Primarily used for testing to ensure the production YAML
    is well-formed and meets all validation rules.

    Raises:
        yaml.YAMLError: If the YAML file is malformed
        GuaranteeDefinitionError: If any validation fails (parameter constraints,
            references, uniqueness checks, etc.)
    """
    app_dependency = get_app_dependency()
    parse_guarantee_catalog_yaml(
        file_path=app_dependency.get_guarantee_yaml_file_path(),
        product_type=app_dependency.get_product_type().value,
    )

validate_coverage_rules

validate_coverage_rules 

validate_coverage_rules(request)

Validates coverage rules for a given coverage against guarantee definitions.

Source code in components/guarantee_catalog/public/queries/validate_coverage_rules.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
def validate_coverage_rules(
    request: ValidateCoverageRulesRequest,
) -> list[GuaranteeCatalogError]:
    """Validates coverage rules for a given coverage against guarantee definitions."""
    app_dependency = get_app_dependency()
    global_errors = _validate_coverage_rules(
        country=app_dependency.get_country_code().value,
        product_type=app_dependency.get_product_type().value,
        request=request,
    )
    country_specific_errors = app_dependency.validate_coverage_rules(request)

    return global_errors + country_specific_errors

validate_target_coverage_rule_is_equal_or_better_than_source 

validate_target_coverage_rule_is_equal_or_better_than_source(
    source, target
)

Validate that target coverage rule is equal to or better than source coverage rule.

Source code in components/guarantee_catalog/public/queries/validate_coverage_rules.py 
30
31
32
33
34
def validate_target_coverage_rule_is_equal_or_better_than_source(
    source: CoverageRule, target: CoverageRule
) -> list[GuaranteeCatalogError]:
    """Validate that target coverage rule is equal to or better than source coverage rule."""
    return _validate_target_coverage_rule_is_equal_or_better_than_source(source, target)

components.guarantee_catalog.public.test_helpers

load_guarantee_catalog

load_guarantee_catalog 

load_guarantee_catalog(app_dependency=None)

Load the guarantee catalog.

Parameters:

Name Type Description Default
app_dependency GuaranteeCatalogDependency | None

The app dependency to use. If not provided, the default app dependency will be used.

 None
Source code in components/guarantee_catalog/public/test_helpers/load_guarantee_catalog.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def load_guarantee_catalog(
    app_dependency: GuaranteeCatalogDependency | None = None,
) -> None:
    """Load the guarantee catalog.

    Args:
        app_dependency: The app dependency to use. If not provided, the default app dependency will be used.
    """
    from components.guarantee_catalog.internal.business_logic.actions.guarantee_definitions_import.sync_guarantee_catalog import (
        load_guarantee_catalog_from_yaml,
    )

    if app_dependency is None:
        from components.guarantee_catalog.public.dependencies import get_app_dependency

        app_dependency = get_app_dependency()

    country = app_dependency.get_country_code()
    product_type = app_dependency.get_product_type()
    catalog_file_path = app_dependency.get_guarantee_yaml_file_path()

    load_guarantee_catalog_from_yaml(
        file_path=catalog_file_path,
        country=country.value,
        product_type=product_type.value,
        commit=True,
    )