egain-api-python 0.1.1__py3-none-any.whl

egain_api_python/models/retrieveresponse.py

@@ -0,0 +1,96 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .referenceresponse import ReferenceResponse, ReferenceResponseTypedDict
+from .searchresult import SearchResult, SearchResultTypedDict
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import List, Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+RetrieveResponseAnswerType = Literal["certified",]
+r"""Specifies that the answer produced was a certified answer."""
+
+
+class RetrieveResponseAnswerTypedDict(TypedDict):
+    r"""If a certified answer is given. The answer object will be present. <br><br> This will be shown only if certified answers are configured and the certified answer meets the configured threshold."""
+
+    answer_value: str
+    r"""The certified answer."""
+    references: List[ReferenceResponseTypedDict]
+    r"""Source used to produce the certified answer."""
+    answer_type: RetrieveResponseAnswerType
+    r"""Specifies that the answer produced was a certified answer."""
+    relevance_score: float
+    r"""Confidence score (0.0-1.0) reflecting how well the answer matches the query."""
+
+
+class RetrieveResponseAnswer(BaseModel):
+    r"""If a certified answer is given. The answer object will be present. <br><br> This will be shown only if certified answers are configured and the certified answer meets the configured threshold."""
+
+    answer_value: Annotated[str, pydantic.Field(alias="answerValue")]
+    r"""The certified answer."""
+
+    references: List[ReferenceResponse]
+    r"""Source used to produce the certified answer."""
+
+    answer_type: Annotated[
+        RetrieveResponseAnswerType, pydantic.Field(alias="answerType")
+    ]
+    r"""Specifies that the answer produced was a certified answer."""
+
+    relevance_score: Annotated[float, pydantic.Field(alias="relevanceScore")]
+    r"""Confidence score (0.0-1.0) reflecting how well the answer matches the query."""
+
+
+RetrieveResponseType = Literal[
+    "portal",
+    "custom",
+]
+r"""The channel where the query originated, e.g., directly from the portal or via a custom integration."""
+
+
+class RetrieveResponseChannelTypedDict(TypedDict):
+    type: RetrieveResponseType
+    r"""The channel where the query originated, e.g., directly from the portal or via a custom integration."""
+    name: NotRequired[str]
+    r"""The channel name."""
+
+
+class RetrieveResponseChannel(BaseModel):
+    type: RetrieveResponseType
+    r"""The channel where the query originated, e.g., directly from the portal or via a custom integration."""
+
+    name: Optional[str] = None
+    r"""The channel name."""
+
+
+class RetrieveResponseTypedDict(TypedDict):
+    answer: NotRequired[RetrieveResponseAnswerTypedDict]
+    r"""If a certified answer is given. The answer object will be present. <br><br> This will be shown only if certified answers are configured and the certified answer meets the configured threshold."""
+    search_results: NotRequired[List[SearchResultTypedDict]]
+    r"""Top search results with relevance scores and metadata."""
+    channel: NotRequired[RetrieveResponseChannelTypedDict]
+    event_id: NotRequired[str]
+    r"""Unique ID for this specific API call or event."""
+    session_id: NotRequired[str]
+    r"""ID that ties multiple API calls to the same user session. Will be used as part of to tie events back to a session."""
+
+
+class RetrieveResponse(BaseModel):
+    answer: Optional[RetrieveResponseAnswer] = None
+    r"""If a certified answer is given. The answer object will be present. <br><br> This will be shown only if certified answers are configured and the certified answer meets the configured threshold."""
+
+    search_results: Annotated[
+        Optional[List[SearchResult]], pydantic.Field(alias="searchResults")
+    ] = None
+    r"""Top search results with relevance scores and metadata."""
+
+    channel: Optional[RetrieveResponseChannel] = None
+
+    event_id: Annotated[Optional[str], pydantic.Field(alias="eventId")] = None
+    r"""Unique ID for this specific API call or event."""
+
+    session_id: Annotated[Optional[str], pydantic.Field(alias="sessionId")] = None
+    r"""ID that ties multiple API calls to the same user session. Will be used as part of to tie events back to a session."""

egain_api_python/models/role.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .roletemplate import RoleTemplate, RoleTemplateTypedDict
+from egain_api_python.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class RoleTypedDict(TypedDict):
+    id: str
+    r"""ID of the object"""
+    name: str
+    r"""Name of the object"""
+    template: RoleTemplateTypedDict
+    r"""Role template"""
+
+
+class Role(BaseModel):
+    id: str
+    r"""ID of the object"""
+
+    name: str
+    r"""Name of the object"""
+
+    template: RoleTemplate
+    r"""Role template"""

egain_api_python/models/roletemplate.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+import pydantic
+from typing_extensions import Annotated, TypedDict
+
+
+class RoleTemplateTypedDict(TypedDict):
+    r"""Role template"""
+
+    value: str
+    r"""Value of the role template"""
+    display_value: str
+    r"""Display value of the role template"""
+
+
+class RoleTemplate(BaseModel):
+    r"""Role template"""
+
+    value: str
+    r"""Value of the role template"""
+
+    display_value: Annotated[str, pydantic.Field(alias="displayValue")]
+    r"""Display value of the role template"""

egain_api_python/models/schemas_answer.py

@@ -0,0 +1,94 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .image import Image, ImageTypedDict
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SchemasAnswerTypedDict(TypedDict):
+    id: NotRequired[str]
+    r"""ID of the answer"""
+    depth: NotRequired[int]
+    r"""depth of the answer"""
+    is_invisible: NotRequired[bool]
+    r"""Flag indicating if answer is visible"""
+    text: NotRequired[str]
+    r"""Text of the answer"""
+    image: NotRequired[ImageTypedDict]
+    concept_name: NotRequired[str]
+    r"""name of the answer"""
+    concept_id: NotRequired[str]
+    r"""Id of the answer"""
+    lower_value: NotRequired[int]
+    r"""lower value of the answer"""
+    upper_value: NotRequired[int]
+    r"""upper value of the answer"""
+    enum_lower_value: NotRequired[str]
+    r"""lower value of enum answer"""
+    enum_upper_value: NotRequired[str]
+    r"""upper value of enum answer"""
+    lower_inclusive: NotRequired[bool]
+    r"""Value indicating if lower value is inclusive"""
+    upper_inclusive: NotRequired[bool]
+    r"""Value indicating if upper value is inclusive"""
+    partial_min: NotRequired[int]
+    r"""Partial minimum"""
+    partial_max: NotRequired[int]
+    r"""Partial maximim"""
+
+
+class SchemasAnswer(BaseModel):
+    id: Optional[str] = None
+    r"""ID of the answer"""
+
+    depth: Optional[int] = None
+    r"""depth of the answer"""
+
+    is_invisible: Annotated[Optional[bool], pydantic.Field(alias="isInvisible")] = None
+    r"""Flag indicating if answer is visible"""
+
+    text: Optional[str] = None
+    r"""Text of the answer"""
+
+    image: Optional[Image] = None
+
+    concept_name: Annotated[Optional[str], pydantic.Field(alias="conceptName")] = None
+    r"""name of the answer"""
+
+    concept_id: Annotated[Optional[str], pydantic.Field(alias="conceptId")] = None
+    r"""Id of the answer"""
+
+    lower_value: Annotated[Optional[int], pydantic.Field(alias="lowerValue")] = None
+    r"""lower value of the answer"""
+
+    upper_value: Annotated[Optional[int], pydantic.Field(alias="upperValue")] = None
+    r"""upper value of the answer"""
+
+    enum_lower_value: Annotated[
+        Optional[str], pydantic.Field(alias="enumLowerValue")
+    ] = None
+    r"""lower value of enum answer"""
+
+    enum_upper_value: Annotated[
+        Optional[str], pydantic.Field(alias="enumUpperValue")
+    ] = None
+    r"""upper value of enum answer"""
+
+    lower_inclusive: Annotated[
+        Optional[bool], pydantic.Field(alias="lowerInclusive")
+    ] = None
+    r"""Value indicating if lower value is inclusive"""
+
+    upper_inclusive: Annotated[
+        Optional[bool], pydantic.Field(alias="upperInclusive")
+    ] = None
+    r"""Value indicating if upper value is inclusive"""
+
+    partial_min: Annotated[Optional[int], pydantic.Field(alias="partialMin")] = None
+    r"""Partial minimum"""
+
+    partial_max: Annotated[Optional[int], pydantic.Field(alias="partialMax")] = None
+    r"""Partial maximim"""

egain_api_python/models/schemas_customattribute.py

@@ -0,0 +1,35 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+SchemasCustomAttributeType = Literal[
+    "STRING",
+    "INTEGER",
+    "BOOLEAN",
+    "DATETIME",
+]
+r"""The custom attribute's type."""
+
+
+class SchemasCustomAttributeTypedDict(TypedDict):
+    name: NotRequired[str]
+    r"""The custom attribute's name."""
+    value: NotRequired[str]
+    r"""The custom attribute's value."""
+    type: NotRequired[SchemasCustomAttributeType]
+    r"""The custom attribute's type."""
+
+
+class SchemasCustomAttribute(BaseModel):
+    name: Optional[str] = None
+    r"""The custom attribute's name."""
+
+    value: Optional[str] = None
+    r"""The custom attribute's value."""
+
+    type: Optional[SchemasCustomAttributeType] = None
+    r"""The custom attribute's type."""

egain_api_python/models/schemas_link.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SchemasLinkTypedDict(TypedDict):
+    rel: NotRequired[str]
+    r"""Defines the relationship between a linked resource and the current document.<br><br>For example: self, prev, next or an object name such as 'user', 'folder' etc."""
+    href: NotRequired[str]
+    r"""The URL that specifies the link's destination."""
+    default: NotRequired[bool]
+    r"""Determines if this is a default link."""
+
+
+class SchemasLink(BaseModel):
+    rel: Optional[str] = None
+    r"""Defines the relationship between a linked resource and the current document.<br><br>For example: self, prev, next or an object name such as 'user', 'folder' etc."""
+
+    href: Optional[str] = None
+    r"""The URL that specifies the link's destination."""
+
+    default: Annotated[Optional[bool], pydantic.Field(alias="_default")] = None
+    r"""Determines if this is a default link."""

egain_api_python/models/schemas_tag.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SchemasTagTypedDict(TypedDict):
+    id: NotRequired[str]
+    r"""The unique identifier for the tag."""
+    name: NotRequired[str]
+    r"""The name of the tag."""
+
+
+class SchemasTag(BaseModel):
+    id: Optional[str] = None
+    r"""The unique identifier for the tag."""
+
+    name: Optional[str] = None
+    r"""The name of the tag."""

egain_api_python/models/schemas_tagcategory.py

@@ -0,0 +1,75 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .schemas_tag import SchemasTag, SchemasTagTypedDict
+from .schemas_taggroup import SchemasTagGroup, SchemasTagGroupTypedDict
+from .userview import UserView, UserViewTypedDict
+from datetime import datetime
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreatedDateAndTimeTypedDict(TypedDict):
+    r"""Date the Tag Category was created."""
+
+    date_: datetime
+    r"""The date in the format <code>YYYY-MM-DDTHH:MM:SS</code>."""
+    user: NotRequired[UserViewTypedDict]
+
+
+class CreatedDateAndTime(BaseModel):
+    r"""Date the Tag Category was created."""
+
+    date_: Annotated[datetime, pydantic.Field(alias="date")]
+    r"""The date in the format <code>YYYY-MM-DDTHH:MM:SS</code>."""
+
+    user: Optional[UserView] = None
+
+
+class LastModifiedDateAndTimeTypedDict(TypedDict):
+    r"""Date of last modification."""
+
+    date_: datetime
+    r"""The date in the format <code>YYYY-MM-DDTHH:MM:SS</code>."""
+    user: NotRequired[UserViewTypedDict]
+
+
+class LastModifiedDateAndTime(BaseModel):
+    r"""Date of last modification."""
+
+    date_: Annotated[datetime, pydantic.Field(alias="date")]
+    r"""The date in the format <code>YYYY-MM-DDTHH:MM:SS</code>."""
+
+    user: Optional[UserView] = None
+
+
+class SchemasTagCategoryTypedDict(TypedDict):
+    name: NotRequired[str]
+    r"""name of the tag category."""
+    tag_group: NotRequired[List[SchemasTagGroupTypedDict]]
+    tag: NotRequired[List[SchemasTagTypedDict]]
+    created: NotRequired[CreatedDateAndTimeTypedDict]
+    r"""Date the Tag Category was created."""
+    last_modified: NotRequired[LastModifiedDateAndTimeTypedDict]
+    r"""Date of last modification."""
+
+
+class SchemasTagCategory(BaseModel):
+    name: Optional[str] = None
+    r"""name of the tag category."""
+
+    tag_group: Annotated[
+        Optional[List[SchemasTagGroup]], pydantic.Field(alias="tagGroup")
+    ] = None
+
+    tag: Optional[List[SchemasTag]] = None
+
+    created: Optional[CreatedDateAndTime] = None
+    r"""Date the Tag Category was created."""
+
+    last_modified: Annotated[
+        Optional[LastModifiedDateAndTime], pydantic.Field(alias="lastModified")
+    ] = None
+    r"""Date of last modification."""

egain_api_python/models/schemas_taggroup.py

@@ -0,0 +1,31 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .schemas_tag import SchemasTag, SchemasTagTypedDict
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SchemasTagGroupTypedDict(TypedDict):
+    id: NotRequired[str]
+    r"""The unique identifier for the tag group."""
+    name: NotRequired[str]
+    r"""Name of the tag group."""
+    tag_group: NotRequired[List[SchemasTagGroupTypedDict]]
+    tag: NotRequired[List[SchemasTagTypedDict]]
+
+
+class SchemasTagGroup(BaseModel):
+    id: Optional[str] = None
+    r"""The unique identifier for the tag group."""
+
+    name: Optional[str] = None
+    r"""Name of the tag group."""
+
+    tag_group: Annotated[
+        Optional[List[SchemasTagGroup]], pydantic.Field(alias="tagGroup")
+    ] = None
+
+    tag: Optional[List[SchemasTag]] = None

egain_api_python/models/schemas_tags.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SchemasTagsTypedDict(TypedDict):
+    id: NotRequired[str]
+    r"""Tag Category ID"""
+    tags: NotRequired[List[str]]
+
+
+class SchemasTags(BaseModel):
+    id: Optional[str] = None
+    r"""Tag Category ID"""
+
+    tags: Optional[List[str]] = None

egain_api_python/models/schemas_wserrorcommon.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from egain_api_python.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SchemasWSErrorCommonDetailTypedDict(TypedDict):
+    key: str
+    value: NotRequired[str]
+
+
+class SchemasWSErrorCommonDetail(BaseModel):
+    key: str
+
+    value: Optional[str] = None

egain_api_python/models/searchfilterattribute.py

@@ -0,0 +1,61 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .stringattributevalue import StringAttributeValue, StringAttributeValueTypedDict
+from egain_api_python.types import BaseModel
+import pydantic
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+ValueType = Literal[
+    "String",
+    "Integer",
+    "Decimal",
+    "Date",
+    "Boolean",
+]
+r"""The data type of the value of the attribute."""
+
+
+class SearchFilterAttributeTypedDict(TypedDict):
+    r"""This includes the custom attributes that have been added to the portal for filtering."""
+
+    internal_name: NotRequired[str]
+    r"""The internal name of a custom attribute."""
+    external_name: NotRequired[str]
+    r"""The external or public name of a custom attribute."""
+    value_type: NotRequired[ValueType]
+    r"""The data type of the value of the attribute."""
+    is_enumerated: NotRequired[bool]
+    r"""Whether the valueType is enumerated."""
+    is_multiselect: NotRequired[bool]
+    r"""Whether the user can select multiple values."""
+    value: NotRequired[StringAttributeValueTypedDict]
+    r"""An attribute can have an external value such as a readable label, and an internal value such as a unique ID. This schema provides both the internal and external values for one attribute."""
+
+
+class SearchFilterAttribute(BaseModel):
+    r"""This includes the custom attributes that have been added to the portal for filtering."""
+
+    internal_name: Annotated[Optional[str], pydantic.Field(alias="internalName")] = None
+    r"""The internal name of a custom attribute."""
+
+    external_name: Annotated[Optional[str], pydantic.Field(alias="externalName")] = None
+    r"""The external or public name of a custom attribute."""
+
+    value_type: Annotated[Optional[ValueType], pydantic.Field(alias="valueType")] = None
+    r"""The data type of the value of the attribute."""
+
+    is_enumerated: Annotated[Optional[bool], pydantic.Field(alias="isEnumerated")] = (
+        None
+    )
+    r"""Whether the valueType is enumerated."""
+
+    is_multiselect: Annotated[Optional[bool], pydantic.Field(alias="isMultiselect")] = (
+        None
+    )
+    r"""Whether the user can select multiple values."""
+
+    value: Optional[StringAttributeValue] = None
+    r"""An attribute can have an external value such as a readable label, and an internal value such as a unique ID. This schema provides both the internal and external values for one attribute."""

egain_api_python/models/searchpriortoescalationop.py

@@ -0,0 +1,108 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .acceptlanguage import AcceptLanguage
+from .optionalarticleattributes import OptionalArticleAttributes
+from egain_api_python.types import BaseModel
+from egain_api_python.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    PathParamMetadata,
+    QueryParamMetadata,
+)
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchPriorToEscalationRequestTypedDict(TypedDict):
+    accept_language: AcceptLanguage
+    r"""The Language locale accepted by the client (used for locale specific fields in resource representation and in error responses)."""
+    portal_id: str
+    r"""The ID of the portal being accessed.<br><br>A portal ID is composed of a 2-4 letter prefix, followed by a dash and 4-15 digits."""
+    escalation_id: str
+    r"""The ID (uuid) of the customer escalation.
+
+    """
+    filter_articles_in_topic_tree: NotRequired[str]
+    r"""This parameter will restrict the search scope to the provided topic and it's sub topic."""
+    additional_attributes: NotRequired[OptionalArticleAttributes]
+    r"""The fields of the article to be returned."""
+    max_results: NotRequired[int]
+    r"""The \"maxResults\" parameter specifies the number of articles that should be included in the response.
+
+    It is only required when the escalation type is chat escalation.If not specified then default value 5 will be considered for chat escalation.
+
+    If the escalation type is email, the maximum results value specified in the portal settings for email escalation will be taken into consideration.
+
+    """
+    pagenum: NotRequired[int]
+    r"""Pagination parameter that specifies the page number of results to be returned. Used in conjunction with $pagesize."""
+    pagesize: NotRequired[int]
+    r"""Pagination parameter that specifies the number of results per page. Used in conjunction with $pagenum.<br>Valid range of 5-75<br>_Default value_: 25"""
+
+
+class SearchPriorToEscalationRequest(BaseModel):
+    accept_language: Annotated[
+        AcceptLanguage,
+        pydantic.Field(alias="Accept-Language"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ]
+    r"""The Language locale accepted by the client (used for locale specific fields in resource representation and in error responses)."""
+
+    portal_id: Annotated[
+        str,
+        pydantic.Field(alias="portalID"),
+        FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
+    ]
+    r"""The ID of the portal being accessed.<br><br>A portal ID is composed of a 2-4 letter prefix, followed by a dash and 4-15 digits."""
+
+    escalation_id: Annotated[
+        str,
+        pydantic.Field(alias="escalationId"),
+        FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
+    ]
+    r"""The ID (uuid) of the customer escalation.
+
+    """
+
+    filter_articles_in_topic_tree: Annotated[
+        Optional[str],
+        pydantic.Field(alias="filter[articles-in-topic-tree]"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""This parameter will restrict the search scope to the provided topic and it's sub topic."""
+
+    additional_attributes: Annotated[
+        Optional[OptionalArticleAttributes],
+        pydantic.Field(alias="additionalAttributes"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""The fields of the article to be returned."""
+
+    max_results: Annotated[
+        Optional[int],
+        pydantic.Field(alias="maxResults"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""The \"maxResults\" parameter specifies the number of articles that should be included in the response.
+
+    It is only required when the escalation type is chat escalation.If not specified then default value 5 will be considered for chat escalation.
+
+    If the escalation type is email, the maximum results value specified in the portal settings for email escalation will be taken into consideration.
+
+    """
+
+    pagenum: Annotated[
+        Optional[int],
+        pydantic.Field(alias="$pagenum"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 1
+    r"""Pagination parameter that specifies the page number of results to be returned. Used in conjunction with $pagesize."""
+
+    pagesize: Annotated[
+        Optional[int],
+        pydantic.Field(alias="$pagesize"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 25
+    r"""Pagination parameter that specifies the number of results per page. Used in conjunction with $pagenum.<br>Valid range of 5-75<br>_Default value_: 25"""